text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static pthread_mutex_t atomic_lock = PTHREAD_MUTEX_INITIALIZER;
void avpriv_atomic_lock(void)
{
pthread_mutex_lock(&atomic_lock);
}
void avpriv_atomic_unlock(void)
{
pthread_mutex_unlock(&atomic_lock);
}
| 1 |
#include <pthread.h>
void *thread_function(void *);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
main()
{
pthread_t thread_id[10];
int i, j;
for(i=0; i < 10; i++)
{
pthread_create( &thread_id[i], 0, thread_function,... | 0 |
#include <pthread.h>
uint16_t get_sequence(uint16_t *seq, pthread_mutex_t *lock) {
uint16_t ret;
pthread_mutex_lock(lock);
ret=(*seq)++;
pthread_mutex_unlock(lock);
return ret;
}
uint16_t get_id(uint16_t *id, pthread_mutex_t *lock) {
uint16_t ret;
pthread_mutex_lock(lock);
ret=(... | 1 |
#include <pthread.h>
void * create_mutex() {
pthread_mutex_t * m = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init ( m, 0 );
return m;
}
void destroy_mutex ( void * m ) {
pthread_mutex_t * _m = ( pthread_mutex_t* ) m;
pthread_mutex_destroy ( _m );
free(m);
}
void lo... | 0 |
#include <pthread.h>
void * thread_inc(void * arg);
void * thread_des(void * arg);
long long num = 0;
pthread_mutex_t mutex;
int main(int argc, char * argv[])
{
pthread_t thread_id[100];
int i;
pthread_mutex_init(&mutex, 0);
for(i=0; i<100; i++)
{
if(i%2)
pthread_create(&(thread_id... | 1 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char* argv[])
{
struct Seatmap* map = (struct Seatmap*)malloc(sizeof(struct Seatmap));
initialize_seatmap(map);
map->mutex = &mutex;
map->cond = &c... | 0 |
#include <pthread.h>
static int files[128];
static unsigned int references[128];
static unsigned int oflag_busy_locks[128];
static pthread_mutex_t muteces[128];
static pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER;
static int isInit = 0;
static int oflag = O_RDONLY;
static int cha... | 1 |
#include <pthread.h>
long totalSum = 0;
int* arr;
int size;
int subSize;
int index;
unsigned int step;
} args;
int* initializeArray(unsigned int size, unsigned int mode) {
int *arr = malloc(sizeof(int) * size);
int i,j;
if(mode == 0) {
for(i = 0; i < size; i++) {
arr[i] = i;
... | 0 |
#include <pthread.h>
int thread_flag;
pthread_cond_t thread_flag_cv = PTHREAD_COND_INITIALIZER;
pthread_mutex_t thread_flag_mutex = PTHREAD_MUTEX_INITIALIZER;
struct job {
struct job* next;
int num;
};
struct job* job_queue;
struct job* tail;
void initialize_flag ()
{
thread_flag = 0;... | 1 |
#include <pthread.h>
void monitor_cross(struct cart_t* cart)
{
pthread_mutex_lock(&gl_monLock);
if (gl_direction == '\\0')
gl_direction = cart->dir;
else
{
switch (cart->dir)
{
fprintf(stderr, "[Cart]\\tCart %i from direction %c must ... | 0 |
#include <pthread.h>
void *sum(void *p);
double *v1, *v2;
double sumtotal = 0.0;
int numthreads, n;
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);
pthread_mutex_init(&mutex, 0);
s... | 1 |
#include <pthread.h>
int SERVER_SHUT_DOWN;
pthread_mutex_t sd_lock;
pthread_t sd_thread;
void* shut_down(void* p)
{
pthread_mutex_init(&sd_lock,0);
pthread_mutex_lock(&sd_lock);
SERVER_SHUT_DOWN = 0;
pthread_mutex_unlock(&sd_lock);
static struct termios oldt, newt;
tcgetattr( STDIN... | 0 |
#include <pthread.h>
pthread_t threads[4];
int thread_count;
pthread_mutex_t thread_count_mutex;
pthread_cond_t thread_count_condvar;
sig_atomic_t sigabrt_received;
void
incr_thread_count (void)
{
pthread_mutex_lock (&thread_count_mutex);
++thread_count;
if (thread_count == 4)
... | 1 |
#include <pthread.h>
int num_threads = 1;
int keys[100000];
pthread_mutex_t lock;
int key;
int val;
struct _bucket_entry *next;
} bucket_entry;
bucket_entry *table[5];
void panic(char *msg) {
printf("%s\\n", msg);
exit(1);
}
double now() {
struct timeval tv;
get... | 0 |
#include <pthread.h>
int finish = 0;
pthread_rwlock_t finish_lock = PTHREAD_RWLOCK_INITIALIZER;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
struct job {
struct job *j_prev;
struct job *j_next;
pthread_t j_id;
int data;
};
struct jo... | 1 |
#include <pthread.h>
char depot[15];
volatile size_t stock;
pthread_mutex_t mute = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_empty = PTHREAD_COND_INITIALIZER;
void show_depot(char* str)
{
int i = 0;
printf("\\r");
for(; i<stock; ... | 0 |
#include <pthread.h>
struct node {
struct node* next;
int value;
};
struct node * file_lock = 0;
struct node * volatile file_lock_free = 0;
pthread_mutex_t file_mutex;
void push_lock(int value_to_push) {
struct node * new_node;
new_node= malloc(sizeof(struct node));
new_node-> value=value... | 1 |
#include <pthread.h>
{
int valid;
unsigned int session;
unsigned int pathid;
unsigned int energy;
int done;
} p_ent;
int pcount = 0;
int idle_uW=0;
p_ent __paths[10];
int64_t __battery_energy=0;
int64_t __battery_capacity=0;
unsigned int __path_costs[NUMPATHS];
unsigned int __path_count... | 0 |
#include <pthread.h>
int value;
pthread_cond_t rc, wc;
pthread_mutex_t rm, wm;
int r_wait, w_wait;
}Storage;
void setValue(Storage *s, int value) {
s->value = value;
}
int getValue(Storage *s) {
return s->value;
}
void *set_thread(void *arg) {
Storage *s = (Storage *)arg;
for (int... | 1 |
#include <pthread.h>
char **P;
pthread_mutex_t m;
pthread_cond_t cond;
} Est;
Est *E = 0;
void myInit(){
if(E == 0){
E = (Est*)malloc(sizeof(Est));
pthread_mutex_init(&E->m, 0);
pthread_cond_init(&E->cond, 0);
E->P = (char**)malloc(5*sizeof(char*));
}
}
int ubicar(char *nom, int k)... | 0 |
#include <pthread.h>
void* func_1(void *ptr);
void* func_2(void *ptr);
void* func_3(void *ptr);
int a = 0;
pthread_mutex_t lock;
int main(int argc, char *argv[])
{
system("clear");
pthread_t thd1, thd2;
int t1, t2;
char *mesg1 = "I'm Thread 1";
char *mesg2 = "I'm Thread 2";
t1 = pthread_... | 1 |
#include <pthread.h>
pthread_mutex_t mu;
pthread_cond_t registerSignal;
int toTreat = 0, nTreated = 0, size = 0;
int *treatTimes;
FILE *outputF;
void fileOP(const char* inputFile, const char* outputFile) {
int num, i;
FILE* file = fopen(inputFile, "r");
while (!feof(file)) {
fscanf(file,... | 0 |
#include <pthread.h>
int event_handler_init(struct event_handler* eh)
{
do
{
eh->ev_cur = 0;
eh->ev_end = 0;
eh->ev_size = 0;
eh->ev_max = MAX_EVENTS;
eh->tr_busy = 0;
eh->tr_min = MIN_THREADS;
eh->tr_max = MAX_THREADS;
eh->tr_live = eh->tr_min;
eh->eh_cancel = 0;
if ((eh->eve... | 1 |
#include <pthread.h>
void*
wkr(void *arg)
{
int n, i, fd, got;
long long k;
char *ptr, *ptc, buf[WEBHDR];
uint64_t cd;
struct qstat *tt = arg;
struct epoll_event events[ECHUNK];
struct iovec iov = {.iov_base = buf, .iov_len = BHSIZE};
struct msghdr mh = { .msg_name = 0,
... | 0 |
#include <pthread.h>
{
int count;
int *array;
}arr_num;
double shared_x;
pthread_mutex_t lock_x;
void swap(int* a, int* b)
{
int aux;
aux = *a;
*a = *b;
*b = aux;
}
int divide(int *vec, int left, int right)
{
int i, j;
i = left;
for (j = left + 1; ... | 1 |
#include <pthread.h>
pthread_mutex_t writeMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t writeThreadRelease = PTHREAD_COND_INITIALIZER;
pthread_mutex_t readMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t readThreadRelease = PTHREAD_COND_INITIALIZER;
pthread_cond_t rwInteraction = PTHREAD_... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
int waiting_students = 0;
sem_t students_sem;
sem_t ta_sem;
void * TAWorker();
void * studentWorker();
unsigned int getRandomTime();
int main() {
printf("CS149 SleepingTA from Derek Lopes\\n");
sem_init(&ta_sem, 0, 0);
sem_init(&stud... | 1 |
#include <pthread.h>
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
pthread_attr_t attr;
int hijosVivos;
void *f( void *n){
int n_local,*p;
p=(int *)n;
n_local=*p;
printf ("Creado TH:n_local %d ((int)time:%d)\\n",n_local, (int)time(0));
sleep (4);
pthread_mutex_... | 0 |
#include <pthread.h>
extern int makethread(void *(*fn)(void *), void * arg);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void *
timeout_helper(void *arg) {
struct to_info *tip;
tip = (struct to_info *)arg;
nanosleep(&tip->to_wait, 0);
(*tip -> to_f... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *another(void *arg)
{
printf("in child thread, lock the mutex.\\n");
pthread_mutex_lock(&mutex);
sleep(5);
pthread_mutex_unlock(&mutex);
return 0;
}
void prepare()
{
pthread_mutex_lock(&mutex);
}
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int count = 0;
int consume( void )
{
int i = 10;
while( i-- ){
pthread_mutex_lock( &mutex );
pthread_cond_wait( &cond, &mutex );
printf( "Consumed %d\\n",... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int i=-1;
void* someThreadFunction(){
int teller;
printf("Hello from a thread!\\n");
for (teller = 0; teller < 100; teller++) {
pthread_mutex_lock(&mutex);
i++;
pthread_mutex_unlock(&mutex);
... | 0 |
#include <pthread.h>
pthread_mutex_t cnt_mutex;
sem_t sem_write;
int reader_count = 0;
int content = 1;
pthread_t readers[10];
void * writer_func()
{
printf("writer start\\n");
while (1)
{
sem_wait(&sem_write);
content++;
printf("writer: %d\\n", content);
... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
struct arg{
int i;
};
void cal(int i, void* p);
static void* func(void *p);
int main(int argc, const char *argv[])
{
int err, i;
pthread_t tid[4];
for (i = 0; i < 4; i++) {
err = pthrea... | 0 |
#include <pthread.h>
void *Incrementer(void *Dummy) {
extern int CommonInt;
extern pthread_mutex_t Mutex;
sleep(rand() % 4);
pthread_mutex_lock(&Mutex);
if (CommonInt == 0) {
sleep(rand() % 2);
CommonInt += 1;
printf("The common integer is now %d\\n",C... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void pthread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthre... | 0 |
#include <pthread.h>
int buff[10];
int buff_index;
pthread_mutex_t buff_mutex;
sem_t buff_sem_empty;
int push_front(int val)
{
if(buff_index < 10) {
buff[buff_index++] = val;
return 0;
} else
return -1;
}
int pop_front()
{
if(buff_index > 0)
return buff[--buff_index];
else
return... | 1 |
#include <pthread.h>
struct dot_prod_data
{
double *a;
double *b;
double sum;
int len;
};
pthread_mutex_t mutex;
struct dot_prod_data vecdata;
void* worker_thread(void* data_t)
{
int offset=(int)(data_t);
int start,end;
double local_sum=0.0;
int len=vecdata.len;
start... | 0 |
#include <pthread.h>
int gwList_insert(struct gwListNode **head, uint32_t gw){
int i = 0;
pthread_mutex_lock(&gw_lock);
struct gwListNode *node = *head;
struct gwListNode *prev = 0;
while(node){
if(gw == node->gw) break;
i++;
prev = node;
node = node->next;
}
if(node == 0){
nod... | 1 |
#include <pthread.h>
WAITTING,
IDLE,
ASSIGNED,
BUSY
}Thread_Status;
pthread_t tid;
pthread_mutex_t mutex;
pthread_cond_t cond;
Thread_Status status;
task_t task;
void * arg;
int cnt;
}Thread_pool_t;
Thread_pool_t * threadPool_create_and_init(int num);
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long double buffer[3] = {1, 1, 1};
void * fibonacci_entry(void *lim) {
long double *prev1 = &buffer[1];
long double *prev2 = &buffer[2];
for (int i = 1; i < *(int*)lim; i++) {
pthread_mutex_lock(&mutex)... | 1 |
#include <pthread.h>
void mediafirefs_destroy(void *user_ptr)
{
printf("FUNCTION: destroy\\n");
FILE *fd;
struct mediafirefs_context_private *ctx;
ctx = (struct mediafirefs_context_private *)user_ptr;
pthread_mutex_lock(&(ctx->mutex));
fprintf(stderr, "storing hashtab... | 0 |
#include <pthread.h>
pthread_mutex_t mAvailable;
pthread_mutex_t mAllocation;
pthread_mutex_t mNeed;
int available[3];
int maximum[5][3];
int allocation[5][3];
int need[5][3];
void show_matrix(int array[5][3], char *array_name);
int request_resources(int customer, int resources[]);
int re... | 1 |
#include <pthread.h>
void *ta (void *arg);
void *tb (void *arg);
void *tc (void *arg);
void *td (void *arg);
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
void *ta (void *arg)
{
pthread_t c;
(void) arg;
printf ("ta: running\\n");
p... | 0 |
#include <pthread.h>
double *A;
int num_threads = 2;
int N = 33554432;
int ocurrencia = 0;
double buscar = 1;
double maximun_value;
double minimun_value;
pthread_mutex_t A_lock;
double dwalltime(){
double sec;
struct timeval tv;
gettimeofday(&tv,0);
sec = tv.tv... | 1 |
#include <pthread.h>
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static void * thr_func(void *p)
{
FILE *fp;
char buf[1024];
fp = fopen("/tmp/out","r+");
if(fp == 0)
{
perror("fopen");
exit(1);
}
pthread_mutex_lock(&mut);
fgets(buf,1024,fp);
fseek(fp,0,0);
... | 0 |
#include <pthread.h>
int i, int_rand, x, y, z;
int tamanhoFila, nrExames;
float float_rand;
int matrizDados[4][2];
pthread_mutex_t mutex;
sem_t sem_sensores[5];
struct Node{
int conjuntoDados[2][2];
struct Node *proximo;
};
Node *fila;
int tamanhoFila, nodoAtual;
void inicializaFila(No... | 1 |
#include <pthread.h>
pthread_mutex_t globalNumberLock;
int globalNumber=0;
void* thread_1(){
for(int i=0; i<1000000; i++){
pthread_mutex_lock(&globalNumberLock);
globalNumber++;
pthread_mutex_unlock(&globalNumberLock);
}
return 0;
}
void* thread_2(){
for (int j=0; j<1000001; j++){
... | 0 |
#include <pthread.h>
int nitems;
int buf[1000000];
struct
{
pthread_mutex_t mutex;
int nput;
int nval;
}put = {PTHREAD_MUTEX_INITIALIZER};
struct
{
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
}nready = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER};
void *produce(vo... | 1 |
#include <pthread.h>
static int global = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t v = PTHREAD_COND_INITIALIZER;
void perror_exit (const char *info)
{
perror (info);
exit (1);
}
void *count_times (void *args)
{
int i = 1;
while (1) {
sleep (1);
fprintf (stderr, "s... | 0 |
#include <pthread.h>
static pthread_mutex_t lock;
static pthread_barrier_t barrier;
int* counterArray;
int nthreads;
int ncounters;
void* chain(void* arglist)
{
int i, j;
for (i = 0; i < nthreads; i++) {
pthread_mutex_lock(&lock);
for (j = 0; j < ncounters; j++)
... | 1 |
#include <pthread.h>
pthread_mutex_t lock_mutex;
char *buf="hello zmw";
sem_t empty,full;
char buf1[50];
int fileopen;
void *readfile(void *arg)
{
sem_wait(&empty);
pthread_mutex_lock(&lock_mutex);
char pro=*(char*)arg;
read(fileopen,buf1,100);
printf("%c read from pipe is: %s\\n",pro,buf1);
... | 0 |
#include <pthread.h>
int done;
FILE *file;
pthread_mutex_t lock1;
pthread_mutex_t lock2;
pthread_mutex_t filelock;
char filename[]="MyMessage.log";
struct thread_person {
pthread_t thread_id;
int thread_num;
pthread_attr_t attr;
int start_flag;
int quit_flag;
int j... | 1 |
#include <pthread.h>
int QUIT = 0;
pthread_mutex_t INUSE;
unsigned char byte;
FILE* PARLELPORT;
void *all_blink(void* arg)
{
QUIT = 0;
pthread_mutex_lock(&INUSE);
while (1)
{
byte = 0xFF;
fwrite(&byte, 1, 1, PARLELPORT);
sleep(0.5);
byte = 0;
fwrite(&byte, 1, 1, PARLE... | 0 |
#include <pthread.h>
void *producer (void *args);
void *consumer (void *args);
int buf[10];
long head, tail;
int full, empty;
pthread_mutex_t *mut;
pthread_cond_t *notFull, *notEmpty;
} queue;
queue *queueInit (void);
void queueDelete (queue *q);
void queueAdd (queue *q, int in);
void q... | 1 |
#include <pthread.h>
pthread_cond_t full = PTHREAD_COND_INITIALIZER, empty = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int buffer[4];
int begin = 0, end = 0, counter = 0, max = 4;
void *producer( void *arg ){
printf("pthread producer id : %d run \\n", *(int *)... | 0 |
#include <pthread.h>
int nitems;
int buff[1000000];
struct {
pthread_mutex_t mutex;
int nput;
int nval;
} put = { PTHREAD_MUTEX_INITIALIZER };
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
} nready = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER };
int ... | 1 |
#include <pthread.h>
const char* __op_to_str(int op)
{
switch(op) {
case 1: return "Begin of access";
case 2: return "Begin of write";
case 3: return "End of write";
case 4: return "Begin of read";
case 5: return "End of read";
case 6: return "End of read/write";
}
}
pthread_mutex_t... | 0 |
#include <pthread.h>
int count = 0;
double finalresult=0.0;
pthread_mutex_t count_mutex;
pthread_cond_t count_condvar;
void *sub1(void *t)
{
int i;
long tid = (long)t;
double myresult=0.0;
sleep(1);
pthread_mutex_lock(&count_mutex);
printf("sub1: thread=%ld going into wait... | 1 |
#include <pthread.h>
void *producer(),*consumer();
int *array;
int limit=-1;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int main(int argc, char **argv) {
int howmany;
pthread_t johntid,marytid;
long long *howlong;
howmany=atoi(argv[... | 0 |
#include <pthread.h>
extern pthread_mutex_t printf_lock;
extern pthread_mutex_t setup_lock;
extern pthread_mutex_t chairs_lock;
extern sem_t TA_ready;
extern sem_t TA_done;
extern sem_t Student_register;
extern int setupNotDone;
extern int globalSeed;
extern int occupied_chairs;
extern int MAX_C... | 1 |
#include <pthread.h>
int nitems;
struct
{
pthread_mutex_t mutex;
int buff[1000000];
int nput;
int nval;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
}nready = {
PTHREAD_MUTEX_INITIALIZER,PTHREAD_CO... | 0 |
#include <pthread.h>
void *philosopher (void *id);
void grab_chopstick (int,
int,
char *);
void down_chopsticks (int,
int);
int food_on_table ();
int get_token ();
void return_token ();
pthread_mutex_t chopstick[5];
pthread_t phi... | 1 |
#include <pthread.h>
int mutateeCplusplus = 0;
const char *Builder_id="";
{
pthread_t tid;
int is_in_instr;
} thrds_t;
thrds_t thrds[8];
pthread_mutex_t barrier_mutex;
pthread_mutex_t count_mutex;
volatile int times_level1_called;
void my_barrier(volatile int *br)
{
int n_... | 0 |
#include <pthread.h>
pthread_mutex_t m, l;
int A = 0, B = 0;
void *t1(void *arg) {
pthread_mutex_lock(&m);
A++;
if (A == 1) pthread_mutex_lock(&l);
pthread_mutex_unlock(&m);
pthread_mutex_lock(&m);
A--;
if (A == 0) pthread_mutex_unlock(&l);
pthread_mutex_unlock(&m);
}
void *t2(void... | 1 |
#include <pthread.h>
int in = 0 ;
int out = 0 ;
int buff[10]={0};
sem_t empty_sem;
sem_t full_sem;
pthread_mutex_t mutex;
int product_id = 0;
int prochase_id = 0;
void print()
{
int i;
for(i=0;i<10;i++)
printf("%d",buff[i]);
printf("\\n");
}
void *produce()
{
int id=++product_id;
w... | 0 |
#include <pthread.h>
int nitems;
struct{
pthread_mutex_t mutex;
int buff[1000000];
int nput;
int nval;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
void *produce(void *);
void *consume(void *);
int main(int argc, char *argv[]){
int i, nthreads, count[100];
pthread_t ... | 1 |
#include <pthread.h>
sem_t PID_sem;
bool stop = 0;
double y = 0;
struct udp_conn connection;
pthread_mutex_t mutex;
volatile int period_us = 5000;
int udp_init_client(struct udp_conn *udp, int port, char *ip)
{
struct hostent *host;
if ((host = gethostbyname(ip)) == 0) return -1;
udp->cl... | 0 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int running_flag = 0;
static int stop_flag = 0;
static pthread_t tid;
static uint16_t timeout;
static char *program_name;
static uint32_t recorded_jobid = NO... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int vec_len;
} DD;
DD dotstr;
pthread_t callThd[4];
pthread_mutex_t mutex_sum;
void *dotprod(void *arg)
{
int i, start, end, len;
long offset = (long)arg;
double mysum, *x, *y;
len = dotstr.vec_... | 0 |
#include <pthread.h>
pthread_mutex_t Mtx;
int Global;
void *Thread2(void *x) {
barrier_wait(&barrier);
pthread_mutex_lock(&Mtx);
Global = 43;
pthread_mutex_unlock(&Mtx);
return 0;
}
void *Thread1(void *x) {
pthread_mutex_init(&Mtx, 0);
pthread_mutex_lock(&Mtx);
Global = 42... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
void main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0);
pth... | 0 |
#include <pthread.h>
int q[4];
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 < 4)
... | 1 |
#include <pthread.h>
int enqueue_element(struct queue *q, void *data)
{
struct queue_element *tmp = malloc(sizeof(struct queue_element));
if(!tmp)
return ENQUEUE_FAILED;
pthread_mutex_lock(q->lock);
q->tail->data = data;
q->tail->next = tmp;
q->enqueued++;
q->tail = tmp;
pthread_mutex_... | 0 |
#include <pthread.h>
int q[4];
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 < 4)
... | 1 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void* inc_count(void* t)
{
int i;
long my_id = (long)t;
for (i=0; i<10; ++i) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
pthrea... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int num_pthreads;
double c_x_min;
double c_x_max;
double c_y_min;
double c_y_max;
double pixel_width;
double pixel_height;
int iteration_max = 200;
int image_size;
unsigned char **image_buffer;
int i_x_max;
int i_y_m... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
extern void __VERIFIER_assume(int expr);
extern int __VERIFIER_nondet_int(void);
void __VERIFIER_assert(int cond) { if (!(cond)) { ERROR: __VERIFIER_error(); } return; }
void *compute_pi (void *);
double intervalWidth, intervalMidPoint, area = ... | 0 |
#include <pthread.h>
char buf[128];
size_t pos;
size_t len;
int write_closed;
pthread_mutex_t mutex;
pthread_cond_t nonempty;
pthread_cond_t nonfull;
} bbuffer;
bbuffer* bbuffer_new(void) {
bbuffer* bb = (bbuffer*) malloc(sizeof(bbuffer));
bb->pos = 0;
bb... | 1 |
#include <pthread.h>
struct timespec ts;
pthread_mutex_t chopstick_mutex[5];
pthread_cond_t chopstick_conds[5];
int philo_states[5];
int phil_to_chopstick(int phil_id, direction_t d){
return (phil_id + d) % 5;
}
int chopstick_to_phil(int stick_id, direction_t d){
return (stick_... | 0 |
#include <pthread.h>
int brashno = 1000;
int masa[4];
pthread_mutex_t lock;
void* Mama(){
int position = 0;
while(brashno) {
int mama_get_brashno = rand() % 100 + 1;
if(mama_get_brashno > brashno){
mama_get_brashno = brashno;
}
brashno -= mama_... | 1 |
#include <pthread.h>
void mifuncion(int *numero);
int VARIABLE_GLOBAL;
pthread_mutex_t MXVARGLOBAL;
int main(void) {
int i;
int hilos = 3;
pthread_t tid[hilos][2];
pthread_mutex_init(&MXVARGLOBAL, 0);
for (i = 0; i < hilos; i++) {
tid[i][1] = i+1;
pthread_create(&tid[i][0], 0, (vo... | 0 |
#include <pthread.h>
const int GAME_PORT = 6967;
int sockfd, connfd;
struct sockaddr_in serv_addr, client;
pthread_t worker;
pthread_mutex_t enemy_mutex,ball_mutex;
void host_init();
void client_init();
void logic_init()
{
if (is_host)
{
host_init();
}
else
{
client_init()... | 1 |
#include <pthread.h>
pthread_mutex_t a;
pthread_mutex_t b;
int k;
int j;
void* fn1(void * args){
pthread_mutex_lock(&a);;
pthread_mutex_unlock(&b);;
}
void* fn2(void * args){
pthread_mutex_lock(&b);;
pthread_mutex_unlock(&a);;
}
int main(int argc, const char *argv[])
{
pthread_... | 0 |
#include <pthread.h>
struct propset {
char *str;
int row;
int delay;
int dir;
};
int setup(int nstrings, char *strings[], struct propset props[]);
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
int main(int ac, char *av[])
{
int c;
pthread_t thrds[10];
struct propset props[10];
... | 1 |
#include <pthread.h>
int source[2];
int out_channel[2];
int in_channel[2];
int th_id = 0;
pthread_mutex_t mid;
pthread_mutex_t ms[2];
void *robot (void * arg)
{
int id = -1;
pthread_mutex_lock (&mid);
id = th_id;
th_id++;
pthread_mutex_unlock (&mid);
__VERIFIER... | 0 |
#include <pthread.h>
long nNumber = 0;
pthread_mutex_t mutx;
void * minus(void* arg);
void * plus(void* arg);
void console_setting_for_eclipse_debugging(void)
{
setvbuf(stdout,0, _IONBF,0);
setvbuf(stderr,0, _IONBF,0);
}
void * minus(void* arg)
{
int i;
for(i= 0; i<100000; i++)
{
pthr... | 1 |
#include <pthread.h>
void main_memory(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);
}
... | 0 |
#include <pthread.h>
struct producers
{
int buffer[4];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty, notfull;
};
void init(struct producers * b)
{
pthread_mutex_init(&b->lock, 0);
pthread_cond_init(&b->notempty, 0);
pthread_cond_init(&b->notfull, 0);
b->readpos ... | 1 |
#include <pthread.h>
struct msg
{
struct msg* m_next;
};
struct msg* workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
void process_msg(void)
{
struct msg* mp;
while (1)
{
pthread_mutex_lock(&qlock);
while (w... | 0 |
#include <pthread.h>
int max_darts;
int darts_in_circle;
pthread_mutex_t * darts_in_circle_lock;
int total_darts_currently_thrown;
pthread_mutex_t * total_darts_currently_thrown_lock;
pthread_mutex_t * rand_lock;
int done;
int dart_is_multiple;
pthread_mutex_t * dart_is_multiple_lock;
p... | 1 |
#include <pthread.h>
int nC = 0;
pthread_cond_t c_dormir;
pthread_cond_t c_corte;
pthread_mutex_t m_activo;
pthread_mutex_t m_corte;
pthread_mutex_t m_nC;
void *Barbero(void *arg);
void *Cliente(void *arg);
void cortaPelo();
void abandona();
void despierta();
void recibirCorte();
void duerme(... | 0 |
#include <pthread.h>
void mux_4_alusrcb(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);
}
... | 1 |
#include <pthread.h>
void *print_odd(void *data);
void *print_even(void *data);
int counter = 1;
pthread_mutex_t mutex_counter;
pthread_cond_t cond_odd, cond_even;
void main()
{
pthread_mutex_init(&mutex_counter, 0);
pthread_cond_init(&cond_odd, 0);
pthread_cond_init(&cond_even, 0);
... | 0 |
#include <pthread.h>
static char *map;
static int nr_bits;
extern FILE *logfile;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void bm_alloc(int bits)
{
int bytes = bits / 8;
if (!bits || bits < 0 || bits % 8)
DIE("invalid bit count: %d", bits);
map = malloc(bytes);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void thread1(void *arg)
{
pthread_cleanup_push((void *) pthread_mutex_unlock,(void *)&mutex );
while(1)
{
printf( "thread1 is running \\n" );
pthread_mutex_lock( &mutex );
pthread_cond_wait... | 0 |
#include <pthread.h>
int typ;
int pocz;
int kon;
int numer;
} par_t;
volatile int running_threads = 0;
volatile int p_count = 0;
pthread_mutex_t primes_mutex = PTHREAD_MUTEX_INITIALIZER;
int pid;
int chid;
void *count_primes2(void *arg) {
int status;
int coid;
par_t reply;
coid = Connec... | 1 |
#include <pthread.h>
struct INSTANCE_CACHE {
const char *module;
const char *instance;
};
static pthread_mutex_t icMutex = PTHREAD_MUTEX_INITIALIZER;
static struct INSTANCE_CACHE *ic = 0;
static int icSize = 0;
static const char *
add_ic(const char *module, const char *instance)
{
struct I... | 0 |
#include <pthread.h>
static pthread_t thread_timer;
static pthread_mutex_t mutex;
void qos_enter_critical(void){
pthread_mutex_lock( &mutex );
}
void qos_exit_critical(void){
pthread_mutex_unlock( &mutex );
}
static void ctrl_break_handler( int ctrl ){
int res;
... | 1 |
#include <pthread.h>
int status = -1;
pthread_mutex_t infrared_mutex;
extern int send_data(const char *data,const unsigned int length);
int infrared_init()
{
pinMode (infrared_Pin, INPUT);
pthread_mutex_init(&infrared_mutex,0);
return 1;
}
void reset_status()
{
pthread_mutex_lock(&infrar... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.