text stringlengths 192 6.24k | label int64 0 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;
int main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0);... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int g_request = 0;
int g_serviced = 0;
void* getFile(void* arg);
void cleanUp(int sigNum);
int main(){
signal(SIGINT, cleanUp);
int status;
srand(time(0));
while(1){
char fileName[255];
printf("Enter Filename: ");
... | 0 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t common_mutex = PTHREAD_MUTEX_INITIALIZER;
long tasks[5];
void *worker_thread(void *arg) {
for(int a = 0; a < 5; a++) {
int ret = pthread_mutex_lock(&common_mutex);
if(ret == EINVAL) {
printf("Encountered an error trying to lock m... | 1 |
#include <pthread.h>
static uint16_t g_curId = 0;
static pthread_mutex_t g_idMutex = PTHREAD_MUTEX_INITIALIZER;
int ip_calc_checksum(struct ip *packet)
{
int oldsum = packet->ip_sum;
packet->ip_sum = 0;
packet->ip_sum = ip_sum((char *)packet, sizeof(struct ip));
return oldsum == packe... | 0 |
#include <pthread.h>
struct sem_t {
int count;
int access;
pthread_mutex_t mutex;
};
int sem_post(struct sem_t * sem);
int sem_wait(struct sem_t * sem);
int sem_init(struct sem_t * sem, int start_access, int init);
void wait(struct sem_t * sem);
int rem();
void add(int val);
void pri... | 1 |
#include <pthread.h>
struct queue_root {
struct queue_head *head;
pthread_mutex_t head_lock;
struct queue_head *tail;
pthread_mutex_t tail_lock;
struct queue_head divider;
};
struct queue_root *ALLOC_QUEUE_ROOT()
{
struct queue_root *root =
malloc(sizeof(struct queue_root));
pthread... | 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>
unsigned long int time_1;
unsigned long int time_2;
char msg_temp[MSG_LEN];
int sec;
char msg[MSG_LEN];
struct st_alarm *next;
} set_alarm;
struct mut {
pthread_mutex_t th_mutex;
pthread_cond_t cond_1;
pthread_cond_t cond_2;
set_alarm *head;
} th_mut = {.th_mutex = ... | 0 |
#include <pthread.h>
{
int pkt,x,y,crc;
char name[20];
}ST;
{
int x,y,crc;
char name[20];
struct frame *next;
}fr;
{
int pkt;
struct node*node_next;
struct frame*frame_next;
}nd;
void make_node();
void print(void);
nd* my_malloc();
nd*h;
ST z;
pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER... | 1 |
#include <pthread.h>
int ticketcount = 10;
pthread_mutex_t lock;
pthread_cond_t cond;
void* salewinds1(void* args)
{
while(1)
{
pthread_mutex_lock(&lock);
if(ticketcount > 0)
{
printf("windows1 start sale ticket!the ticket is:%d\\n",ticketcount);
ticketcount --;
if(ticketcount == 0... | 0 |
#include <pthread.h>
struct timespec diff_timespec(struct timespec start, struct timespec end);
long long millisec_elapsed(struct timespec diff);
int main(int argc, char** argv)
{
struct timespec start;
struct timespec end;
struct timespec diff;
int i;
pthread_mutex_t mu... | 1 |
#include <pthread.h>
int *a, *b;
long sum=0;
pthread_mutex_t bloqueo;
void *dotprod(void *arg)
{
int i, start, end, offset, len;
long tid = (long)arg;
offset = tid;
len = 100000;
start = offset*len;
end = start + len;
printf("thread: %ld starting. start=%d end=%d\\n",tid,start... | 0 |
#include <pthread.h>
static pthread_t tid;
static pthread_mutex_t mut_pending_event = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_pending_event = PTHREAD_COND_INITIALIZER;
static volatile int pending_event=0;
static volatile int thread_quit_mark=0;
static void *thr_maintainer(vo... | 1 |
#include <pthread.h>
int escalar=3;
int matriz[3][3];
pthread_mutex_t bloq;
int *t;
void * matrizporescalar ( void * arg ) {
t=(int *) arg;
printf("t: %s\\n",t );
pthread_mutex_lock (&bloq);
int i;
for ( i = 0 ; i < 3 ; i ++ ) {
matriz [ *t ][ i] = matriz [ *t ][ i] * escalar ;
... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
... | 1 |
#include <pthread.h>
int i1,i2,i3,i4,i;
pthread_mutex_t mutex;
void *thread_fun1(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
i1++;
i++;
pthread_mutex_unlock(&mutex);
}
return (void *)0;
}
void *thread_fun2(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
i2++;... | 0 |
#include <pthread.h>
char* key;
char* value;
size_t value_len;
struct hash_item** pprev;
struct hash_item* next;
} hash_item;
hash_item* hash[1024];
pthread_mutex_t hash_mutex[1024];
pthread_mutex_t thread_mutex;
pthread_cond_t thread_cond;
int nthreads;
hash_item* hash_ge... | 1 |
#include <pthread.h>
pthread_t pt;
int i = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * secondary_func( void * arg );
int main( int argc, char ** argv ) {
pthread_create(&pt, 0, secondary_func, (void*)0);
while (i <= 2000) {
pthread_mutex_lock(&mutex);
printf("\\ni m... | 0 |
#include <pthread.h>
struct philosopher{
int index;
int first_fork;
int second_fork;
}*p;
pthread_mutex_t f[4];
void philosopher_init(struct philosopher *p, int i){
p->index = i;
int leftfork = i;
int rightfork;
if(p->index == 0)
rightfork = 4 -1;
else
rightfork = i-1;
if(le... | 1 |
#include <pthread.h>
void *Tackle(void *Dummy) {
extern pthread_cond_t Snap;
extern pthread_mutex_t Mutex;
pthread_mutex_lock(&Mutex);
printf("Waiting for the snap\\n");
pthread_cond_wait(&Snap,&Mutex);
pthread_mutex_unlock(&Mutex);
printf("Tackle!!\\n");
return... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
char debut_train1[2];
char fin_train1[2];
char debut_train2[2];
char fin_train2[2];
char debut_train3[2];
char fin_train3[2];
char *substring(size_t start, size_t stop, const char *src, char *dst, size_t size)
{
int count = stop - start;
if ( coun... | 1 |
#include <pthread.h>
int const maxQueueLen = 3;
int const shavingTimeMin = 1;
int const shavingTimeMax = 10;
int const customerSleepTimeMin = 1;
int const customerSleepTimeMax = 10;
void sleepInRange( int min, int max )
{
sleep(min + rand() % (max - min));
}
void doShaving()
{
sleepIn... | 0 |
#include <pthread.h>
static volatile int is_receiver_started = 0;
void initialize_event_dispatch() {
pthread_mutex_init(&wait_notify_lock, 0);
pthread_mutex_init(&ready_lock, 0);
pthread_cond_init(&wait_notify_condn, 0);
pthread_cond_init(&ready_condn, 0);
}
void cleanup_event_dispatch() ... | 1 |
#include <pthread.h>
pthread_t threads[3];
char buf[20];
int count=0;
pthread_mutex_t mutex,mutex2;
pthread_cond_t rdv;
void rdv_fonc(){
pthread_mutex_lock(&mutex2);
count++;
if(count < 3) pthread_cond_wait(&rdv,&mutex2);
if(count >1){
pthread_cond_signal(&rdv);
coun... | 0 |
#include <pthread.h>
int id;
pthread_t threadConsumidor;
}t_consumidor;
int in;
int out;
int buf[5];
sem_t empty;
sem_t full;
pthread_mutex_t mutex;
}BUFFER;
BUFFER sc;
int fibo[25];
int QTD_CONSUMERS;
int cont = 0;
void* consumer(void* thread);
void* producer();
void pri... | 1 |
#include <pthread.h>
pthread_t maleTID, femaleTID, makethreadTID1,makethreadTID2, makethreadTID3;
sem_t male_count, female_count, empty, turnstile;
pthread_mutex_t mutex_male = PTHREAD_MUTEX_INITIALIZER, mutex_female = PTHREAD_MUTEX_INITIALIZER,
mutex_thread=PTHREAD_MUTEX_INITIALIZER;
int m... | 0 |
#include <pthread.h>
struct _gg_pthread_lock {
pthread_cond_t cond;
pthread_mutex_t mtx;
int users;
int canceled;
};
void *ggLockCreate(void)
{
struct _gg_pthread_lock *ret;
int ct;
int dummy;
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &ct);
if ((ret = calloc(1, sizeof(struct _g... | 1 |
#include <pthread.h>
struct node_struct* next;
char* data;
pthread_mutex_t mtx;
} node;
pthread_mutex_t head_mtx;
node* head;
node* push_front(node* p, char* buf) {
int len = strlen (buf);
node* q = (node*) malloc (sizeof (node));
pthread_mutex_init (&(q -> mtx), 0);
q -> data = (char... | 0 |
#include <pthread.h>
int thread_count;
int n;
pthread_mutex_t mutex;
void Usage(char* prog_name);
unsigned My_random(unsigned seed);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
if (argc != 3) Usage(argv[0]);
... | 1 |
#include <pthread.h>
int arr[1000][1000];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void initArray()
{
int i = 0;
int j = 0;
for (i = 0; i < 1000; i++)
{
for (j = 0; j < 1000; j++)
{
srand(time(0));
arr[i][j] = rand() % 1 + 1;
... | 0 |
#include <pthread.h>
int sync_fd[3] = { 0, 1, 2 };
char *const sync_cmd[] = { "mbsync", "-a", 0 };
char *const mutt_cmd[] = { "mutt", 0 };
int done;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *mail_sync(void *d)
{
struct timespec wt;
... | 1 |
#include <pthread.h>
int g_ncount;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
void* threadFunc(void* args){
int i,val;
for(i = 0; i < 5000; i++){
pthread_mutex_lock(&g_mutex);
val = g_ncount;
printf("%x : %d\\n",(unsigned int)pthread_self(),val+1);
g_ncount = val + 1;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int count = 0;
void* function1( void* arg )
{
int tmp = 0;
while( 1 ) {
if(pthread_mutex_trylock(&mutex) == 16)
printf("%d: mutex is already locked\\n", pthread_self());
pthread_mutex_lock(... | 1 |
#include <pthread.h>
pthread_mutex_t _mutex_disc_access;
int _disc_access_init = 0;
void disc_access_init(){
if(!_disc_access_init){
_disc_access_init = 1;
pthread_mutex_init(&_mutex_disc_access, 0);
}
}
void disc_access_lock(){
pthread_mutex_lock(&_mutex_disc_... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t emptySlots;
pthread_cond_t filledSlots;
int buffer[10];
int in = 0;
int out = 0;
int count = 0;
void *producer(void *param);
void *consumer(void *param);
int main(int argc, char *argv[])
{
int i = 0;
if (argc != 2) { fprintf(... | 1 |
#include <pthread.h>
void guppi_thread_args_init(struct guppi_thread_args *a) {
a->priority=0;
a->finished=0;
pthread_cond_init(&a->finished_c,0);
pthread_mutex_init(&a->finished_m,0);
}
void guppi_thread_args_destroy(struct guppi_thread_args *a) {
a->finished=1;
pthread_c... | 0 |
#include <pthread.h>
void *adc_thread_handler(void *arg)
{
int adc_value;
int gprs_flag;
int led_flag;
int beep_flag;
while (1)
{
read(*((int *)arg), &adc_value, sizeof(adc_value));
pthread_mutex_lock(&SHM->status_mutex_temperature);
SHM->status_temperature = adc_value / 10;
pthre... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[3];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
len... | 1 |
#include <pthread.h>
pthread_mutex_t downloader_mutex, parser_mutex;
unsigned long downloaders[MAX_THREADS];
unsigned long parsers[MAX_THREADS];
int downloader_threads = 0;
int parser_threads = 0;
int wait_for_downloaders = 0;
char *fetch(char *link) {
int fd = open(link, O_RDONLY);
if (fd <... | 0 |
#include <pthread.h>
pthread_mutex_t lock1, lock2;
void *print_forever12(void *args) {
while (1) {
pthread_mutex_lock(&lock1);
fprintf(stdout, "Locked lock1...");
fprintf(stdout, "processing data...");
pthread_mutex_lock(&lock2);
fprintf(stdout, "... | 1 |
#include <pthread.h>
int
makethread(void *(*fn)(void *), void * arg) {
int err;
pthread_t tid;
pthread_attr_t attr;
err = pthread_attr_init(&attr);
if (err != 0)
return(err);
err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (err == 0)
err = pthread_create(&tid, &a... | 0 |
#include <pthread.h>
static int classificacao = 1;
static pthread_mutex_t lock;
static char * resp[200];
static int cont = 0;
void *Correr(void *sapo){
int pulos = 0;
int distanciaJaCorrida = 0;
while (distanciaJaCorrida <= 100)
{
int pulo = rand() % 100;
distanciaJaCorrida += pulo;
pulo... | 1 |
#include <pthread.h>
pthread_mutex_t chopstiks[5];
int philoTimeEating[5];
int philoTimeThinking[5];
void makeSemaphore(int size);
void* philosopher(void* philo);
void thinking(const int philo, const int thinkingTime, const int totalThinkingTime);
void eating(const int philo, const int eatingTim... | 0 |
#include <pthread.h>
int buffer[16];
int itemsPerConsumer;
int itemsPerProducer;
int counter = 0;
sem_t full;
sem_t empty;
pthread_mutex_t lock;
struct producerThread{
int pid;
int producerAmount;
};
void *consume(void *param){
int numberConsumed = *(int *) param;
int item;
... | 1 |
#include <pthread.h>
struct arg_set
{
char* fname;
int count;
};
struct arg_set* mailbox;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
void* count_words(void*);
int main( int ac, char* av[] )
{
if (ac < 2)
{
printf("\\n::pc... | 0 |
#include <pthread.h>
void * thread_read_spi_rx()
{
int ret_val =0;
unsigned char buffer;
sleep(1);
while(1)
{
while( ioctl(fd_spi,READ_GPIO,0) < 0 || SpiFlag != 1)
{
printf("\\n GPIO FAILED");
sleep(1);
}
SpiFlag = 0;
do
{
ret_val = read_data_spi(&buffer,1);
if(ret_va... | 1 |
#include <pthread.h>
void printPhilosophers() {
for (int i = 0; i < PHILOSOPHERS; i++) {
if (philosopher_condition[i] == HUNGRY) {
printf("%s", "HUNGRY ");
} else if (philosopher_condition[i] == THINKING) {
printf("%s", "THINKING ");
} else if (philosopher_cond... | 0 |
#include <pthread.h>
{
int stock;
pthread_t thread_store;
pthread_t thread_clients [2];
pthread_mutex_t mutex_stock;
}
store_t;
static store_t store =
{
.stock = 200,
.mutex_stock = PTHREAD_MUTEX_INITIALIZER,
};
static int get_random (int max)
{
double val;
val = (dou... | 1 |
#include <pthread.h>
struct BUFDATA {
int producer_tid;
int data_id;
struct BUFDATA *prev;
struct BUFDATA *next;
};
struct BUFDATA* head = 0;
pthread_mutex_t mutex;
int sema = 0;
int prod_num = 0;
int consum_num = 0;
int buf_size = 0;
int prod_count = 0;
int consum_count = 0;
void* producer(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t mutexProd;
pthread_mutex_t mutexCons;
pthread_cond_t emptySlots;
pthread_cond_t filledSlots;
int buffer[10];
int in = 0;
int out = 0;
int count = 0;
void *producer(void *param);
void *consumer(void *param);
int main(int argc, char *... | 1 |
#include <pthread.h>
struct work_args {
pthread_mutex_t *mutex;
struct timeval *start;
struct timeval *end;
double ***matrix;
int *row;
int id;
};
double do_crazy_computation(int i,int j);
double standard_deviation(double vals[], int length);
double average(double vals[... | 0 |
#include <pthread.h>
void *thr_sub(void *);
pthread_mutex_t lock;
int main(int argc, char **argv)
{
int thr_count = 100;
if(argc == 2){
thr_count = atoi(argv[1]);
}
printf("Creating %d threads...\\n", thr_count);
pthread_mutex_lock(&lock);
pthread_t thread... | 1 |
#include <pthread.h>
int done = 0;
int count = 0;
int quantum = 2;
int thread_ids[4] = {0,1,2,3};
int thread_runtime[4] = {0,5,4,7};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void * inc_count(void * arg);
static sem_t count_sem;
int quit = 0;
void *inc_count(void *t)... | 0 |
#include <pthread.h>
const int MAXIMUN_RGB = 255;
struct YUV * LUT_RGB2YUV [64][64][64];
int isInitTableYUV;
pthread_mutex_t mutex;
void rgb2yuv_wiki (double r, double g, double b, double *Y, double *U, double *V)
{
r = r / MAXIMUN_RGB;
g = g / MAXIMUN_RGB;
b = b / MAXIMUN_RGB;
... | 1 |
#include <pthread.h>
char write_file[3][10] = {"11.c", "12.c", "13.c"};
char buf[1024];
int over_flag = 0;
int write_flag = 1;
int read_flag[3] = {100, 100, 100};
int src_fd, dest_fd[3],len, size;
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INI... | 0 |
#include <pthread.h>
volatile int count = 0;
pthread_mutex_t count_lock;
void *process(void *arg)
{
int procid = *((char *) arg) - '0';
while (1) {
pthread_mutex_lock(&count_lock);
if (count < 1000) {
count++;
} else {
pthread_mutex_unlock(&count_lock); break;
... | 1 |
#include <pthread.h>
int *table;
int flour=1000;
pthread_mutex_t kitchen;
void *mother() {
int sec=0,i=0;
while(flour>0) {
if(table[i]==0) {
pthread_mutex_lock(&kitchen);
sec=rand()/(32767/100)+1;
if(sec>flour) {
sec=flour;
}
usleep(sec*1000);
flour-=sec;
table[i]=1;... | 0 |
#include <pthread.h>
struct thread_content
{
pthread_mutex_t *mutex[2];
};
void *print(void *value)
{
pthread_t selfID = pthread_self();
struct thread_content *ptr = (struct thread_content*)value;
for(int it=0;it<100000;it++)
{
for(;;)
{
pthread_mutex_lock(ptr->mutex[0]);
if(pt... | 1 |
#include <pthread.h>
pthread_mutex_t id;
int recursive;
pthread_t owner;
} Mutex_t;
Mutex_t *CreateMutex (void)
{
Mutex_t *mutex;
pthread_mutexattr_t attr;
mutex = (Mutex_t *)calloc(1, sizeof(*mutex));
if ( mutex ) {
pthread_mutexattr_init(&attr);
... | 0 |
#include <pthread.h>
int first_pack = 0;
struct timeval dateInicio, dateFin;
pthread_mutex_t lock;
int mostrarInfo = 0;
int MAX_PACKS = 0;
int NTHREADS = 0;
double segundos;
void print_usage(){
printf("Uso: ./dev_null [--verbose] --packets <num> --threads <num>\\n");
}
void print_config... | 1 |
#include <pthread.h>
int w, h;
v2df zero = { 0.0, 0.0 };
v2df four = { 4.0, 4.0 };
v2df nzero;
double inverse_w;
double inverse_h;
char *whole_data;
int y_pick;
pthread_mutex_t y_mutex = PTHREAD_MUTEX_INITIALIZER;
static void * worker(void *_args) {
char *data;
double x, y;
int ... | 0 |
#include <pthread.h>
void funregister(FILE* fp)
{
if ( !(fp->flags & _FILE_REGISTERED) )
return;
pthread_mutex_lock(&__first_file_lock);
if ( !fp->prev )
__first_file = fp->next;
if ( fp->prev )
fp->prev->next = fp->next;
if ( fp->next )
fp->next->prev = fp->prev;
fp->flags &= ~_FILE... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void taskA(void *threadid)
{
int i;
for(i = 0; i < 5; i++) {
pthread_mutex_lock(&mutex1);
sleep(1);
pthread_mutex_lock(&mutex2);
printf("tas... | 0 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t l = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t n = PTHREAD_MUTEX_INITIALIZER;
{
uint64_t number;
int k;
struct node *next;
uint64_t factors[64];
} node_t;
struct arg_struct
{
FILE *arg1;
... | 1 |
#include <pthread.h>
pthread_t philosopher[5];
pthread_mutex_t spoon[5];
void *dine(int n)
{ printf("\\nPhilosopher %d is thinking ",n);
pthread_mutex_lock(&spoon[n]);
pthread_mutex_lock(&spoon[(n+1)%5]);
printf("\\nPhilosopher %d is eating ",n);
sleep(1);
pthread_mutex_unlock(&spoon[n])... | 0 |
#include <pthread.h>
int PLPA_NAME(initialized) = 0;
static int refcount = 0;
static pthread_mutex_t mutex;
int PLPA_NAME(init)(void)
{
int ret;
if (PLPA_NAME(initialized)) {
pthread_mutex_lock(&mutex);
++refcount;
pthread_mutex_unlock(&mutex);
... | 1 |
#include <pthread.h>
static int ready = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static void *
mythr(void *ignore)
{
pthread_mutex_lock(&mutex);
ready = 1;
pthread_cond_signal(&cond);
pthread_mutex_unlo... | 0 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main(int argc, const char *argv[])
{
int res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if(res != 0) {
... | 1 |
#include <pthread.h>
void * Producer();
void * Consumer();
int BufferIndex = 0;
char *BUFFER;
pthread_cond_t Buffer_Not_Full = PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar = PTHREAD_MUTEX_INITIALIZER;
int main(){
pthread_t ptid, ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
struct pthread_block
{
int fdin;
int fdout;
int start;
int end;
};
int get_size(const char *filename)
{
struct stat file_stat;
stat(filename,&file_stat);
return file_stat.st_size;
}
void *pthread_func(void *args)
{
struct pthread_block... | 1 |
#include <pthread.h>
pthread_t thread[3];
pthread_mutex_t mut1,mut2;
pthread_cond_t cond_sum_ready;
pthread_cond_t cond_mut1_ready;
int number=1, serial=1;
char buf1[100] = {0};
char buf2[100] = {0};
char buf3[100] = {0};
char name[30] = {0};
int fd1=0,fd2=0,fd3=0,fd4=0;
sem_t sem;
void *thread... | 0 |
#include <pthread.h>
int *globalvector;
long range;
int nthreads;
int cur_number = 0;
pthread_mutex_t plock;
struct return_values
{
int element;
int nprimes;
int *primes;
};
void *runthread(void *param);
int main(int argc, char *argv[])
{
int total_primes =0, j, number_printed=0;
t... | 1 |
#include <pthread.h>
FILE * fptr;
extern pthread_mutex_t *m_LOCK;
extern int *s_shm, * c_shm;
struct timespec some_time;
int my_rand(int start, int range){
struct timeval t;
gettimeofday(&t, (struct timezone *)0);
return (int) (start+(float)range*rand_r((unsigned *)&t.tv_usec)/(32767 +1.0));
}... | 0 |
#include <pthread.h>
char *start=0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int avail = 0;
static void * threadFunc1(void *arg)
{
int ret, i = 0;
char data=64;
sleep(1);
while(data<84) {
pthread_mutex_lock(&mutex);
... | 1 |
#include <pthread.h>
FILE *logFile;
static volatile __u8 logging = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void voltageListener() {
if (logging) {
struct timeval t;
gettimeofday(&t, 0);
double now = t.tv_sec + t.tv_usec / (double) 1000000;
pthread_mutex_lock... | 0 |
#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;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 5)
... | 1 |
#include <pthread.h>
int isEndOfFile;
int isPass;
int threadWorking;
int isTimeTest;
char* passToHack;
char* salt;
int countProcess;
void* source;
long progress;
int iteration;
long fileSize;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void threadFunc(int* args);
int isPassCorrect(c... | 0 |
#include <pthread.h>
void* arg;
void* (*process)(void* arg);
struct Tasks* next;
}PthreadTasks;
pthread_mutex_t lock;
pthread_cond_t task_sig;
PthreadTasks* head_task;
pthread_t* tid_array;
int status;
int max_thread_num;
int cur_queue_num;
}Thread_pool;
static Th... | 1 |
#include <pthread.h>
static pthread_mutex_t g_logger;
static int g_loglevel;
void hs_init_log(int loglevel)
{
g_loglevel = loglevel;
if (pthread_mutex_init(&g_logger, 0)) {
perror("loger pthread_mutex_init failed");
exit(1);
}
}
int hs_get_log_level()
{
return g_loglevel;
}
v... | 0 |
#include <pthread.h>
int readers;
int writer;
pthread_cond_t readers_proceed;
pthread_cond_t writer_proceed;
int pending_writers;
pthread_mutex_t read_write_lock;
} mylib_rwlock_t;
char** theArray;
pthread_mutex_t mutex;
mylib_rwlock_t rwlock;
void* ServerEcho(void *args)... | 1 |
#include <pthread.h>
struct Request;
struct Reply;
struct GroupComm;
struct Msg;
struct Request{
int opid;
int gid;
};
struct Reply{
char host[512];
int port;
};
struct GroupComm{
int port;
};
struct Msg{
char data[512];
};
int semkey = -1;
int semid = 0;
struct pollfd cfd[1024];
int numclien... | 0 |
#include <pthread.h>
void insert(struct tree_node **ptr, struct payload *obj)
{
if (*ptr == 0) {
*ptr = (struct tree_node *)malloc((sizeof(struct tree_node)));
(*ptr)->val = obj->id;
(*ptr)->data = obj->data;
(*ptr)->left = 0;
(*ptr)->right = 0;
(*ptr)->height = -1;
LOG("node %p val... | 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 && count < 12; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (... | 0 |
#include <pthread.h>
int** matrix;
int order;
int sort_index;
} sort_t;
int** A;
int** B;
int** C;
int order;
int sort_index;
} add_t;
pthread_mutex_t lock;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void * initialize_matrix(void * arg,int flag) {
if (flag == 0){
so... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *do_work(void *data)
{
char buf[128];
int count = 0, i;
int fd = *(int *)data;
pthread_mutex_lock(&mutex);
while(1)
{
if (count >= 100)
{
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
snprintf(buf, sizeof(buf), "pthread_id ... | 0 |
#include <pthread.h>
pthread_t tid1;
pthread_t tid2;
int status;
pthread_mutex_t lock;
int mine[17];
int poin;
int lub;
int mine2[17];
int poin2;
int lub2;
int htung;
int htung2;
}pmn;
void* pemain1(void *arg)
{
pthread_mutex_lock(&lock);
struct player *maen = (struct player*)arg;... | 1 |
#include <pthread.h>
struct timeval t0;
struct timeval t1;
static unsigned len = 2000000;
pthread_t tid[16];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int v;
struct p * left;
struct p * right;
} p;
struct p *tree;
struct p * newNode(int value) {
struct p * node = (struct p*)... | 0 |
#include <pthread.h>
pthread_t *clientthreads;
int threadscreated;
int numthreads = 1;
int numrequests = 1;
char* ipaddress = "127.0.0.1";
int port = 8080;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
pexit(char * msg)
{
perror(msg);
exit(1);
}
void request(int id)
{
pthr... | 1 |
#include <pthread.h>
int *buf;
int size;
int head;
int tail;
pthread_mutex_t mutex;
pthread_cond_t not_full;
pthread_cond_t not_empty;
} buf_t;
static inline bool is_full(buf_t *buf)
{
return buf->head == (buf->tail + 1) % buf->size;
}
static inline bool is_empty(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
phil_state state[5 +1];
sem_t spoon[5 +1];
sem_t phil_sem[5 +1];
void* philosopher(void* p);
void pick_forks(int i);
void put_forks(int i);
void thinking(int i);
void test(int i);
void eat(int i);
int main()
{
int i,... | 1 |
#include <pthread.h>
int idx=0;
int ctr1=1, ctr2=0;
int readerprogress1=0, readerprogress2=0;
pthread_mutex_t mutex;
void __VERIFIER_atomic_use1(int myidx) {
__VERIFIER_assume(myidx <= 0 && ctr1>0);
ctr1++;
}
void __VERIFIER_atomic_use2(int myidx) {
__VERIFIER_assume(myidx >= 1 && ctr... | 0 |
#include <pthread.h>
void*
thread_func(void *arg)
{
pthread_mutex_t locl_lock;
int err;
if((err = pthread_mutex_lock(&locl_lock)) != 0){
printf("lock error: %s\\n", strerror(err));
}
pthread_mutex_lock(&locl_lock);
if((err = pthread_mutex_lock(&locl_lock)) != 0){... | 1 |
#include <pthread.h>
struct Node {
int value;
struct Node *next;
}*head;
pthread_mutex_t inserter;
pthread_mutex_t searcher;
pthread_mutex_t deleter;
void ins()
{
struct Node * temp;
while(1)
{
if (!pthread_mutex_lock(&inserter))
{
int input = (ra... | 0 |
#include <pthread.h>
int max = 1000000000;
int sharedResource = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* fooAPI(void* param)
{
int i;
pthread_mutex_lock(&mutex);
printf("Changing the shared resource now.\\n");
for(i = 0; i < max; i++){
sharedResource += 1;
}
pthre... | 1 |
#include <pthread.h>
struct worker_queue {
pthread_t tid;
pthread_mutex_t mutex;
pthread_cond_t cond;
pthread_attr_t attr;
void (*func)(void *priv);
int done;
void *priv;
struct worker_queue *next;
};
struct work {
struct worker_queue *queue_head, *queue_tail;
... | 0 |
#include <pthread.h>
struct prevList {
struct prevList *prev;
int pos;
int no;
};
int x(int);
int y(int);
void *backtrace(void *);
int movex[] = {1, 2, 2, 1, -1, -2, -2, -1};
int movey[] = { -2, -1, 1, 2, 2, 1, -1, -2};
int threads;
int solutions;
pthread_mutex_t printLock;
pthread_mutex_t... | 1 |
#include <pthread.h>
FILE *arquivo;
unsigned int id;
char nome[256];
char sexo;
float salario;
} funcionario;
int contM, contF, num_threads = 2;
float salarioM, salarioF;
char* base_funcionarios;
pthread_mutex_t calculo;
void inserir_funcionario(){
funcionario fc;
printf("\\nInsira o id:\\... | 0 |
#include <pthread.h>
int stoj = 0;
int smeVsetci = 0;
int volnePece = 4, oddychujuci = 0;
int chleby[10] = {0}, pocetChlebov = 0;
pthread_mutex_t mutexChleby = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexSynchronizacia = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexOddychovanie = PTHREAD... | 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_r(const char *name)
{
int i, ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.