text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_cond_t time_to_ring = PTHREAD_COND_INITIALIZER;
pthread_mutex_t time_to_ring_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t time_to_eat = PTHREAD_COND_INITIALIZER;
pthread_mutex_t time_to_eat_mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_master(void *args)
... | 1 |
#include <pthread.h>
int rank;
char finished1;
pthread_mutex_t mutex1;
pthread_cond_t cond1;
char finished2;
pthread_mutex_t mutex2;
pthread_cond_t cond2;
} thread_data;
thread_data td[20];
void* hello_thread(void *rank) {
int thread_rank = *(int *)rank;
if (thread_rank > 0) {
threa... | 0 |
#include <pthread.h>
int available_resources = 5;
int times = 100000;
pthread_mutex_t mutex;
sem_t semaphore;
int decrease_count(int count) {
pthread_mutex_lock(&mutex);
if (available_resources < count) {
pthread_mutex_unlock(&mutex);
return -1;
} else {
available_resources... | 1 |
#include <pthread.h>
pthread_t phil[3];
pthread_mutex_t baguette[3];
void mange(int id) {
printf("Philosophe [%d] mange\\n",id);
for(int i=0;i< rand(); i++) {
}
}
void* philosophe ( void* arg )
{
int *id=(int *) arg;
int left = *id;
int right = (left + 1) % 3;
while(1) {
pri... | 0 |
#include <pthread.h>
int s=0;
sem_t full,empty;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int q[5],front=0,rear=5 -1;
void *prod(void *count)
{
int* c = (int*)count;
long int i;
int j;
for(i=0;i<10;i++)
{
sem_wait(&full);
pthread_mutex_lock(&mutex);
rear=(rear+1)%5;
... | 1 |
#include <pthread.h>
double a[100000000];
int count ,num_threads,iterations;
double search_no ;
pthread_mutex_t count_mutex;
void *find_entries(void *tid)
{
int i, start, *mytid, end;
int local_count =0;
mytid = (int *) tid;
start = (*mytid * iterations);
... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
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:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_t... | 1 |
#include <pthread.h>
int tid;
double stuff;
} thread_data_t;
double shared_x;
pthread_mutex_t lock_x;
void *thr_func(void *arg) {
thread_data_t *data = (thread_data_t *)arg;
printf("hello from thr_func, thread id: %d\\n", data->tid);
pthread_mutex_lock(&lock_x);
shared_x += ... | 0 |
#include <pthread.h>
int lock_var = 0;
time_t end_time;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_routine1(void *arg)
{
int i;
printf("I'am the sub thread1\\n");
while(time(0) < end_time) {
pthread_mutex_lock(&mutex);
for(i=0; i<3; i++) {
lock_var++;
sleep... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t _wait = PTHREAD_COND_INITIALIZER;
void * thr_fn(void *arg)
{
int err, signo;
for(; ;)
{
err = sigwait(&mask, &signo);
if(err != 0)
{
pthread_exit((void*)0);
}
switch... | 0 |
#include <pthread.h>
struct DECIMAL_COORD
{
int time;
float latitude;
float longitude;
};
struct DECIMAL_COORD decimal_coord = {0, 0.0, 0.0};
struct HANDLERS handlers;
void signals_handler(int signal_number)
{
printf("Signal catched.\\n");
hndclose(&handlers);
exit(0);
... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void thread_init(void)
{
pthread_key_create(&key, free);
}
char* getenv(const char *name)
{
int i, l... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void* p_func(void* p)
{
pthread_mutex_lock(&mutex);
int ret;
int i=(int)p;
printf("I am child %d,I am here\\n",i);
ret=pthread_cond_wait(&cond,&mutex);
if(0!=ret)
{
printf("pthread_cond_wait ret=%d\\n",ret);
}
printf("I ... | 1 |
#include <pthread.h>
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
int g_sum = 0;
void* vector_operation(void* p_param)
{
int* t_param = p_param;
fprintf(stdout, "%d * %d\\n", t_param[0], t_param[1]);
pthread_mutex_lock(&g_mutex);
g_sum += t_param[0] * t_param[1];... | 0 |
#include <pthread.h>
struct thread_args {
int *counter;
int rep;
pthread_mutex_t *counter_mutex;
pthread_mutex_t *condition_mutex;
pthread_cond_t *condition;
};
void* thread_function1(void *ptr) {
struct thread_args *arg = (struct thread_args*) ptr;
for ( ; ; ) {
pthread_mutex_lock(arg->... | 1 |
#include <pthread.h>
int NUM_THREADS;
long int chunk_end;
long int chunk_init;
pthread_mutex_t lock_x;
void swapM(long int* a, long int* b)
{
long int aux;
aux = *a;
*a = *b;
*b = aux;
}
long int divideM(long int *vec, int left, int right)
{
int i, j;
i = left;
for (... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer=0;
void *producer(void *ptr)
{
int i;
for (int i; i <= 10; i++) {
pthread_mutex_lock(&the_mutex);
while (buffer != 0) pthread_cond_wait(&condp, &the_mutex);
buffer = i;
... | 1 |
#include <pthread.h>
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void dotprod(void *data) {
int i,start,end;
double mysum, *x, *y;
start=*((int *)data);
end = start+dotstr.veclen/8;
x = dot... | 0 |
#include <pthread.h>
int g_done = 0;
pthread_mutex_t g_mutex_launch;
void *thread_main(void *null)
{
char line[1024];
pid_t child_pid;
char *result;
while (! g_done) {
pthread_mutex_lock(&g_mutex_launch);
if (! g_done && (result = fgets(line, 1024, stdin)) ) {
... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
void *myfunc(void* myvar);
int a = 0;
int main()
{
pthread_t thread1;
pthread_t thread2;
int ret1, ret2;
char* msg1 = "first thread";
char* msg2 = "second thread";
if (pthread_mutex_init(&lock, 0) != 0)
{
printf("\\n mutex init fai... | 0 |
#include <pthread.h>
double a[100];
double b[100];
double c[100];
int k = 0;
void fun2(int n,double money)
{
c[n] = 0;
srand((unsigned)time(0));
for(int i = 0; i < n;i++)
{
a[i] = rand();
}
double total = 0.0;
for(int i = 0 ; i < n;i++)
{
total... | 1 |
#include <pthread.h>
int inc_all;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *threadIncrement(void *p){
int g = 0;
*(int*)p = 0;
for(g = 0; g<1000000; g++){
(*(int*)p)++;
pthread_mutex_lock(&mutex);
inc_all++;
pthread_mutex_unlock(&mutex);
}
pthread_exit(0);
}
in... | 0 |
#include <pthread.h>
int a[16][16], b[16][16], c[16][16];
int numThreads = 1;
pthread_mutex_t sumLock;
int idx = 0;
void init_array() {
int i, j;
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j++) {
a[i][j] = i + j;
b[i][j] = 16 - j;
}
}
}
void print_array() {
... | 1 |
#include <pthread.h>
pthread_mutex_t mut;
int pubRecord;
void *thread1(void)
{
pid_t pid;
pthread_t tid;
tid = pthread_self();
pid = getpid();
int i;
for (i =0; i <10; i++)
{
pthread_mutex_lock(&mut);
pubRecord++;
printf("my name is subthread1-thr... | 0 |
#include <pthread.h>
int shared = 0;
pthread_mutex_t mutex_shared;
void * increment(void *arg)
{
int i;
pthread_mutex_lock(&mutex_shared);
for(i=0; i<1000; i++)
{
shared++;
}
pthread_mutex_unlock(&mutex_shared);
pthread_exit(0);
}
int main (int argc, char *argv[])
{
voi... | 1 |
#include <pthread.h>
long thread_count;
long long n;
double sum;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double Serial_pi(long long n);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_h... | 0 |
#include <pthread.h>
int *all_buffers;
int num_producers;
int num_consumers;
int num_buffers;
int num_items;
int num_producer_iterations;
int actual_num_produced;
pthread_mutex_t should_continue_producing_lock;
pthread_mutex_t buffer_printer_lock;
sem_t total_empty;
sem_t buffer_lock;
sem_t ... | 1 |
#include <pthread.h>
int total_words ;
pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
int main(int ac, char *av[])
{
pthread_t *thread_list;
void *count_words(void *);
int i;
if ( ac == 1 ){
printf("usage: %s file ..\\n", av[0]);
exit(1);
}
thread_list = (pthread_t *) m... | 0 |
#include <pthread.h>
char *filename;
struct task *next;
} task;
task *job_queue_head = 0;
task *job_queue_tail = 0;
pthread_cond_t condQueueReady = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qMutex = PTHREAD_MUTEX_INITIALIZER;
void getfileinfo(int tid, char*filename);
void *thread_pool_func(voi... | 1 |
#include <pthread.h>
sem_t plataforma_embarque[5];
sem_t plataforma_desembarque[5];
sem_t fila_embarque;
sem_t fila_desembarque;
volatile int embarcaram;
volatile int desembarcaram;
sem_t carro_encheu;
sem_t carro_esvaziou;
pthread_mutex_t trava_passageiros_embarque;
pthread_mutex_t trava_... | 0 |
#include <pthread.h> static char rcsId[]="$Id: ikcq.c,v 1.1 1999/12/16 22:13:40 lanzm Exp lanzm $";
int ikcq_queue_request(struct ikc_queue_head* head, struct ikc_request* req)
{
struct ikc_request_queue* tail;
struct ikc_request_queue* new_q = (struct ikc_request_queue*) malloc(sizeof(st... | 1 |
#include <pthread.h>
char temp[100];
int flag = 0;
char flag_f = 0;
int who;
void *thread_recv(void *arg);
void *thread_send(void *arg);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int main(void){
int socket_fd;
socket_fd =... | 0 |
#include <pthread.h>
struct counter_thread
{
int value;
pthread_mutex_t lock;
};
void topup(struct counter_thread *p)
{
pthread_mutex_lock(&p->lock);
p->value++;
pthread_mutex_unlock(&p->lock);
}
void *the_thing(void *c)
{
struct counter_thread *d=(struct counter_thread*)c;
long long int ... | 1 |
#include <pthread.h>
pthread_mutex_t mut1;
int n = 0;
int s = 0;
void* thread_function1 (void* unused)
{
int i = 1;
while(1)
{
pthread_mutex_lock (&mut1);
s = s + i;
pthread_mutex_unlock(&mut1);
printf("s=%d, i=%d\\n", s, i);
i = i + 2;
if (i > n)
bre... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0)
err_exit(err, ... | 1 |
#include <pthread.h>
pthread_t tid[3];
static volatile int keepRunning = 1;
pthread_mutex_t lock;
sem_t countsem, spacesem;
FILE *f;
void *b[(50)];
int in = 0, out = 0;
int biggest1=0,biggest2=0;
int smallest1=1749241873,smallest2=1749241873;
int bufferCount=0;
void controller() {
keepRu... | 0 |
#include <pthread.h>
static pthread_mutex_t ios_event_queue_lock = PTHREAD_MUTEX_INITIALIZER;
static struct
{
void (*function)(void*);
void* userdata;
} ios_event_queue[16];
static uint32_t ios_event_queue_size;
void ios_frontend_post_event(void (*fn)(void*), void* userdata)
{
pth... | 1 |
#include <pthread.h>
struct args {
int index;
int *counter;
pthread_mutex_t *lock;
};
void *incdec(void *args) {
printf("thread %d starts\\n", ((struct args *)args)->index);
struct args *targs = args;
int *counter = targs->counter;
pthread_mutex_lock(targs->lock);
for(int i = 0; i... | 0 |
#include <pthread.h>
static void *get_wqe(struct mlx4_srq *srq, int n)
{
return srq->buf.buf + (n << srq->wqe_shift);
}
void mlx4_free_srq_wqe(struct mlx4_srq *srq, int ind)
{
struct mlx4_wqe_srq_next_seg *next;
pthread_spin_lock(&srq->lock);
next = get_wqe(srq, srq->tail);
next->next_wqe... | 1 |
#include <pthread.h>
int shouldExit = 0;
sem_t empty;
sem_t full;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;;
buffer_item buffer[5];
void initBuffer(){
printf("Setting up buffer....\\n");
sleep(0);
printf("Buffer Initialized\\n");
}
int insert_item(buffer_item item,long id){
... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void* func1();
void* func2();
int fib(int);
int n = 0;
int main(){
pthread_t thread1, thread2;
pthread_create(&thread1, 0, &func1, 0);
pthread_create(&threa... | 1 |
#include <pthread.h>
{
int id, vector, place, **grid;
} threadinfo;
void *threadwork(void *);
int answer;
pthread_mutex_t themutex;
int main(int argc, char **argv)
{
int vector = atoi(argv[1]);
int place = atoi(argv[2]);
int **grid = createArray(vector, place);
readFile(vector, place,... | 0 |
#include <pthread.h>
char *dict, *found_keys;
unsigned char *ssid;
int sha_len, ssid_size, n_found=0;
int YEARS[] = {6, 7, 8, 9, 10, 5, 4, 3, 2, 1, 0};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int id;
int start;
int end;
} bf_arg;
int num_threads() {
int n_threads = sysconf(_SC... | 1 |
#include <pthread.h>
struct mt{
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(void)
{
int fd, i;
struct mt * mm;
pid_t pid;
fd = open("mt_test", O_CREAT | O_RDWR, 0777);
ftruncate(fd, sizeof(*mm));
mm = mmap(0, sizeof(*mm), PROT_READ | PROT_WRITE, MAP_SHARED,... | 0 |
#include <pthread.h>
volatile uint16_t *muxbus = 0;
pthread_mutex_t dio_lock;
void initiate_dio_mutex() {
if (pthread_mutex_init(&dio_lock, 0) != 0)
{
syslog(LOG_ERR, "Failed to initiate dio mutex");
display_error_msg("E07:UNEXPECTED");
exit(1);
}
}
voi... | 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;
void *functionCount1();
void *functionCount2();
int count = 0;
main()
{
pthread_t thread1, th... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t esperaPares;
pthread_cond_t esperaImpares;
int turnoPares=1;
int turnoImpares=0;
void *pares(void *kk) {
int i;
for(i=0; i <= 10; i+=2 ) {
pthread_mutex_lock(&mutex);
while (turnoPares == 0)
pthr... | 1 |
#include <pthread.h>
int SharedVariable = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_barrier_t barrier;
int valid(char *string){
int i; int length = strlen(string);
for(i = 0; i < length; i++){
if((string[i] <48) || (string[i] > 57))
return 0;
}
return 1;
}
int g... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
void __VERIFIER_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
char *v;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *thread1(void * arg)
{
v = malloc(sizeof(char));
return 0;
}
void *thread2(... | 1 |
#include <pthread.h>
int nitems;
int buff[MAXNITEMS];
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... | 0 |
#include <pthread.h>
int make_listen(int port);
void handle_connection(FILE* fin, FILE* fout);
int remove_trailing_whitespace(char* buf);
static pthread_mutex_t mutex;
static pthread_cond_t condvar;
static int n_connection_threads;
void* connection_thread(void* arg) {
FILE* f = (FILE*) arg;
... | 1 |
#include <pthread.h>
extern struct fs_options_struct fs_options;
static struct simple_hash_s fuse_users_hash;
static unsigned int calculate_uid_hash(uid_t uid)
{
return uid % fuse_users_hash.len;
}
static unsigned int uid_hashfunction(void *data)
{
struct fuse_user_s *user=(st... | 0 |
#include <pthread.h>
pthread_mutex_t M;
int DATA=0;
int accessi1=0;
int accessi2=0;
void *thread1_process(void * arg)
{
int k=1;
while(k) {
pthread_mutex_lock(&M);
accessi1++;
DATA++;
k=(DATA>=10?0:1);
printf("accessi di T1: %d\\n", accessi1);
pthread_mutex_unlock(&M);
}
pthrea... | 1 |
#include <pthread.h>
extern int identifier;
extern int NUMBER_OF_ROUTERS;
extern int NUMBER_OF_EDGES;
extern int NUMBER_OF_NEIGHBORS;
extern int* NEIGHBOR_IDS;
extern struct sockaddr_in my_addr;
extern int MAX_POSSIBLE_DIST;
extern int** neighbor_link_details;
extern int** actual_link_costs;
exte... | 0 |
#include <pthread.h>
int q[2];
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 < 2)
... | 1 |
#include <pthread.h>
void quick_sort(double *vector, int a, int b);
void *quick_sort_pthread(void *arg);
void swap(double *vector, double temp, int i, int j);
void barrier();
int dbgSorted(double* data, int len);
void print_vector(double *vector, int len);
int MAX_LEVEL;
volatile int number_... | 0 |
#include <pthread.h>
void *baby( void *ptr );
int limite = 30000;
int n = 2;
int trovati = 0;
pthread_mutex_t mutexN = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexTrovati = PTHREAD_MUTEX_INITIALIZER;
void threads(int NChildren);
void * baby (void * ptr);
int main(int argc, char * ... | 1 |
#include <pthread.h>
int pointCounter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long thread_number, iteration_number, iterationPerThread_number;
void* shoot_arrow(void *arg) {
unsigned int seed;
double x, y;
int i, counter = 0;
for (i = 0; i < iterationPerThread_numb... | 0 |
#include <pthread.h>
int npos;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
int buf[10000000], pos = 0, val = 0;
void *fill(void *nr)
{
while (1)
{
pthread_mutex_lock(&mut);
if (pos >= npos)
{
pthread_mutex_unlock(&mut);
return 0;
}
buf[pos] = val... | 1 |
#include <pthread.h>
struct CTMemoryRecord {
int retainCount;
void (* deallocMethod)(void *address);
pthread_mutex_t *memoryRecordMutex;
};
void _createMemoryRecordTree(void);
struct CTAVLTreeRoot *_sharedMemoryRecordTree(void);
void _createMemoryRecordTreeMutex(void);
pthread_mutex_... | 0 |
#include <pthread.h>
void
pager_shutdown (struct pager *p)
{
pager_sync (p, 1);
pager_flush (p, 1);
pthread_mutex_lock (&p->interlock);
p->pager_state = SHUTDOWN;
ports_destroy_right (p);
pthread_mutex_unlock (&p->interlock);
}
| 1 |
#include <pthread.h>
static pthread_mutex_t lock;
static pthread_cond_t data_ready, thread_idle;
static int x;
static int
factorial(int x)
{
if (x == 1)
return 1;
return x * factorial(x - 1);
}
static void *
thread_main(void *arg)
{
pthread_mutex_lock(&lock);
while (x >= 0) {
if (... | 0 |
#include <pthread.h>
int memory[(2*320+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top;
int index_malloc(){
int curr_alloc_idx = -1;
pthread_mutex_lock(&m);
if(next_alloc_idx+2-1 > (2*320+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx =... | 1 |
#include <pthread.h>
struct pmic_data {
pthread_t pmic_thread;
pthread_mutex_t pmic_mutex;
pthread_cond_t pmic_condition;
int threshold_reached;
int temp_idx;
int sensor_shutdown;
struct sensor_info *sensor;
} pmic_data;
static void *pmic_uevent(void *data)
{
int err = 0;
struct sensor_... | 0 |
#include <pthread.h>
struct play_t
{
char fname[256];
off_t flen;
off_t ldlen;
int pos;
int fi;
int fo;
};
static pthread_t tid_play;
static pthread_t tid_load;
static volatile int playing = 0;
static volatile int loading = 0;
static volatile int _pause = 0;
static struct play_t play;
... | 1 |
#include <pthread.h>
int x;
pthread_mutex_t mutex;
pthread_cond_t cond;
void producer(void)
{
while(1)
{
pthread_mutex_lock(&mutex);
int i;
for(i=0;i<3-x;i++)
{
x++;
printf("Producing:i=%d x=%d \\n",i,x);
sleep(1);
... | 0 |
#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)
... | 1 |
#include <pthread.h>
{
int *array;
int length;
int sum;
}
MyData;
MyData mData;
pthread_t myThread[5];
pthread_mutex_t mutex;
void *threadWork(void *arg)
{
int offset = (int)arg;
int j, sum = 0;
int start, end;
start = offset*mData.length;
end = start + mData.length;
for( j = start;... | 0 |
#include <pthread.h>
pthread_mutex_t* Forks;
int* Thinkers_hunger;
int N;
void get_Lfork(int name)
{
if (name == 0) pthread_mutex_lock(Forks + N - 1);
else pthread_mutex_lock(Forks + name - 1);
}
void get_Rfork(int name)
{
pthread_mutex_lock(Forks + name);
}
void put_Lfork(int name)
{
if (n... | 1 |
#include <pthread.h>
char _buffer[50][30];
int _nbmess = 0;
int _arret_lecture=0;
int _arret_tot = 0;
pthread_cond_t _full_buff = PTHREAD_COND_INITIALIZER;
pthread_cond_t _empty_buff = PTHREAD_COND_INITIALIZER;
pthread_mutex_t _mut = PTHREAD_MUTEX_INITIALIZER;
void * Ecriture(void * arg)
{
... | 0 |
#include <pthread.h>
void main_constructor( void )
;
void main_destructor( void )
;
void __cyg_profile_func_enter( void *, void * )
;
void __cyg_profile_func_exit( void *, void * )
;
char* join3(char *s1, char *s2);
pthread_mutex_t mut;
void (*callback)() = 0;
double register_functi... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[40];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, offset, len ;
double mysum, *x, *y;
offset = (int)arg;
... | 0 |
#include <pthread.h>
static pthread_mutex_t _locker = PTHREAD_MUTEX_INITIALIZER;
static int _fd = STDERR_FILENO;
static char _suffix[PATH_LEN];
char *format_datetime(const struct tm *datetime,
const size_t bufflen, char *buff){
size_t len = DATETIME_LEN_NOSEPY < buffle... | 1 |
#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_CH... | 0 |
#include <pthread.h>
int zwierzyna;
int pozywienie;
pthread_mutex_t pozywienie_m;
pthread_mutex_t zwierzyna_m;
int millisecons_sleep = 10;
int rzut_kostka() {
return rand() % 6 + 1;
}
void *mysliwy(void *ptr) {
for(int i=1; i<=365; i++) {
if (rzut_kostka() > rzut_kostka()) {... | 1 |
#include <pthread.h>
static pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER;
static int log_use_syslog = 0;
static void
syslog_opened(void)
{
pthread_mutex_lock(&log_lock);
log_use_syslog = 1;
pthread_mutex_unlock(&log_lock);
}
static int
is_syslog_opened(void)
{
int use_syslog;
p... | 0 |
#include <pthread.h>
extern struct connect_handle connection[];
extern struct connection svr_conn[];
int get_connection_entry(
int *conn_pos)
{
int rc = PBSE_NONE;
int pos = 0;
pthread_mutex_t *tmp_mut = 0;
pthread_mutexattr_t t_attr;
*conn_pos = -1;
pthread_mutexattr_init... | 1 |
#include <pthread.h>
int data[64];
sem_t blank_sem;
sem_t data_sem;
pthread_mutex_t lock1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2=PTHREAD_MUTEX_INITIALIZER;
void* product(void* arg)
{
static int i=0;
while(1)
{
sem_wait(&blank_sem);
pthread_mutex_lock(&lock1);
if(i==64)
{
... | 0 |
#include <pthread.h>
int main_ConditionVariable();
static void* ConditionVariable_funcThread(void* a_pArg);
static void ConditionVariable_wait(int timeoutMs);
static int ConditionVariable_CreateThread();
static pthread_mutex_t m_mutex;
static pthread_cond_t mCondition;
static pthread_t vTreadID... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t db = PTHREAD_MUTEX_INITIALIZER;
int rc = 0;
int reading_time = 3, writing_time = 12,using_time = 18;
void read_data_base(int reader_id)
{
printf("number %d reader is reading data base!\\n",reader_id);
... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void
prepare(void)
{
printf("preparing unlocking locks...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void
parent(void)
{
printf("parent ... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void thread_init(void) {
pthread_key_create(&key, free);
}
char *getenv(const char *name) {
int i,... | 0 |
#include <pthread.h>
struct info
{
int * BUFFER_P;
sem_t * s;
pthread_mutex_t * bf_mutex;
pthread_cond_t * bf_cond;
int * full_P;
};
void * producer_data(void * P);
void * consumer_data(void * C);
int fibonacci_number(int ant, int prox);
int search_place_insert(int * BUFFER);
int search... | 1 |
#include <pthread.h>
void *customerMaker();
void *barberShop();
void *waitingRoom();
void checkQueue();
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t sleep_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t barber... | 0 |
#include <pthread.h>
pthread_mutex_t turno;
pthread_mutex_t mutex;
pthread_mutex_t db;
int rc = 0;
void* reader(void *arg);
void* writer(void *arg);
void read_data_base();
void use_data_read();
void think_up_data();
void write_data_base();
int main() {
pthread_mutex_init(&mutex, 0);
pthr... | 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) {
fp... | 0 |
#include <pthread.h>
char __resource[32 + 1];
unsigned long __resource_len = 0;
unsigned long __reader_count = 0;
pthread_mutex_t __write_mutex;
pthread_mutex_t __read_mutex;
void write_resource(unsigned long tid) {
char ch = 'a' + __resource_len % 26;
__resource[__resource_len] = ch;
... | 1 |
#include <pthread.h>
pthread_mutex_t tenedor[5];
sem_t S;
void pensar(int i) {
printf("Filosofo %d pensando...\\n",i);
usleep(random() % 50000);
}
void comer(int i) {
printf("Filosofo %d comiendo...\\n",i);
usleep(random() % 50000);
}
void tomar_tenedores(int i) {
pthread_mutex_lock(&(t... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex;
static pthread_mutexattr_t mta;
static void my_init_hook (void);
static void *my_malloc_hook (size_t, const void *);
static void my_free_hook (void*, const void *);
static void *my_realloc_hook (void*, size_t, const void*);
void (*__malloc_initi... | 1 |
#include <pthread.h>
int auti_na_mostu = 0;
int smjer_most = 2;
int *smjer_auta;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t uvjet = PTHREAD_COND_INITIALIZER;
void popniSeNaMost (int smjer) {
pthread_mutex_lock(&m);
while ((auti_na_mostu == 3) || ((auti_na_mostu > 0) ... | 0 |
#include <pthread.h>
struct node {
struct sockaddr_in address;
long port;
int del;
};
struct node nodeList[10];
struct hubmsg_t {
int mtype;
long port;
};
struct listmsg_t {
int mtype;
struct node nodeList[10];
};
struct listmsg_t listmsg;
struct nodemsg_... | 1 |
#include <pthread.h>
static pthread_cond_t pwait = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t plock = PTHREAD_MUTEX_INITIALIZER;
static int N;
static int nsecs = 2;
int *forks;
int isAvailable(int i)
{
if(forks[i] && forks[(i+1) % N])
return 1;
else
return 0;
}
void... | 0 |
#include <pthread.h>
void *allocate_small(size_t size)
{
void *block;
pthread_mutex_lock(&g_global_lock);
if (g_book_keeper.small.head == 0)
{
g_book_keeper.small.head = allocate_new_zone(SMALL_MAX);
divide_zone((void*)&(g_book_keeper.small.head),
(void*)&(g_book_keeper.small.tail), S... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int recordList[1000];
int result = 0;
int start;
int end;
}t_range;
void* compute_sum(void* range) {
t_range r = *((t_range*) range);
int i;
int partialSum = 0;
for (i = r.start ; i < r.end ;... | 0 |
#include <pthread.h>
unsigned long long* arrayptr;
int thread_no;
}arg;
const unsigned long long maxSize =200000;
pthread_mutex_t lock;
void init_emptyAry(void *ptr);
void solve_problem(void *ptr);
pthread_mutex_t lock;
int main(){
pthread_t threadArray[16];
arg lowOrdInter[16];
... | 1 |
#include <pthread.h>
int sockfd;
int newsockfd[10];
int clients;
char inputbuffer[256];
char outputbuffer[256];
int noofoutputbytes;
int noofinputbytes;
char newinput;
char newoutput;
char transclient;
char recvingdata;
pthread_t clithread;
pthread_t inputthread;
pthread_t outputthread;
pthread_m... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
void delay_in_msec(int max)
{
unsigned delay = (int) (rand() / (double) 32767 + 1) * max;
usleep(delay);
}
const char* id;
pthread_mutex_t* pLock;
} PARAMS;
void* work(void* v) {
PARAMS* params = (PARAMS*) v;
pthread_mutex_lo... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int x;
void threaddeal1(void)
{
while(x>0)
{
pthread_mutex_lock(&mutex);
printf("线程1正在运行: x=%d \\n",x);
x--;
pthread_mutex_unlock(&mutex);
sleep(1);
}
pthread_exit(0);
}
void threaddeal2(void)
{
while(x>0)
{
pthread_... | 0 |
#include <pthread.h>
void *do_chat(void *);
int pushClient(int);
int popClient(int);
pthread_t thread;
pthread_mutex_t mutex;
int list_c[10];
char greeting[]="Welcome to chatting room\\n";
char CODE200[]="Sorry No More Connection\\n";
main(int argc, char *argv[])
{
int c_socket, s_socket;... | 1 |
#include <pthread.h>
int len = 0;
int front = 0;
int back = 0;
int size;
int *arr;
struct params{
int len;
int size;
int front;
int back;
int *arr;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_variable1 = PTHREAD_COND_INITIALIZER, condition_variable2 = PT... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.