text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t mutex;
unsigned int counter;
char *buffer_ptr;
struct pthread_args
{
unsigned int tid;
unsigned int chunk_size;
unsigned int* histogram;
};
void * local_histo (void * ptr)
{
unsigned int i;
struct pthread_args *arg = ptr;
while (buffer_ptr[(counter... | 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;
l... | 0 |
#include <pthread.h>
struct prodcons{
int buffer[8];
pthread_mutex_t lock;
int readpos,writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct prodcons *b)
{
pthread_mutex_init(&b->lock,0);
pthread_cond_init(&b->notempty,0);
pthread_cond_in... | 1 |
#include <pthread.h>
struct prodcons
{
int buffer[2];
pthread_mutex_t lock;
int readpos;
int writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct prodcons *prod)
{
pthread_mutex_init(&prod->lock, 0);
pthread_cond_init(&prod->notempty, 0);
pthread_cond_init(&pr... | 0 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *lock_worker(void *arg) {
for (size_t i = 0; i < 100000; ++i) {
pthread_mutex_lock(&mutex);
++counter;
pthread_mutex_unlock(&mutex);
}
return arg;
}
void *trylo... | 1 |
#include <pthread.h>
void findPet(char searchName[32], int clientfd, int r){
pthread_mutex_lock(&lock);
sem_wait(semaforo);
read(pipefd[0], &witness, sizeof(char));
char petName[32];
int founds = 0;
int headHash = allHashPets[hashFunction(searchName)];
struct dogType... | 0 |
#include <pthread.h>
NEW,
PROCESSING,
DONE
}statuses;
int duration;
int id;
statuses status;
pthread_t worker;
} task_t;
pthread_mutex_t lock;
task_t tasks[100];
void* my_thread(void* var){
int frag = 0, k = *((int*)(var + 4));
long long unsigned worker = *((pthread_t*)(var + 8 + size... | 1 |
#include <pthread.h>
int stoj = 0;
int dar_od_lovcov = 0;
int dar_od_zberacov = 0;
pthread_mutex_t mutex_dari_lovcov = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_dari_zberacov = PTHREAD_MUTEX_INITIALIZER;
sem_t l_controll, z_controll;
int l_count = 0;
int z_count = 0;
sem_t room_empty;
se... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int *blink;
} params_t;
void cleanup() {
gpio_unexport(17);
gpio_unexport(18);
}
void sigint_handler(int sig) {
printf("Detected CTROL+C, cleaning up and exiting...\\n");
cleanup();
exit(0);
}
void *blink_function(void ... | 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)
err_exit(err, "sigwait failed");
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
static void *increment(void *arg)
{
long *counter = arg;
for(long i=0; i<1000000; i++)
{
pthread_mutex_lock(&mutex);
*counter = *counter+1;
pthread_mutex_unlock(&mutex);
}
return 0;
}
static void *decrement(void *arg)
{
long *... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
long long int N,i_global;
int n_threads;
int * total_primos;
int ehPrimo(long long int n) {
int i;
if (n<=1) return 0;
if (n==2) return 1;
if (n%2==0) return 0;
for (i=3; i<sqrt(n)+1; i+=2)
if(n%i==0) return 0;
return 1;
}
void * contra... | 0 |
#include <pthread.h>
struct libpthreadpool_heap_t *libpthreadpool_create_heap()
{
struct libpthreadpool_heap_t *ret;
ret = xmalloc(sizeof(struct libpthreadpool_heap_t));
ret->arr = xmalloc(8 * sizeof(struct libpthreadpool_task_t));
ret->len = 8;
ret->occ = 0;
if(pthread_mutex_init(&ret->... | 1 |
#include <pthread.h>
volatile unsigned int value = 0;
pthread_mutex_t value_mtx = PTHREAD_MUTEX_INITIALIZER;
char* program_name = 0;
void *not_synchronized(void *ntimes)
{
unsigned int i;
for (i = *(unsigned int *)ntimes; i > 0; i--) {
value--;
}
pthread_exit(0... | 0 |
#include <pthread.h>
int nitems;
int buff[100000];
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 * pro... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full, empty;
buffer_type buffer[5];
int counter;
pthread_t thread_id;
pthread_attr_t attr;
void *producer_thread(void *param);
void *consumer_thread(void *param);
void initializi() {
pthread_mutex_init(&mutex, 0);
sem_init(&fu... | 0 |
#include <pthread.h>
static time_t update_config_time;
static time_t update_sector_time;
extern pthread_mutex_t ourMutex;
void elf_update_timer_init(void)
{
update_config_time = time(0);
update_sector_time = time(0);
}
void elf_update_timer_handler(void)
{
time_t now = time... | 1 |
#include <pthread.h>
int ringbuffer_empty(struct ringbuffer_s *rb)
{
if (0 == rb->fill) {
return 1;
}else {
return 0;
}
}
int ringbuffer_full(struct ringbuffer_s *rb)
{
if (rb->size == rb->fill) {
return 1;
}else {
return 0;
}
}
int ringbuffer_currentSize(struct ringbuffer_s *... | 0 |
#include <pthread.h>
int count = 0;
pthread_t t;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread_func(void *p)
{
while (count < 50)
{
pthread_mutex_lock(&mutex);
int i = 0;
for (i = 0; i < 10; i... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(800)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR: __VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{... | 0 |
#include <pthread.h>
extern pthread_mutex_t public_crc16_mutex;
extern pthread_mutex_t public_crccheck_mutex;
unsigned short crc16_ccitt_table[256] ={
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108,... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int cnt;
void espera_activa( int tiempo) {
time_t t;
t = time(0) + tiempo;
while(time(0) < t);
}
void *tareaA( void * args) {
printf("tareaA::voy a dormir\\n");
sleep(3);
printf("tareaA::me despierto y pillo mutex\\n");
pthread_mutex_lo... | 0 |
#include <pthread.h>
void initializeData(struct ElevatorData *ed);
int main(){
struct ElevatorData x;
initializeData(&x);
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, 0);
pthread_t threads[4];
struct ArgumentData ad;
ad.ed = &x;
ad.mutex = &mutex;
int error;
... | 1 |
#include <pthread.h>
struct stack {
char x[PTHREAD_STACK_MIN];
};
static pthread_mutex_t mutex[(503)];
static int data[(503)];
static struct stack stacks[(503)];
static void* thread(void *num)
{
int l = (int)num;
int r = (l+1) % (503);
int token;
while(1) {
pthread_m... | 0 |
#include <pthread.h>
pthread_mutex_t m[5];
void *tfn(void *arg)
{
int i,l,r;
srand(time(0));
i=(int)arg;
if(i==4)
l=0,r=i;
else
l=i;r=i+1;
for(;;)
{
pthread_mutex_lock(&m[l]);
if(pthread_mutex_trylock(&m[r])==0)
{
... | 1 |
#include <pthread.h>
pthread_mutex_t cnt_mutex = PTHREAD_MUTEX_INITIALIZER;
int shmid;
key_t key;
int SHMSZ = sizeof(int);
struct Stuff {
int* shm_ptr;
};
void * Count(void * stuff)
{
int i, tmp;
for(i = 0; i < 1000000; i++)
{
int* ptr = ((struct Stuff*) stuff)->shm_ptr;... | 0 |
#include <pthread.h>
char **memoryTrace;
int lastIndex = 1024 - 1;
int memoryIndex = 0;
void markMemory(char *data);
pthread_mutex_t writeMutex;
void initMyMalloc()
{
memoryTrace = malloc(1024*sizeof(char *));
memset(memoryTrace,0,1024*sizeof(char *));
pthread_mutex_init(&writeMu... | 1 |
#include <pthread.h>
pthread_t threads[4];
pthread_mutex_t lock;
int pearls = 1000;
double A=0;
double B=0;
double C=0;
double D=0;
void * takePearlsAB(void *arg){
double ten= 0.10;
while(pearls > 0){
if(threads[0]){
pthread_mutex_lock(&lock);
printf("Pirate A took: %.2lf pearl... | 0 |
#include <pthread.h>
int len;
char data[0];
}QueueNode;
int size;
int head;
int tail;
int num;
pthread_mutex_t lock;
char buffer[0];
}Queue;
Queue* queue_init( int size){
Queue *p;
p = (Queue*)malloc(size);
memset(p, 0, sizeof(Queue));
size -= (int)(((Queue*)0)->buffer);
p->s... | 1 |
#include <pthread.h>
struct rtpp_pcount_priv {
struct rtpp_pcount pub;
struct rtpps_pcount cnt;
pthread_mutex_t lock;
};
static void rtpp_pcount_dtor(struct rtpp_pcount_priv *);
static void rtpp_pcount_reg_reld(struct rtpp_pcount *);
static void rtpp_pcount_reg_drop(struct rtpp_pcoun... | 0 |
#include <pthread.h>
void search_by_thread( void* ptr);
{
char* start_ptr;
char* end_ptr;
int slice_id;
} slice_data;
{
char* start_ptr;
char* end_ptr;
int thread_id;
int num_slices;
int slice_size;
char match_str[15];
char* array_address;
slice_data* slice_struct_address;
} thread... | 1 |
#include <pthread.h>
int threads = 0;
pthread_mutex_t mutex;
pthread_cond_t cond_pode_ler;
pthread_cond_t cond_pode_escrever;
int lendo = 0;
int escrevendo = 0;
unsigned long mix(unsigned long a, unsigned long b, unsigned long c);
void entra_leitura()
{
pthread_mutex_lock(&mutex);
... | 0 |
#include <pthread.h>
pthread_mutex_t counter_clock=PTHREAD_MUTEX_INITIALIZER;
int total_words=0;
int main(int ac,char* av[])
{
int pc;
pthread_t t1,t2;
void*count_words(void*);
if(ac!=3)
{
printf("Usage:%s file1 file\\n",av[0]);
exit(1);
}
pc=pthread_create(&t1,0,count_words,av[1]);
... | 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 i=(int)arg;
int ret;
sleep(5-i);
pthread_mutex_lock(&mylock);
while(i!=num)
{
printf("thread %d waiting\\n",i);
ret=pth... | 0 |
#include <pthread.h>
struct Msg{
struct Msg *next;
int data;
};
struct Msg *workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
void process_msg(void)
{
struct Msg *mp;
for( ; ;){
pthread_mutex_lock(&qlock)... | 1 |
#include <pthread.h>
int p_id;
int p_fila;
int p_columna;
int p_weapon;
}people;
char** board;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void move_people(people *persona, char** board){
printf("Pifia1\\n");
int i, j;
i = persona->p_fila;
j = perso... | 0 |
#include <pthread.h>
static int reader_count = 0;
static pthread_mutex_t reader_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t new_op_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t writer_mutex = PTHREAD_MUTEX_INITIALIZER;
void justice_reader(int num, int duration) {
pth... | 1 |
#include <pthread.h>
char alphabet[26] = "abcdefghijklmnopqrstuvwxyz";
pthread_t t[2];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void print_alphabet(){
for (int i = 0; i < 26; i++) {
printf("%c", alphabet[i]);
}
printf("\\n");
}
void *reverse(void *arg){
(void) arg;
while ... | 0 |
#include <pthread.h>
int usage;
char buf[MESSAGE_SIZE];
char* next;
}chain;
struct send {
int index;
char* smsg;
pthread_t p_send;
};
struct receive {
int index;
char* rmsg;
pthread_t p_receive;
};
chain* messages;
struct send sends[MAXSEND_T];
struct receive receives[MAXRECE... | 1 |
#include <pthread.h>
{
unsigned char status;
char data[1024];
}Block_Info;
pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;
Block_Info memory_block_arr[2];
static int initindicator = 0;
int init()
{
if (0 == initindicator)
{
pthread_mutex_lock(&gmutex);
if (0 == initindicator)
... | 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>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER(count_mutex);
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER(condition_mutex);
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER(condition_cond);
void *functionCount1();
void *functionCount2();
int c... | 0 |
#include <pthread.h>
statusThinking,
statusWaiting,
statusEating
} status;
status states[5];
int eatCount[5];
pthread_t philosophers[5];
pthread_mutex_t chopsticks[5];
pthread_mutex_t mutex;
void printStatus() {
fprintf(stdout, "\\nPrinting the status of all 5 philosophers:... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
{
int id;
char name[20];
}STU_T;
{
STU_T st;
struct stu * next;
}NODE;
NODE * H = 0;
void *handler(void *arg)
{
NODE *p = 0;
while(1)
{
pthread_mutex_lock(&lock);
if(H != 0)
{
p = H;
H = H->next;
printf("recv student message: i... | 0 |
#include <pthread.h>
void statistic_reset_r(struct Statistic *s, struct Statistic *d, int flag) {
if (s && 0 == pthread_mutex_lock(&s->mutex)) {
int f = flag ? flag : STAT_RESET_ALL;
if (d) {
d->value = s->value;
d->count = s->count;
d->tota... | 1 |
#include <pthread.h>
struct vehicles{
char* vPlate;
int id;
pthread_t tid;
int arrDelay;
int vWeight;
int crossTime;
struct vehicles *next;
struct vehicles *prev;
};
static int totalVehicles;
static int bridgeload;
static pthread_mutex_t access;
static pthread_cond_t ok=PTHREAD_C... | 0 |
#include <pthread.h>
void *watch_resources(void *t)
{
long my_id = (long)t;
printf("Starting watch_count(): thread %ld\\n", my_id);
while(not_quit)
{
pthread_mutex_lock(&remaining_resources_mutex);
printf("watch_resources(): thread %ld Remaining resources= %d. ... | 1 |
#include <pthread.h>
static char *l_trim(char * szOutput, const char *szInput)
{
assert(szInput != 0);
assert(szOutput != 0);
assert(szOutput != szInput);
while(*szInput != '\\0' && isspace(*szInput))
{
++szInput;
}
return strcpy(szOutput, szInput);
}
static... | 0 |
#include <pthread.h>
pthread_t philosopher[5];
pthread_mutex_t chopstick[5] = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER};
struct philosopher_t {
int nr;
int left;
... | 1 |
#include <pthread.h>
struct pid_data{
pthread_mutex_t pid_mutex;
pid_t pid;
};
struct thread_args{
char message[100];
int priority;
};
static int server_PID;
int set_priority(int priority){
int policy;
struct sched_param param;
if (priority < 1 || priority > 63) return -1;
pthread_gets... | 0 |
#include <pthread.h>
void reader_read(int divider);
void writer_write();
pthread_mutex_t readers_waiting_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t readers_waiting_cond = PTHREAD_COND_INITIALIZER;
int readers_waiting = 0;
pthread_mutex_t writer_locked_mutex = PTHREAD_MUTEX_INITIALIZER;... | 1 |
#include <pthread.h>
struct msg {
int len;
int seq;
char data[20];
};
struct rbuff *rbuff = 0;
pthread_mutex_t iolock = PTHREAD_MUTEX_INITIALIZER;
void *
func_enqueue(void *arg)
{
struct msg msg;
void *buffer = 0;
int i, writen = 0, left = 0;
int num = atoi((char *)arg... | 0 |
#include <pthread.h>
static int capture_fd = -1;
static pthread_mutex_t captureMutex ;
static char capture_fd_opened = -1;
void capture_init()
{
pthread_mutex_init(&captureMutex, 0);
}
void capture_term()
{
pthread_mutex_destroy(&captureMutex);
}
int capture_open()
{
unsigned int capture_fd_n... | 1 |
#include <pthread.h>
static Display *dpy;
void close_dpy(void) { XCloseDisplay(dpy); }
char* data;
size_t maxlen;
} lazystr;
void lazystr_init(lazystr* s) {
s->data = malloc(16*sizeof(char));
s->data[0]='\\0';
s->maxlen = 16 -1;
}
void lazystr_fitatleast(lazystr* s, size_t len) {
if (len ... | 0 |
#include <pthread.h>
pthread_mutex_t mx, my;
int x=2, y=2;
void *thread1() {
int a;
pthread_mutex_lock(&mx);
a = x;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
pthread_mutex_unlock(&my);
a =... | 1 |
#include <pthread.h>
void add_to_queue(struct list *e, int local)
{
pthread_mutex_lock(&access_queues);
if(local==0)
{
queue_local->next = e;
queue_local = queue_local->next;
num_elem_local++;
}
else
{
queue_ext->next = e;
queue_ext = queue_ext->next;
num_elem_ext++;
}
p... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *another(void *arg)
{
printf("child thread\\n");
pthread_mutex_lock(&mutex);
sleep(3);
pthread_mutex_unlock(&mutex);
}
void prepare()
{
pthread_mutex_lock(&mutex);
}
void parent()
{
pthread_mutex_unlock(&mutex);
}
... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static void *thr_primer(void *p);
int main()
{
int i,err;
pthread_t tid[3];
for(i = 0; i < 3; i++)
{
err = pthread_create(tid+i,0,thr_primer,(void *)i);
if(err)
{
fprintf(stderr... | 0 |
#include <pthread.h>
int argv[];
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
int numero_lineas(char *ruta, int *tam_lineas){
if(ruta != 0){
FILE* ar = fopen(ruta, "r");
int lineas = 0;
int tam_linea;
while(!feof(ar)){
tam_linea++;
char c = getc(ar);
if(c == '\\n'){
... | 1 |
#include <pthread.h>
struct msg
{
int num;
struct msg *next;
} ;
struct msg *head;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
void *producer(void *p);
void *consumer(void *p);
int main(int argc, const char *argv[])
{
pthre... | 0 |
#include <pthread.h>
int buffer[3];
int size;
int error;
pthread_mutex_t lock;
pthread_t threads[1 + 1];
void * produce (void *arg) {
int i;
for(i = 0; i < 5; i++) {
pthread_mutex_lock(&lock);
if (size < 3) {
buffer[size] = 1;
size++;
}
pthread_mutex_unlock(&lock);
}
ret... | 1 |
#include <pthread.h>
int cartas = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_pombo = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_user = PTHREAD_COND_INITIALIZER;
void* pombo() {
while(1) {
pthread_mutex_lock(&lock);
if (cartas >= 0) ... | 0 |
#include <pthread.h>
static pthread_mutexattr_t mp_mutex_attr;
static pthread_mutex_t mp_mutex;
extern struct fuse_lwext4_options fuse_lwext4_options;
static void mp_lock()
{
pthread_mutex_lock(&mp_mutex);
}
static void mp_unlock()
{
pthread_mutex_unlock(&mp_mutex);
}
static struct ext4_lock... | 1 |
#include <pthread.h>
void AC_init(struct arp_cache *AC)
{
AC->length=0;
int i;
for(i=0; i<MAX_AC_LEN; i++)
{
AC->list[i].ip_addr=0;
}
pthread_mutex_init(&(AC->AC_mutex), 0);
pthread_create(&(AC->thread), 0, AC_update, AC);
}
void AC_insert(struct arp_cache* AC, uint32_t ip_addr, unsigne... | 0 |
#include <pthread.h>
double sumPi( int startN, int count ) {
double s = 0;
int n;
for( n = startN; n<startN+count; n++ ) {
s += pow( -1, n + 1 ) * 4 / ( 2*n -1 );
}
return s;
}
int epp;
int len;
} tdata;
double pi = 0;
pthread_mutex_t mutex = PTHREAD_MUT... | 1 |
#include <pthread.h>
enum {
eUndefinedId,
};
int id;
EvCallback onEvent;
} Listener;
static Listener NullLis = {.id = eUndefinedId, .onEvent = 0};
static Listener gListeners[6] = {{eUndefinedId, 0}};
static pthread_mutex_t gLisMutex;
void initListenerGroup() {
pthread_mutex_... | 0 |
#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 ... | 1 |
#include <pthread.h>
int primes[10000];
int pflag[10000];
int total = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int is_prime(int v)
{
int i;
int bound = floor(sqrt(v)) + 1;
for (i = 2; i < bound; i++) {
if (!pflag[i])
continue;
if (v ... | 0 |
#include <pthread.h>
int num = 0, switch_count = 0;
int child_status;
float thread_switching_times[1000];
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
double timespec_to_ns(struct timespec *t... | 1 |
#include <pthread.h>
struct target {
unsigned long ip;
unsigned short port;
struct target *next;
} *targets = 0;
char *progname;
pthread_mutex_t lock;
void
error (char *err)
{
fprintf (stderr, "%s: %s\\n", progname, err);
exit (1);
}
unsigned long
host_resolve (char *host)
{
struc... | 0 |
#include <pthread.h>
THREAD_STATE_RUNNING,
THREAD_STATE_WAIT,
} DbgCpuThrStateType;
static pthread_mutex_t dbg_mutex;
static pthread_cond_t dbg_cv;
static pthread_cond_t cpu_cv;
static volatile DbgCpuThrStateType dbgthr_state = THREAD_STATE_RUNNING;
static volatile DbgCpuThrStateType cputhr_sta... | 1 |
#include <pthread.h>
char buffer[1024];
int bytesReceived = 1;
int bytesInBuffer = 0;
pthread_mutex_t mutex;
void *interfaceThread( void *arg ) {
short terminated = 0;
int bytesPrinted = 0;
int lines_count = 0;
while (1) {
pthread_mutex_lock(&mutex);
if ((0 == bytesReceived) && (bytesInBu... | 0 |
#include <pthread.h>
int addHrac(int c_socket, char* nazev);
int removeHrac(int id);
int removeHracSoc(int clie_soc);
int getHracIndex(int socket);
int broadcastHraci(char *text);
int broadcastToLobby(int *hraciX, int SocketHraceVynechat, char *text);
struct Hrac* boostHraci();
struct Hrac... | 1 |
#include <pthread.h>
int udp_init_client(struct udp_conn *udp, int port, char *ip)
{
struct hostent *host;
if ((host = gethostbyname(ip)) == 0) return -1;
if (pthread_mutex_init(&udp->lock, 0) != 0) return -2;
udp->client_len = sizeof(udp->client);
memset((char *)&(udp->server), 0, sizeo... | 0 |
#include <pthread.h>
int reader_cnt = 0;
pthread_mutex_t read_cnt_mutex,rw_mutex;
int cnt = 3;
void *write_handle(void *arg);
void *read_handle(void *arg);
int main(void)
{
int type;
pthread_t tid_r, tid_w;
srand(getpid());
pthread_mutex_init(&read_cnt_mutex, 0);
pthread_mutex_init(&rw_mute... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int next(int n)
{
if (n+1 == 4) {
return 0;
}
return n+1;
}
void* func(void *p)
{
int i = (int)p;
int c= 'a'+ i;
while (1) {
p... | 0 |
#include <pthread.h>
pthread_t thread[20];
pthread_mutex_t mut;
{
int num;
int money;
}red_Packet;
static red_Packet redPacket = {0};
void *woker()
{
int money = 0;
pthread_mutex_lock(&mut);
if(redPacket.num <= 0)
{
pthread_mutex_unlock(&mut);
... | 1 |
#include <pthread.h>
struct mbox mbox_sort_recv, mbox_sort_send;
struct mbox mbox_mmul_recv, mbox_mmul_send;
struct reconos_hwt hwt[11];
struct reconos_resource sort_res[2];
struct reconos_resource mmul_res[2];
struct reconos_configuration sort_cfg[11];
struct reconos_configuration mmul_cfg[11... | 0 |
#include <pthread.h>
struct game_state master_state;
pthread_mutex_t master_state_mutex = PTHREAD_MUTEX_INITIALIZER;
void game_state_initialize()
{
pthread_mutex_lock(&master_state_mutex);
int row, column;
for (row = 0; row < 6; ++row)
{
for (column = 0; column < 7; ++column)
... | 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, offset;
double mysum;
offset = (int) arg;
start = offset * dotstr.veclen;
end = start + dotstr.... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condc, condp;
int buffer[100000000] = {-2};
int buffercount = 0;
int sum = 0;
int count = 0;
FILE *inputfile = 0;
void* consumer(void *ptr)
{
ptr = ptr;
int localbuffer = 0;
while(buffer[0] != -1)
{
pthread_cond_wait(&condc,&mutex... | 1 |
#include <pthread.h>
float foo(float x) {
return x*x + 2*x + 3;
}
float sum;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *function(void *argv) {
float a = ((float*)argv)[0];
float b = ((float*)argv)[1];
float h = (b-a)*4/1000000;
float tmp = 0.0;
int i;
for(i = 0; i... | 0 |
#include <pthread.h>
char* network = "192.168.250.";
pthread_mutex_t bloqueo;
int status=0;
int total=0;
int ping(char *ipaddr) {
char *command = 0;
char buffer[1024];
FILE *fp;
int stat = 0;
asprintf (&command, "%s %s -c 1", "ping", ipaddr);
printf("%s\\n", command);
fp = popen... | 1 |
#include <pthread.h>
buffer_item *buffer;
int rear=0;
int front=0;
pthread_mutex_t mutex;
sem_t empty;
sem_t full;
pthread_mutex_t m1,m2;
int cnt, ack;
int error_semWait;
int error_mutexLock;
int error_mutexUnlock;
int error_semPost;
int insert_item(buffer_item *item){
error_semWait=sem_w... | 0 |
#include <pthread.h>
extern pthread_mutex_t __sfp_mutex;
extern pthread_cond_t __sfp_cond;
extern int __sfp_state;
FILE *fdopen(int fd, const char *mode)
{
register FILE *fp;
int flags, oflags, fdflags, tmp;
if ((flags = __sflags(mode, &oflags)) == 0)
return (0);
if ((fdflags = fcntl(fd,... | 1 |
#include <pthread.h>
semaphore mutex=1;
semaphore empty=100;
semaphore full=0;
void producer(void){
int item;
while(true){
item=produce_item;
down(&empty);
down(&mutex);
insert_item(item);
up(&mutex);
up(&full);
}
}
void consumer(void){
int item;
wh... | 0 |
#include <pthread.h>
pthread_mutex_t thread_mutex;
int id = 0 ;
void send(){
int dev_id = -1;
pthread_mutex_lock(&thread_mutex);
dev_id = id;
++id;
pthread_mutex_unlock(&thread_mutex);
struct timespec starttime;
struct timespec endtime;
char *data_buffer = fifty_char_msg;
int dataLen... | 1 |
#include <pthread.h>
const int image_width = 512;
const int image_height = 512;
const int image_size = 512*512;
const int color_depth = 255;
int n_threads;
unsigned char* image;
unsigned char* output_image;
int* histogram;
float *transfer_function;
int counter = 0;
pthread_mutex_t barrier_mutex... | 0 |
#include <pthread.h>
pthread_mutex_t x;
pthread_mutex_t wsem;
FILE *fp;
int readcount=0;
char str[20];
char txt;
void *writer(void *thread)
{
int t=*(int *)thread;
pthread_mutex_lock(&wsem);
printf("\\nEnter the name of file to open\\n");
scanf("%s",str);
fp=fopen(str,"a");
printf("Enter ... | 1 |
#include <pthread.h>
{
char ip[100];
int port;
char name[64];
int age ;
int numId;
}ThreadInfo;
int g_num = 0;
int nNum, nLoop;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_routine(void* arg)
{
int i = 0;
ThreadInfo *tmp = (ThreadInfo *)arg;
pthread_mute... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int barrier_call = 0;
void barrier(void)
{
pthread_mutex_lock(&mutex);
barrier_call++;
while(barrier_call < 16){
pthread_cond_wait(&cond, &mutex);
}
pt... | 1 |
#include <pthread.h>
buffer_item START_NUMBER;
buffer_item buffer[8];
pthread_mutex_t mutex;
sem_t empty;
sem_t full;
int insertPointer = 0, removePointer = 0;
int insert_item(buffer_item item);
int remove_item(buffer_item *item);
void *producer(void *param);
void *consumer(void *param);
i... | 0 |
#include <pthread.h>
pthread_mutex_t m[1];
pthread_cond_t c[1];
volatile long x, y;
void produce(long n_producers, long n_consumers, long buffer_size) {
(void)n_producers;
(void)n_consumers;
pthread_mutex_lock(m);
while (!(y - x < buffer_size)) {
pthread_cond_wait(c, m);
}
... | 1 |
#include <pthread.h>
char dictionary[] = "abcdefghijklmnoprstv";
pthread_mutex_t mutex;
struct thread_config {
char color[8];
char position[11];
int print_times;
};
void _log(char *);
void thread1_3(void *args){
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
char buff[255];
st... | 0 |
#include <pthread.h>
struct Table {
sem_t agent_sem;
sem_t pusher_sems[3];
sem_t smoker_sems[3];
bool ingredients[3];
pthread_mutex_t table_lock;
};
struct TableIngredient {
struct Table *table;
ingredient_t ing;
};
int rand_range(int min, int max)
{
return ra... | 1 |
#include <pthread.h>
pthread_mutex_t _internal_lock;
void _bb_init_internal(){
if(pthread_mutex_init(&_internal_lock, 0) != 0){
puts("Failed to initialize mutex.");
exit(1);
}
}
struct bb_QueueItem* curQueue = 0;
void _bb_run_queue(){
pthread_mutex_lock(&_interna... | 0 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
{
pthread_t thread;
int idNum;
int delay;
} threadData;
void * threadLogic(void * arg)
{
threadData d = *(threadData *)arg;
for (;;)
{
pthread_mutex_lock(&mut);
printf ("in %d critical section (delay is %d... | 1 |
#include <pthread.h>
FILE *fp1,*fp2;
int file_size;
char buf[100];
volatile char read_size=0;
volatile char buf_ready =0;
volatile char end_file =0;
pthread_mutex_t pthread_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t pthread_cond = PTHREAD_COND_INITIALIZER;
int buf_compare(cha... | 0 |
#include <pthread.h>
int shm_int;
int array[100];
int portion[4];
void* thread_sum();
pthread_mutex_t portion_lock;
pthread_mutex_t sum_lock;
main (int argc, char** argv) {
int input_value;
int index;
if(argc != 2) {
fprintf(stderr, "Error: Incorrect number of arguments.\\n");
... | 1 |
#include <pthread.h>
void * serverthread(void * parm);
pthread_mutex_t mut;
int visits = 0;
main (int argc, char *argv[])
{
struct hostent *ptrh;
struct protoent *ptrp;
struct sockaddr_in sad;
struct sockaddr_in cad;
int sd, sd2;
int port;
int alen;
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.