text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int q[5];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
int i = 0;
printf2 ("prod: trying\\n");
while (done == 0)
{
i++;
pthread_mutex_lock (&mq);
... | 1 |
#include <pthread.h>
int q[3];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 3)
... | 0 |
#include <pthread.h>
pthread_mutex_t pmutex;
pthread_mutex_t gmutex;
union semun
{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
int semid = -1;
void getChopsticks(int num)
{
int left = num;
int right = (num+1)%5;
struct sembuf sem[2] = {{left,... | 1 |
#include <pthread.h>
static pthread_cond_t condvar;
static bool child_ready;
static pthread_mutex_t lock;
static void
handler(int sig)
{
print("in handler %d\\n", sig);
pthread_mutex_lock(&lock);
child_ready = 1;
pthread_cond_signal(&condvar);
pthread_mutex_unlock(&lock);
}... | 0 |
#include <pthread.h>
int GlobalGeneratedValues[10*10];
pthread_mutex_t mutexsum;
void *GenerateValues(void *threadid)
{
int taskId;
taskId = (int)threadid;
int i=0, tmepvalue;
int LocalThreadGeneratedValues[10];
for (i =0; i <= 10; i++)
{
tmepvalue = rand() % 11;
while (tmepvalue =... | 1 |
#include <pthread.h>
volatile int myInt = 1;
pthread_mutex_t myLock;
void *readInt(void *numberOfLoops)
{
int i=0;
int localInt = 0;
for (i=0; i<*((int*)numberOfLoops); i++)
{
pthread_mutex_lock(&myLock);
localInt = myInt;
pthread_mutex_unlock(&myLo... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
}thread,*pthread;
void *threadfunc(void *p)
{
int ret;
pthread id=(pthread)p;
printf("process id:%d,chlid pthread id:%lu be waiting!\\n",getpid(),pthread_self());
pthread_mutex_lock(&id->mutex);
ret=pthread_cond_wait(&id->con... | 1 |
#include <pthread.h>
char wkeyerbuffer[400] = "";
int data_ready = 0;
pthread_mutex_t keybuffer_mutex = PTHREAD_MUTEX_INITIALIZER;
void keyer_append(const char *string) {
pthread_mutex_lock( &keybuffer_mutex );
g_strlcat(wkeyerbuffer, string, sizeof(wkeyerbuffer));
data_ready = 1;... | 0 |
#include <pthread.h>
struct zc_queue create_queue() {
struct zc_queue queue = {
.first = 0,
.last = 0,
.mutex = 0,
};
check(pthread_mutex_init(&queue.mutex, 0) == 0, "ERROR DURING MUTEX INIT");
check(pthread_cond_init(&queue.cond, 0) == 0, "... | 1 |
#include <pthread.h>
const int nr_threads = 4;
int port;
char* data;
int size;
int nr_requests;
pthread_mutex_t lock;
unsigned long total = 0;
int nr_accepted = 0;
const char* HOST = 0;
void* worker(void* arg) {
int i;
for (i = 0; i < nr_requests / nr_threads; ++i) {
int sfd;
int ret;
u3... | 0 |
#include <pthread.h>
int main(int argc, char *argv[]) {
int num_mutexes = 5;
if (argc > 1) num_mutexes = atoi(argv[1]);
pthread_mutex_t m[num_mutexes];
for (int i = 0; i < num_mutexes; ++i)
pthread_mutex_init(&m[i], 0);
for (int i = 0; i < num_mutexes - 1; ++i) {
pthread... | 1 |
#include <pthread.h>
int pthread_getschedparam (pthread_t thread_id,
int *policy,
struct sched_param *param)
{
int ret = 0;
posix_thread_t *thread;
pthread_mutex_lock(&_posix_threads_mutex);
thr... | 0 |
#include <pthread.h>
volatile int tab[5];
pthread_mutex_t mutex;
void *
lire (void *arg)
{
int i;
pthread_mutex_lock (&mutex);
for (i = 0; i != 5; i++)
printf ("Thread lecture: tab[%d] vaut %d\\n", i, tab[i]);
pthread_mutex_unlock (&mutex);
pthread_exit (0);
}
void *
ecri... | 1 |
#include <pthread.h>
static int classificacao = 1;
static pthread_mutex_t lock;
static void* Correr(void* sapo);
int main()
{
classificacao = 1;
pthread_t threads[5];
int t;
printf("Corrida iniciada...\\n");
for(t = 0; t < 5; t++)
{
pthread_create(&threads[t], 0, Correr, (void *)t... | 0 |
#include <pthread.h>
int end;
int p,q;
char buffer[5];
pthread_mutex_t mutex;
pthread_cond_t empty,full;
int thread_no;
int partial_count;
} thdata;
void producer_func(FILE *fp){
char s1;
s1 = fgetc(fp);
while(1){
pthread_mutex_lock(&mutex);
buffer[p] = s... | 1 |
#include <pthread.h>
int bitmap[5000];
int init;
int num_alloc;
pthread_mutex_t lock;
} pid_table;
pid_table ptable;
int allocate_map(void)
{
int i;
if (ptable.init) {
return 1;
}
for (i = 0; i < 5000; i++) {
ptable.bitmap[i] = 0;
}
... | 0 |
#include <pthread.h>
struct gw
{
void *thingplus;
char *id;
bool connected;
int nr_sensor;
struct sensor *sensor;
timer_t timer_id;
pthread_mutex_t wait_thingplus_done_mutex;
pthread_cond_t wait_thingplus_done;
};
static struct gw *gw = 0;
static unsigned long long _now_ms(void)
{
... | 1 |
#include <pthread.h>
struct file_path {
int tag;
char path[1024];
int flag;
int fd;
};
struct thread_arg {
int fd;
char *data;
uint64_t size;
int id;
};
struct file_path fp[(1000)];
char cpath[(1000)][1024];
int fp_flag[(1000)];
pthread_t writer_thread[(1000)];
struct thread_arg w... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutexattr_t mutex_attrs;
pthread_t thread_A, thread_B;
int global_var;
void *thread_func_A(void *arg)
{
char *message = arg;
int ret;
printf("%s \\n", message);
pthread_mutex_lock(&mutex);
global_var = 5;
pthread_mutex_unlock(&mute... | 1 |
#include <pthread.h>
int thread_count;
char theArray[1024][1000];
int* seed;
pthread_mutex_t mutex;
void *Operate(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
int i;
double start, finish, elapsed;
thread_count = strtol(argv[1], 0, 10);
se... | 0 |
#include <pthread.h>
void *sum(void *p);
unsigned long int psum[8 * 64];
unsigned long int sumtotal = 0;
unsigned long int n;
int numthreads;
pthread_mutex_t mutex;
int main(int argc, char **argv) {
pthread_t tid[8];
int i, myid[8];
struct timeval start, end;
gettimeofday(&start, 0);
... | 1 |
#include <pthread.h>
sem_t *sem_consume;
sem_t *sem_produce;
pthread_mutex_t mutex;
buffer_item buffer[5];
int head = 0;
int tail = 0;
int count = 0;
void sleep_rand() {
sleep(rand() % 5 + 1);
}
int insert_item(buffer_item item) {
sem_wait(sem_produce);
pthread_mutex_lock(&mutex);
if ... | 0 |
#include <pthread.h>
double start_time, end_time;
pthread_mutex_t palindromicsMutex;
pthread_mutex_t wordsMutex;
struct thread_data {
long noPalindromes;
FILE* wordsfd;
FILE* palindromicsfd;
};
double read_timer()
{
static bool initialized = 0;
static struct timeval start;
... | 1 |
#include <pthread.h>
int id;
int lap;
int v;
int broken;
int d;
int track;
int points;
int step;
} cyclist;
int d, n, v;
int debug;
pthread_t* t;
cyclist** comp;
int** velodrome;
int readyCount;
pthread_mutex_t readyMutex;
pthread_cond_t allReady;
pthread_mutex_t** mutex;
pthrea... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0)
err_exit(err, "sigwait failed");
swi... | 1 |
#include <pthread.h>
double estimatePi(int, int);
void * monteCarlo(void *);
int circleCount = 0;
pthread_mutex_t count_mutex;
time_t seed;
int main(int argc, char *argv[]) {
int i;
pthread_t threads[10];
pthread_mutex_init(&count_mutex, 0);
seed = time(0);
for(i = 0; i < 10; ++i... | 0 |
#include <pthread.h>
struct AutoFreePool_callback {
void (* callback)(void * context);
void * context;
};
struct AutoFreePool {
unsigned int numberOfAddresses;
unsigned int addressListSize;
void ** addresses;
unsigned int numberOfCallbacks;
unsigned int callbackListSize;
struct AutoFree... | 1 |
#include <pthread.h>
pthread_t *consumitors;
pthread_t productor;
sem_t prod_sem, cons_sem;
int productor_pointer, consumitor_pointer, prod_end;
char **thread_buffer;
int thread_buffer_size;
int thread_consumitors_num;
char * (*productor_extract_data) (void);
int (*productor_continue) (v... | 0 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
int isRed1 (int s) {
return s == 2;
}
int isRed2 (int s) {
return s == 2;
}
void * signal1(void* d) {
int status = 0;
b1:
printf("1 -> GREEN\\n");
sleep... | 1 |
#include <pthread.h>
void * theif (void * param) {
int balance;
int stolen = 0;
pthread_mutex_t * mutex = (pthread_mutex_t *) param;
while ( 1 )
{
pthread_mutex_lock(mutex);
FILE * file = fopen ("account.txt", "r");
fscanf ( file, "%d", &balance);
fclose(file);
if ( balance ==... | 0 |
#include <pthread.h>
pthread_mutex_t prod_cons_mutex;
pthread_cond_t prod_cons_cond;
int cantProdCons = 1,
buffer = 0;
int generateItem();
void *producir(void *index)
{
int fibIndex = (int) index;
printf("Estoy en el hilo productor Nª %d..\\n", fibIndex);
while ( 1 ) {
s... | 1 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_function(void *arg)
{
int index;
pthread_mutex_lock(&mutex);
for(index=1;index<6;index++)
{
sum += index;
printf("Thread : %d is running : sum : %d index : %d\\n",*((unsigned int ... | 0 |
#include <pthread.h>
pthread_mutex_t buffer_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t datosLeidos_lock = PTHREAD_MUTEX_INITIALIZER;
sem_t hay_datos;
sem_t hay_sitio;
int Nhilos, Nnumeros, Tambuffer;
int datosLeidos = 0;
int *buffer;
int in = 0;
int out = 0;
int esPrimo(int n){
i... | 1 |
#include <pthread.h>
pthread_mutex_t atomic64;
pthread_mutex_t atomic32;
int64_t atomicRead64(int64_t* i) {
pthread_mutex_lock(&atomic64);
int64_t r = *i;
pthread_mutex_unlock(&atomic64);
return r;
}
void atomicWrite64(int64_t* i, int64_t v) {
pthread_mutex_lock(&atomic64);
*i = v;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
const char * function3(int *test){
static char strBuff[16];
sprintf(strBuff, "%d", *test);
printf("%s", strBuff);
return strBuff;
}
void *function1(void *arg... | 1 |
#include <pthread.h>
int mutex_set_int(pthread_mutex_t *mutex, int *i, int value)
{
pthread_mutex_lock(mutex);
*i = value;
pthread_mutex_unlock(mutex);
return (0);
}
| 0 |
#include <pthread.h>
void InitLock(void *pv_lock) {
pthread_mutex_t *p_lock = (pthread_mutex_t *)pv_lock;
pthread_mutex_init(p_lock, 0);
}
void EnterLock(void *pv_lock) {
pthread_mutex_t *p_lock = (pthread_mutex_t *)pv_lock;
pthread_mutex_lock(p_lock);
}
void LeaveLock(void *p... | 1 |
#include <pthread.h>
int buffer[10];
int rear = 0;
int front = -1;
int count = 0;
int resourceAccess = 0;
int readerPriorityFlag = 0;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cons_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t prod_cond = PTHREAD_COND_INITIALIZER;
pthre... | 0 |
#include <pthread.h>
int tickets=10;
pthread_mutex_t mutex;
pthread_cond_t cond;
void* s_func(void* p)
{
int i=(int)p;
while(1)
{
pthread_mutex_lock(&mutex);
if(tickets >0)
{
printf("I am windows %d,tickets=%d\\n",i,tickets);
tickets--;
if(0==tickets)
pthread_cond_signal(&c... | 1 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *
foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) != 0) {
f... | 0 |
#include <pthread.h>
pthread_mutex_t mutex ;
pthread_cond_t cond_pro, cond_con ;
void* handle(void* arg)
{
int* pt = (int*)arg ;
int soldn = 0 ;
int tmp ;
while(1)
{
pthread_mutex_lock(&mutex);
while( *pt == 0)
{
printf("no tickets!\\n");
pthread_cond_signal(&cond_pro);
p... | 1 |
#include <pthread.h>
char* outboard;
char* inboard;
int nrows;
int ncols;
int gens_max;
pthread_mutex_t lock;
} arguments;
arguments * struct_alloc_initialize();
void struct_alloc_set_fields(arguments * args, char* outboard, char* inboard, const int nrows, const int ncols, const int g... | 0 |
#include <pthread.h>
void *do_image(void *);
void *do_chat(void *);
int pushClient(int);
int popClient(int);
int pushClientImage(int);
int popClientImage(int);
pthread_t thread;
pthread_mutex_t mutex;
pthread_mutex_t mutex_image;
int list_c[10];
int list_c_i[10];
char greeting[]="Welcome to... | 1 |
#include <pthread.h>
extern int _shutdown;
extern struct s_conf conf;
struct gps_data_t *gpsd_data = 0, *gpsd_data_new = 0;
pthread_t t_gps_update;
pthread_mutex_t mutex_gps;
double db_interval = 5.0f;
double db_last = 0.0f;
static void *gpsd_update_thread(void *arg) {
logger("GPS: Updat... | 0 |
#include <pthread.h>
int port, portlow, porthigh;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *scan(void *arg)
{
int sd;
struct sockaddr_in servaddr;
struct servent *srvport;
struct hostent* hp;
char *argv1 = (char*)arg;
hp = gethostbyname(argv1);
if (hp == 0) {
h... | 1 |
#include <pthread.h>
int randomNum, divisor=2;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
void *send_random(void *lfdInput){
int parameter, checkPrime=0;
memcpy(¶meter,(int *)lfdInput,sizeof(int));
int cfd=0;
char sBuffer[1044], rBuffer[1044];
memset(sBu... | 0 |
#include <pthread.h>
{
int Buffer;
sem_t Bloqueado;
}Tarjeta_Red;
pthread_mutex_t Mutex_Requerido = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t Cond_Tarjeta_Disponible = PTHREAD_COND_INITIALIZER;
void Inicio(Tarjeta_Red *TR);
void Envio_Recepcion_Datos(Tarjeta_Red *TR, int IRQ);
void Cier... | 1 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
};
struct s *new(int x) {
struct s *p = malloc(sizeof(struct s));
p->datum = x;
p->next = 0;
return p;
}
void list_add(struct s *node, struct s *list) {
struct s *temp = list->next;
list->next = node;
node->next = te... | 0 |
#include <pthread.h>
{
void * (*start_routine)(void *);
void * arg;
pthread_mutex_t lock;
pthread_cond_t wait;
struct itimerval itimer;
} wrapper_t;
static void * wrapper_routine(void *);
int gprof_pthread_create(pthread_t * thread, pthread_attr_t * attr,
... | 1 |
#include <pthread.h>
int addLobby(char *nazev);
int removeLobby(int index);
int addPlayer(int indexHrac, int indexLobby);
int removePlayer(int indexHrac, int indexLobby);
struct Lobby* boostLobby();
struct Lobby* reduceLobby(int index);
int initLobby();
int uvolniLobby();
struct Lobby *... | 0 |
#include <pthread.h>
double res = .0, a = .0, b = 2 * atan(1.0), h;
int n = 100000, loc_n;
pthread_mutex_t mut;
int thread_count;
void parsearg(int, char **);
double f(double);
void * func(void *);
double integate(double, double);
int main(int argc, char ** argv)
{
parsearg(argc, argv);
int... | 1 |
#include <pthread.h>
int B[4];
int in_ptr, out_ptr;
int count;
pthread_cond_t full, empty;
pthread_mutex_t lock;
void *thread_A(void *arg) {
int i, data;
for (i = 0; i < 20; i++) {
data = i;
pthread_mutex_lock(&lock);
while (count >= 4) pthread_cond_wait(&full, &... | 0 |
#include <pthread.h>
char buf[1024];
int occupied;
int nextin;
int nextout;
pthread_mutex_t lock;
pthread_cond_t more;
pthread_cond_t less;
} buffer_t;
void buffer_init(buffer_t *);
void buffer_free(buffer_t *);
void producer(buffer_t *, char);
char consumer(buffer_t *);
void produ... | 1 |
#include <pthread.h>
int num=0;
pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qready=PTHREAD_COND_INITIALIZER;
void* thread_func(void *arg)
{
int param=(int)arg;
int count=1;
while(1)
{
pthread_mutex_lock(&mylock);
while(param!=num)
pthread_cond_wait(&qready,&myloc... | 0 |
#include <pthread.h>
int ncount;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* do_loop(void *data)
{
int i;
pthread_mutex_lock(&mutex);
for (i = 0; i < 10; i++)
{
printf("loop1 : %d\\n", ncount);
ncount ++;
sleep(1);
}
pthread_mutex_unlock(&mutex);
}
void* do_loop2(void... | 1 |
#include <pthread.h>
int SharedVariable = 0;
pthread_mutex_t lock_x;
static pthread_barrier_t barrier;
bool isPositiveNumber(char number[])
{
int i = 0;
if (number[0] == '-')
return 0;
for (; number[i] != 0; i++)
{
if (!isdigit(number[i]))
return ... | 0 |
#include <pthread.h>
int main() {
pthread_mutex_t m;
pthread_cond_t c;
pthread_condattr_t at;
struct timespec ts0, ts1, ts2;
int res;
u64 sleep;
pthread_mutex_init(&m, 0);
pthread_condattr_init(&at);
pthread_condattr_setclock(&at, CLOCK_MONOTONIC);
pthread_cond_init(&c, &at);
... | 1 |
#include <pthread.h>
buffer_t buffer[5];
int buffer_index;
pthread_mutex_t buffer_mutex;
sem_t full_sem;
sem_t empty_sem;
void insertbuffer(buffer_t value) {
if (buffer_index < 5) {
buffer[buffer_index++] = value;
} else {
printf("Buffer overflow\\n");
}
}
b... | 0 |
#include <pthread.h>
pthread_t thread[11];
pthread_mutex_t mut;
int data[9][9];
int a = 0, b = 0, i = 0, j = 0, k = 0, m = 0, err = 0, err1 = 0;
void read_data()
{
FILE *fp = fopen("sudoku.txt", "r");
if(fp == 0)
{
printf("cannot open the file\\n");
exit(0);
}... | 1 |
#include <pthread.h>
void *Worker(void *);
void InitializeGrids();
void Barrier();
pthread_mutex_t barrier;
pthread_cond_t go;
int numArrived = 0;
int gridSize, numWorkers, numIters, stripSize;
double grid1[258], grid2[258];
int main(int argc, char *argv[]) {
pthread_t workerid[16]... | 0 |
#include <pthread.h>
{
struct LinkTableNode * pNext;
}tLinkTableNode;
{
tLinkTableNode *pHead;
tLinkTableNode *pTail;
int SumOfNode;
pthread_mutex_t mutex;
}tLinkTable;
tLinkTable * CreateLinkTable()
{
tLinkTable *pLinkTable = (tLinkTable*)malloc(sizeof(tLinkTable));
if... | 1 |
#include <pthread.h>
void* thread1(void* pParam);
void* thread2(void* pParam);
int count1=0;
int count2;
int count3;
int i,j;
int n=10000;
pthread_mutex_t mutex;
int main(int argc, char *argv[]){
pthread_t tid1, tid2;
clock_t start, end;
start = clock();
pthread_mutex_init(&mutex, 0);
... | 0 |
#include <pthread.h>
int quitflag = 0;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void *
thr_fn(void *arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0)
err_ex... | 1 |
#include <pthread.h>
void *dosomething(void *threadnum ){
int *num = threadnum;
for(int i=0; i<100; i++){
printf("this is thread %d : task [%d]\\n", *num, i );
}
return 0;
}
int buff[8] = {0};
sem_t *full;
sem_t *empty;
void *writer(){
for(int i=0 ; i < 100 ; i++){
... | 0 |
#include <pthread.h>
int num_people = 0;
int on_car = 0;
int next_car = 0;
bool can_board = 1;
pthread_mutex_t conductor_mutex;
pthread_cond_t begin_loading, begin_unloading, enter_car, leave_car, car_empty;
void conductor_take_ride() {
pthread_mutex_lock(&conductor_mutex);
num_p... | 1 |
#include <pthread.h>
int proximo = -1, i = 0;
int nFatoracoes = 100;
pthread_mutex_t mutex;
pthread_cond_t condM;
pthread_cond_t condE;
struct strDivisores {
int *lista;
int tamanho;
int nDivisores;
};
struct strDivisores encontraDivisores (int n) {
struct strDivisores div;
div.tam... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int jump;
struct list{
int id;
int lower_bound;
int upper_bound;
};
int is_prime(int n){
int i;
if(n%2==0 && n!=2) return 0;
for(i=3;i*i<n;i+=2){
if(n%i==0) return 0;
}
return 1;
}
void* print(void *arg){
pthread_mutex_lock(&lock);
struct... | 1 |
#include <pthread.h>
pthread_mutex_t sum_mutex1;
int a[1000], sum;
void initialize_array(int *a, int n) {
int i;
for (i = 1; i <= n; i++) {
a[i-1] = i;
}
}
void *thread_add(void *argument) {
int i, thread_sum, arg;
thread_sum = 0;
arg = *(int *)argument;
fo... | 0 |
#include <pthread.h>
static int camera_stop_flag = 0;
static int take_picture =0;
static pthread_t read_thread;
static char filename[64];
static int count = 0;
pthread_mutex_t lock;
static struct fb_info *fb_info;
struct display_info disp_info;
static int fd = -1;
static int start_ms = 0;
vo... | 1 |
#include <pthread.h>
long long int value;
pthread_mutex_t mutex1;
}count;
void init(count *c)
{
c->value=0;
c->mutex1=(pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
}
void *increment(void *c)
{
while(((count *)c)->value<1000000000)
{
pthread_mutex_lock(&(((count *)c)->mutex1... | 0 |
#include <pthread.h>
extern int makethread (void* (*) (void*), void*);
struct to_info
{
void (*to_fn) (void*);
void* to_arg;
struct timespec to_wait;
};
void
clock_gettime (int id, struct timespec* tsp)
{
struct timeval tv;
gettimeofday (&tv, 0);
tsp->tv_sec = tv.tv_sec;
... | 1 |
#include <pthread.h>
pthread_cond_t found;
pthread_mutex_t mutexi;
pthread_barrier_t barreira;
int resultados;
int num_equipes, num_membros;
int print =0;
int equipes[100][100][2];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void* doIt(void* team){
int *equipi = (int*)team;
... | 0 |
#include <pthread.h>
struct job {
struct job* next;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_function (void* arg)
{
while (1) {
struct job* next_job;
pthread_mutex_lock (&job_queue_mutex);
if (job_queue == 0)
next_job = ... | 1 |
#include <pthread.h>
struct setNode* next;
pthread_mutex_t* mutex;
void* data;
}setNode_t;
setNode_t* head;
int (*compare)(void* , void* );
}set_t;
static setNode_t* setNode_new(void* data, setNode_t* next)
{
setNode_t* new = malloc(sizeof(setNode_t));
if (new == 0){
fprintf(stderr, "%s... | 0 |
#include <pthread.h>
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR: ;
goto ERROR;
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(void)
{
ret... | 1 |
#include <pthread.h>
void *resourceRequest(void *i);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int **alloc,**need,**maxClaim;
int *maxRes,*resVector,*complete;
int *executionOrder;
int order=0;
int nr,np;
char space;
int count=0;
int main(int argc , char *argv[]) {
int rc[100];
int... | 0 |
#include <pthread.h>
void shift_left_after_se(void *not_used){
pthread_barrier_wait(&threads_creation);
while(1)
{
pthread_mutex_lock(&control_sign);
if (!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait, &control_sign) != 0);
}
pthread_mutex_unlock(&control_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
double target;
void* opponent(void *arg)
{
int i ;
for(i = 0; i < 100000; ++i)
{
pthread_mutex_lock(&mutex);
target -= i ;
pthread_mutex_unlock(&mutex);
}
return 0;
}
int main(int argc, char **argv)
... | 0 |
#include <pthread.h>
struct options
{
char* mnt_point;
int mnt_point_set;
};
static struct options* parse_args(int argc, char* argv[]);
static void usage(int argc, char** argv);
static struct options* user_opts = 0;
int main(int argc, char **argv)
{
int ret = -1;
int c... | 1 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
struct foo *f_next;
};
struct foo *
foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) ... | 0 |
#include <pthread.h>
void *v2(void *path){
if (start_time.tv_sec == 0 && start_time.tv_usec == 0) {
if (gettimeofday(&start_time, 0)) {
fprintf(stderr, "Failed to run Variant 2: unable to get current time\\n");
exit(1);
}
}
char *file, new_path[1000];
pthread_t... | 1 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void* p_func(void* p)
{
struct timespec ts;
struct timeval now;
bzero(&ts,sizeof( ts));
int ret;
gettimeofday(&now,0);
ts.tv_sec=now.tv_sec+5;
pthread_mutex_lock(&mutex);
printf(" i am child ,this is wait entrance\\n"... | 0 |
#include <pthread.h>
void *matrix(void *);
void *display(void *);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t t[5];
int C[4], A[8], B[8];
int main(int argc, char *argv[]) {
if (argc == 17) {
if (datavalidation(argc, argv)) {
int i;
for (i = 0; i < 8; i++) A[i] = at... | 1 |
#include <pthread.h>
void insert_end( char * );
void delete_beginning( void );
void delete_position( int pos );
struct node {
int sec;
int lost_sec;
char info[64];
struct node *link;
};
pthread_mutex_t mutex;
pthread_cond_t cond1;
pthread_cond_t cond2;
struct node * head;
} my_st... | 0 |
#include <pthread.h>
int N=100;
int T=4;
pthread_mutex_t count_lock;
pthread_cond_t ok_to_proceed;
int count;
} barrier;
double escalar;
barrier *barrera;
double max, min, suma;
double *R;
double* M[8];
pthread_mutex_t mutexMax;
pthread_mutex_t mutexMin;
pthread_mutex_t mutexAvg;
vo... | 1 |
#include <pthread.h>
main()
{
int semId,semval,fd,i,j;
struct sembuf v1,v2;
pthread_t tid1,tid2;
char rdbuf1[20],rdbuf2[20];
pthread_mutex_t m1,m2;
if(fork()==0)
{
printf("In child process %d\\n",getpid());
printf("Enter message\\n");
scanf("%s... | 0 |
#include <pthread.h>
uint64_t nb;
FILE * file;
char str[60];
pthread_t thread0;
pthread_t thread1;
pthread_mutex_t lock;
void* thread_prime_factors(void * u);
void print_prime_factors(uint64_t n);
void* thread_prime_factors(void * u)
{
pthread_mutex_lock(&lock);
while ( fgets(str, 60... | 1 |
#include <pthread.h>
struct common_ctx_t_ {
uint8_t printer_tid;
uint8_t cur_count;
bool cur_count_handled;
uint8_t total_count;
bool do_debug;
pthread_mutex_t mtx;
pthread_cond_t cv;
};
struct thread_ctx_t_ {
uint8_t thread_id;
common_ctx_t *common_ctx;
};
... | 0 |
#include <pthread.h>
sem_t dataBaseController;
pthread_mutex_t mutex;
pthread_t writters[1], readers[5];
int rc = 0, n;
int data[1];
int dataBase[6];
void readDataBase(int i){
printf("O leitor %d leu a informacao %d do banco de dados\\n", i, dataBase[rand()%6]);
usleep(500000);
}
void... | 1 |
#include <pthread.h>
int g_wpmsg_num = 0;
struct wpmsglist *g_wpmsg_list = 0;
pthread_mutex_t g_wpmsglist_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t g_wpd_mutex = PTHREAD_MUTEX_INITIALIZER;
struct wpmsg {
int len;
unsigned char *data;
};
struct wpmsglist {
struct wpmsglist *next;
st... | 0 |
#include <pthread.h>
void hashpipe_thread_args_init(struct hashpipe_thread_args *a) {
a->thread_desc=0;
a->instance_id=0;
a->cpu_mask=0;
a->finished=0;
pthread_cond_init(&a->finished_c,0);
pthread_mutex_init(&a->finished_m,0);
memset(&a->st, 0, sizeof(hashpipe_status_t)... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
enum BUS_STATUS {
BUS_ON_BUSY =0,
BUS_OFF_BUSY =1,
BUS_ON_LOCK =2,
BUS_OFF_LOCK =3,
};
enum... | 0 |
#include <pthread.h>
int count[5]={0};
int inputs[10000]={0};
void *job(void *);
pthread_mutex_t mutexprotect;
int main(){
pthread_t t[5];
int tstatus[5];
int i=0,j=0;
time_t tim;
srand((int) tim);
for(j=0;j<10000;j++){
inputs[j]=(rand()%5);
printf("%d",inputs[j],"\... | 1 |
#include <pthread.h>
int data[50];
int occupied;
int nextin;
int nextout;
pthread_mutex_t *buflock;
pthread_cond_t *objects;
pthread_cond_t *room;
} Buffer;
void *prime_thread(void *args);
int main(){
Buffer *buffer1;
int val = 2;
buffer1 = malloc(sizeof... | 0 |
#include <pthread.h>
int elementos[10];
int in = 0;
int out = 0;
int total = 0;
int producidos = 0, consumidos = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t consume_t = PTHREAD_COND_INITIALIZER;
pthread_cond_t produce_t = PTHREAD_COND_INITIALIZER;
void * product... | 1 |
#include <pthread.h>
struct UpdateThreadParams
{
int min;
int max;
};
void* gridUpdateThread(void* param);
void finishTick();
void finishCount();
void finishTickInit();
int threadCount = 0;
int threadsDone = 0;
bool ticksPaused = 0;
pthread_cond_t pauseCond;
pthread_cond_t... | 0 |
#include <pthread.h>
int allocate_map();
int allocate_pid();
int release_pid(int pid);
void* test_method(void *p);
unsigned int *pidMap;
pthread_mutex_t *locks;
int mapSize;
int allocate_map()
{
if (pidMap != 0)
{
free(pidMap);
}
mapSize = ceil((5000 -300)/32.0);
pidMap = (unsigned... | 1 |
#include <pthread.h>
static int cant_hilos;
static int resto;
static pthread_mutex_t lock;
static int tarea = -1;
static int A[4000][4000], B[4000][4000], C[4000][4000];
struct indices
{ int i, j;
};
void cargarMatrices();
void realizarTarea(indice indiceGral);
void *mapearTarea(void *);
ind... | 0 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct list {
struct list *next;
int exiting;
enum eid_vwr_state_event e;
void* data;
void (*free)(void*);
void (*done)(void*);
} *cmdlist = 0;
static void* thread_mai... | 1 |
#include <pthread.h>
struct mytask
{
char c;
};
void showtask(struct mytask *p)
{
printf("%c\\n",p->c);
sleep(1);
}
int quit;
void * start(void * arg)
{
struct myqueue *myq = arg;
struct mytask *p = 0;
while(1)
{
pthread_mutex_lock(&myq->lock);
while(myq->... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.