text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct binary_sem * bsem_init(void)
{
struct binary_sem *bsem;
bsem = (struct binary_sem *)malloc(sizeof(struct binary_sem));
if(bsem == 0){
printf("malloc binary semaphore failed...\\n");
return 0;
}
pthread_mutex_init(&bsem->mutex, 0);
pthread_cond_init(&bsem->con... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
int num_of_cooks;
int num_of_phils;
struct queue
{
int first, last;
int thread_counter_id;
int data[];
};
voi... | 0 |
#include <pthread.h>
int GLOBAL = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* affiche(void* arg) {
int* num = (int*) arg;
int random = (int) (10*((double)rand())/ 32767);
printf("THREAD %d ; Random: %d\\n", *num, random);
pthread_mutex_lock(&mutex);
GLOBAL+=random;
pthread_m... | 1 |
#include <pthread.h>
int write_to_buffer(struct fifo_buffer* fbuf, const char* data, int data_length) {
int res = 0;
int from;
int first_part_size;
pthread_mutex_lock(&fbuf->lock);
if ( fbuf->size + data_length > MAX_FIFO_BUFFER_CAPACITY ) {
res = -1;
goto done;
}
from = (fbuf->pos ... | 0 |
#include <pthread.h>
pthread_mutex_t m[1];
pthread_cond_t c[1];
long x, y;
void produce(long z) {
pthread_mutex_lock(m);
assert(y == z);
while (x != y) {
pthread_cond_wait(c, m);
}
y++;
pthread_cond_signal(c);
pthread_mutex_unlock(m);
}
void consume(long z) {
pthread... | 1 |
#include <pthread.h>
{
char estado;
pthread_t thread;
} filosofo_t;
filosofo_t * filosofos;
{
char estado;
pthread_cond_t cond;
} garfo_t;
garfo_t * garfos;
int numFG = 0;
pthread_cond_t chairs;
int numChairs = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutexImpressao;
pthre... | 0 |
#include <pthread.h>
int thread_counter = 0;
int * test_array;
int i, length, t;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * count3s(void * arg){
int id = *((int *) arg);
id--;
int length_per_thread = length/t;
int start = id *length_per_thread;
for(i = start; i... | 1 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
};
struct s *new(int x) {
struct s *p = malloc(sizeof(struct s));
p->datum = x;
p->next = 0;
return p;
}
void list_add(struct s *node, struct s *list) {
struct s *temp = list->next;
list->next = node;
node->next = te... | 0 |
#include <pthread.h>
unsigned int seed;
int n_epochs;
long long int *in;
} pi_params_t;
pthread_mutex_t pi_update_lock;
void
pi_computer (void *t_params)
{
pi_params_t *params = (pi_params_t *) t_params;
long long unsigned int i;
double x, y, d;
long long int in = 0;... | 1 |
#include <pthread.h>
double x, y, z;
double mass;
} Particle;
double xold, yold, zold;
double fx, fy, fz;
} ParticleV;
Particle * particles;
ParticleV * pv;
static long seed = 123456789;
double global_max_f;
double dt, dt_old, dt_tmp;
unsigned npart, num_threads;
unsigned ra... | 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;
int f_id;
struct foo *f_next;
};
struct foo *foo_alloc(int id) {
struct foo *fp;
int idx;
if((fp = (struct foo *)mallo... | 1 |
#include <pthread.h>
pthread_mutex_t lock_1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_4 = PTHREAD_MUTEX_INITIALIZER;
void* thread_one(void* arg)
{
(void)arg;
pthread_mutex_lock(&loc... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
unsigned long long main_counter,counter[3]={0};
void* thread_worker(void* arg)
{
int thread_num = *(int*)arg;
free((int*)arg);
for(;;)
{
pthread_mutex_lock(&mutex);
counter[thread... | 1 |
#include <pthread.h>
int sum = 0;
float max = 9.0;
pthread_mutex_t mutex;
void* calculer(void* arg)
{
int j = (int)arg;
int alea = (int) (max * rand() / 32767);
fprintf(stdout, "Thread %i choisit %d\\n", j, alea);
pthread_mutex_lock(&mutex);
sum += alea;
pthread_mutex_unlock(&mutex)... | 0 |
#include <pthread.h>
volatile int progress;
void nsleep (long nsec)
{
struct timespec sleepTime, remainingSleepTime;
sleepTime.tv_sec = 0;
sleepTime.tv_nsec = nsec;
while (nanosleep(&sleepTime, &remainingSleepTime) != 0)
sleepTime = remainingSleepTime;
}
void *monitor (void *p)
{... | 1 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing(void *arg)
{
pthread_mutex_lock(&lock);
unsigned long i = 0;
counter += 1;
printf("\\n Job %d started\\n", counter);
for(i=0; i<(100000000);i++);
printf("\\n Job %d finished\\n",... | 0 |
#include <pthread.h>
int read_cnt = 0, write_cnt = 0;
int write_flag = 1;
pthread_mutex_t read_m, write_m, access_m;
int cnt = 4;
void *write_handler(void * arg);
void *read_handler(void* arg);
int main()
{
pthread_t read_tid, write_tid;
srand(getpid());
pthread_mutex_init(&read_m, 0)... | 1 |
#include <pthread.h>
pthread_mutex_t garfo[5];
int state[5], pratadas;
void* filosofo(void *arg) {
int i;
i=*((int*)arg);
while(1) {
printf("Filosofo %d pensando!!!\\n",i);
sleep(rand()%3);
if(state[i+1]==0 && state[(i+(5 -1))%5]==0) {
state[i]=1;
pth... | 0 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mutex;
pthread_cond_t threshold;
int number = 0, i = 0;
void *threadlock(int thread_num)
{
pthread_mutex_lock(&mutex);
if (thread_num == 2 && number == 0){
pthread_cond_wait(&threshold, &mutex);
}
pthread_mutex_unlock(&mutex);
... | 1 |
#include <pthread.h>
static pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mut2 = PTHREAD_MUTEX_INITIALIZER;
static bool last_round;
static int ntogo;
static ... | 0 |
#include <pthread.h>
int motorSteps;
const int stepMotorDelay = 800;
const int fasMotorDelay = 800;
const int delayInThread = 2000;
const int maxSteps = 4000;
void motor_steps(int steps, int direction)
{
int i;
if(direction == MOTOR_STEP_FORWARD)
{
DEBUG0("MOTOR_STEP_FORWARD");
if(step... | 1 |
#include <pthread.h>
struct queueNode {
int key;
struct queueNode *next;
};
struct queueHeader {
struct queueNode *head;
struct queueNode *tail;
pthread_mutex_t h_lock;
pthread_mutex_t t_lock;
};
void *hwthread(void *arg);
void enqueue(struct queueHeader *qh, int key);
int* dequeue(s... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int gnum = 1;
void* thread1(void* arg)
{
for(;;)
{
printf("\\nin thread 1\\n");
pthread_mutex_lock(&mutex);
sleep(1);
while(gnum < 5) {
printf("thread1:I'm block... | 1 |
#include <pthread.h>
void *filosofo (void *id);
void pegaGarfo (int, int, char *);
void devolveGarfo (int, int, char *);
void pensar(int);
void comer(int);
int comidaNaMesa ();
int numero_filosofos;
pthread_mutex_t *garfo;
pthread_t *filo;
pthread_mutex_t comidaBloqueada;
int sleep_seconds = ... | 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;
len = ... | 1 |
#include <pthread.h>
int mThread=0;
int start_main=0;
pthread_mutex_t mStartLock;
int __COUNT__ =0;
void __VERIFIER_atomic_acquire() {
pthread_mutex_lock(&mStartLock);
}
void __VERIFIER_atomic_release() {
pthread_mutex_unlock(&mStartLock);
}
void __VERIFIER_atomic_thr1(int PR_CreateThread__... | 0 |
#include <pthread.h>
void mux_2_iord(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>
pthread_t maleTID, femaleTID, makethreadTID1,makethreadTID2, makethreadTID3;
sem_t male_count, female_count, empty;
pthread_mutex_t mutex_male = PTHREAD_MUTEX_INITIALIZER, mutex_female = PTHREAD_MUTEX_INITIALIZER,
mutex_thread=PTHREAD_MUTEX_INITIALIZER;
int mcount, fcou... | 0 |
#include <pthread.h>
static int tcp_listen(char *ip, char *port);
struct thread_pool {
pthread_mutex_t mutex;
pthread_cond_t cond;
pthread_cond_t main_cond;
pthread_t tids[4];
int connfd;
int ready;
void (*process)(int s);
};
static int thread_pool_create(struct t... | 1 |
#include <pthread.h>
void error(char *msg) {
fprintf(stderr, "%s: %s\\n", msg, strerror(errno));
exit(1);
}
int beers = 2000000;
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void *drink_lots(void *a) {
int i;
pthread_mutex_lock(&beers_lock);
for (i = 0; i < 100000... | 0 |
#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 (... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t coz, can;
int comidinha = 0;
void* cozinheiro() {
while(1) {
pthread_mutex_lock(&lock);
while(comidinha != 0) {
pthread_cond_wait(&coz, &lock);
}
printf("C... | 0 |
#include <pthread.h>
int A[1000000];
int A_flag[1000000];
int n;
int num_thrd;
pthread_mutex_t k_threshold_mutex;
pthread_cond_t k_threshold_cv;
int Loaddata (int* A, int n)
{
FILE* ip;
int i,j,temp;
if ((ip=fopen("data_input","r"))==0)
{
printf(... | 1 |
#include <pthread.h>
struct fuse_worker {
struct fuse_worker *prev;
struct fuse_worker *next;
pthread_t thread_id;
size_t bufsize;
char *buf;
struct fuse_mt *mt;
};
struct fuse_mt {
pthread_mutex_t lock;
int numworker;
int numavail;
struct fuse_session *se;
struct fuse_chan *prevch;
... | 0 |
#include <pthread.h>
pthread_mutex_t wait;
short mother_finished = 0;
short check_if_full_plates(short* table_plates)
{
short full_plate = 0;
int i;
pthread_mutex_lock(&wait);
for(i = 0; i < 4; i++)
{
if(table_plates[i] == 1)
{
return 1;
}
}
pthread_mutex_unlock(&wait);
return 0;... | 1 |
#include <pthread.h>
pthread_mutex_t *chopstick;
void pickup(int me)
{
if (me == 10)
{
pthread_mutex_lock(&chopstick[((me + 1) % 5)]);
pthread_mutex_lock(&chopstick[me]);
}
else
{
pthread_mutex_lock(&chopstick[me]);
pthread_mutex_lock(&ch... | 0 |
#include <pthread.h>
static int iTThreads = 1;
static int iRThreads = 1;
static int data1Value = 0;
static int data2Value = 0;
pthread_mutex_t *data1Lock;
pthread_mutex_t *data2Lock;
void lock(pthread_mutex_t *);
void unlock(pthread_mutex_t *);
void *funcA(void *param) {
pthread_mutex_lock... | 1 |
#include <pthread.h>
pthread_t pthread_id[2];
pthread_mutex_t mutex1, mutex2;
int status;
void *f_thread_1(void *ptr){
pthread_mutex_lock(&mutex1);
printf("je suis le pthread 1 %d\\n",pthread_self());
pthread_exit(0);
}
void *f_thread_2(void *ptr){
pthread_mutex_lock(&mutex2);
sleep(3);
p... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void err_thread(int ret, char *str)
{
if (ret != 0) {
fprintf(stderr, "%s:%s\\n", str, strerror(ret));
pthread_exit(0);
}
}
void *tfn(void *arg)
{
srand(time(0));
while (1) {
pthread_mutex_lock(&mutex);
... | 1 |
#include <pthread.h>
static int fd ;
int IsBusy(void)
{
unsigned short wdata, rdata;
wdata = 0x0200;
write(fd ,&wdata,2);
wdata = 0x0200 | 0x0400;
write(fd ,&wdata,2);
read(fd,&rdata ,2);
wdata = 0x0200;
write(fd,&wdata,2);
if (rdata & 0x0080)
return 1;
return 0;
}
i... | 0 |
#include <pthread.h>
static int valueget=0;
static char nameget='P';
struct elem{
char c;
int integer;
};
struct buffer{
struct elem content[16];
int readp;
int writep;
int counter;
pthread_mutex_t bufferlocker;
pthread_cond_t bufferwait;
};
static struct buffer b... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t can_write = PTHREAD_COND_INITIALIZER;
pthread_cond_t can_read = PTHREAD_COND_INITIALIZER;
char arr[10] = {0};
int in_pos = 0;
int out_pos = 0;
void* do_it_a(void* p)
{
char c = 'a';
for(; c <= 'z'; c++)
{
... | 0 |
#include <pthread.h>
int getAleatorio(int maximo);
pthread_mutex_t sum_mutex;
int *arr_cuentas;
int *arr_cuentas_estado;
int numeroDeHilos, cantidad_tiempo_a_correr, numero_cuentas, valor_inicial;
void *calcularTransferencias(){
int cuentaA=getAleatorio(numero_cuentas);
int cuentaB=getAleat... | 1 |
#include <pthread.h>
struct node *next;
int data;
} Node;
struct node *head, *tail;
} Queue;
void initialize_queue(void);
void enqueue(int val);
int dequeue(int *extractedValue);
int isEmpty();
void printContent();
int sumOfAllElements();
void clearQueue();
static Queue *q;
pthread_m... | 0 |
#include <pthread.h>
pthread_t id[3];
int clock_t_1=0, clock_t_2=0, clock_t_3=0;
int sender = 1;
pthread_mutex_t mutex_var;
void *increment1(void *interval)
{
int *intr= (int*)interval;
while(1)
{
sleep(2);
clock_t_1 = clock_t_1 + *intr;
printf("\\nClock 1 = %d\\n",clock_t_1);
}
}... | 1 |
#include <pthread.h>
int ActivateROEReal()
{
pthread_mutex_lock(&roe.mx);
if(roe.active == FALSE)
{
}
roe.active = TRUE;
pthread_mutex_unlock(&roe.mx);
record("ROE Active\\n");
return 0;
}
int deactivateReal()
{
pthread_mutex_lock(&roe.mx);
if(roe.active == T... | 0 |
#include <pthread.h>
struct fdlist_t {
uintptr_t bt[15];
int bt_depth;
int fd;
struct fdlist_t *next;
int allocated;
} ;
pthread_mutex_t osal_debug_fdleak_mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t osal_debug_fdleak_con = PTHREAD_COND_INITIALIZER;
char osal_debug_fdleak_event;
... | 1 |
#include <pthread.h>
void *thread_function(void *);
char *trimr(char *);
void print_usage(const char *);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
unsigned long int total_lines = 0;
const char *filename;
const char *user_process;
unsigned short int max_threads = DEF_THREADS;
unsig... | 0 |
#include <pthread.h>
int global_variable_count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void* IncrementVariable(void *id)
{
int i;
int threadID = (int)id;
printf("Starting IncrementVariable(): thread %d\\n", threadID);
for (i=0; i < 5; i++) {
... | 1 |
#include <pthread.h>
struct queue
{
int *v;
int head;
int tail;
int size;
int maxsize;
pthread_mutex_t mutex;
};
struct queue *queue_create(int maxsize)
{
struct queue *q = malloc(sizeof(*q));
if (q != 0) {
q->v = malloc(sizeof(int)*(maxsize+1));
if (q->v == 0) {
free(q);
retu... | 0 |
#include <pthread.h>
void *func1 (void *arg);
void *func2 (void *arg);
void sig_handler (int signo);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int main ()
{
pthread_t tid[2];
struct sigaction act;
sigset_t newset;
bzero (&act,sizeof (... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_cond_t go;
int numWorkers;
int numArrived = 0;
void Barrier()
{
pthread_mutex_lock(&barrier);
numArrived++;
if (numArrived == numWorkers)
{
numArrived = 0;
pthread_cond_broadcast(&go);
}
else
{
pthread_cond_wait(&go, &barr... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int numthreads;
int increment;
struct parameter
{
int id;
int startInt;
};
int id;
struct node *next;
}node;
node *head;
void insert(int id){
node *ptr,*temp;
if(head == 0){
head = (node*)malloc(sizeof(nod... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t sinalAcordaBarbeiro = PTHREAD_COND_INITIALIZER;
pthread_cond_t chamaCliente = PTHREAD_COND_INITIALIZER;
int costumers=0;
int ocupado=0;
int temCadeiraVazia(){
if (costumers<5){
return 1;
}
return 0;
}... | 0 |
#include <pthread.h>
char* shm;
pthread_mutex_t* mutex;
char* attach_shm()
{
int fd = shm_open("/share_memory", O_RDWR|O_CREAT|O_EXCL, 0777);
if(fd > 0)
{
ftruncate(fd, 4096);
}
else
{
fd = shm_open("/share_memory", O_RDWR, 0777);
}
printf("fd ... | 1 |
#include <pthread.h>
int queue, max;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *
producer(void *x)
{
int rnd;
while (1) {
pthread_mutex_lock(&mutex);
while (queue == max) {
(void) printf("Queue full, producer sleeping.\\n"... | 0 |
#include <pthread.h>
struct async_list
{
void **data;
uint64_t count;
uint64_t size;
pthread_mutex_t lock;
};
struct async_list *
async_list_new (void)
{
struct async_list *l = calloc (1, sizeof (struct async_list));
if (0 == l)
return 0;
pthread_mutex_init (&l->lock, 0);
re... | 1 |
#include <pthread.h>
pthread_mutex_t pingmtx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t pongmtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t pingcv = PTHREAD_COND_INITIALIZER;
pthread_cond_t pongcv = PTHREAD_COND_INITIALIZER;
int minprio;
int maxprio;
int nrmlprio;
int specprio;
int main( int,... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
FILE *fptr;
void *reader1(void *threadid)
{
while(1)
{
pthread_mutex_lock(&lock);
int temp = *(int *)threadid;
printf("Thread no: %d ",temp);
printf("Lock accquired by reader 1\\n");
int i=0;
char ch,result[100];
ch = fgetc(fptr);
if ... | 1 |
#include <pthread.h>
struct SysThread
{
pthread_t thread;
};
struct SysMutex
{
pthread_mutex_t mutex;
};
struct SysThread *Sys_Thread_CreateThread(void (*entrypoint)(void *), void *argument)
{
struct SysThread *thread;
int r;
thread = malloc(sizeof(*thread));
if (thread)
{
r = pthrea... | 0 |
#include <pthread.h>
pthread_mutex_t marker_mutex;
int MARKER;
int maxx;
int maxy;
int color_lum_min = 220;
int color_lum_max = 255;
int color_cb_min = 0;
int color_cb_max = 255;
int color_cr_min = 0;
int color_cr_max = 255;
int blob_threshold = 2500;
static struct video_listener* helipad_lis... | 1 |
#include <pthread.h>
pthread_t thread1, thread2;
static pthread_mutex_t verrou1, verrou2;
int var1, var2, var3;
void *lire(void *nom_du_thread)
{
pthread_mutex_lock(&verrou1);
printf("lire variable 1 = %d\\n",var1);
printf("lire variable 2 = %d\\n",var2);
printf("lire variable 3 = %d\\n",... | 0 |
#include <pthread.h>
pthread_mutex_t asientos_mutex[5 * 2];
int asientos[5 * 2 * 2];
void *cliente(void *arg)
{
int id = *(int *) arg;
while (1)
{
int complejo;
int sala;
int asiento;
int pos;
printf("%d - .........\\n", id);
u... | 1 |
#include <pthread.h>
void mutex_set_tab(pthread_mutex_t *mutex, int *ptr[], int val[], int size)
{
int i;
i = 0;
pthread_mutex_lock(mutex);
while (i < size)
{
*ptr[i] = val[i];
i++;
}
pthread_mutex_unlock(mutex);
return ;
}
| 0 |
#include <pthread.h>
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t thread_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t thread_cond2 = PTHREAD_COND_INITIALIZER;
struct com_data
{
int a;
int b;
};
struct com_data mydata;
void *do_write(void *data)
{
mydata.... | 1 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
static void* _thread1(void *__u )
{
printf("1: obtaining mutex\\n");
pthread_mutex_lock(&lock);
printf("1: waiting on condition variable\\n... | 0 |
#include <pthread.h>
extern const unsigned short g_server_port;
pthread_t g_listener_thread = 0;
pthread_mutex_t g_client_handle_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *agt_listener_thread(void *params) {
struct sockaddr_in local;
struct sockaddr remote;
int sock, con, remote_len;
... | 1 |
#include <pthread.h>
int a = 0;
int b = 0;
pthread_mutex_t mutex_a;
pthread_mutex_t mutex_b;
void *another(void *arg)
{
pthread_mutex_lock(&mutex_b);
printf("in child thread, got mutex b, waiting for mutex a\\n");
sleep(5);
++b;
pthread_mutex_lock(&mutex_... | 0 |
#include <pthread.h>
char queue [5] ;
int front = 0 , rear = 0 ;
int items = 0 ;
int done = 1 ;
pthread_mutex_t mutex ;
pthread_cond_t item_available ;
pthread_cond_t space_available ;
void * p_thread() ;
void * c_thread() ;
int main(int argc, char *argv[])
{
pthread_t producer , consumer;
... | 1 |
#include <pthread.h>
int num_philosophers;
pthread_mutex_t stdout_mutex;
pthread_mutex_t random_mutex;
pthread_mutex_t *fork_mutex;
pthread_t *philosophers;
void *
xmalloc (size_t n)
{
void *p = malloc (n);
if (! p)
{
fprintf (stderr, "out of memory\\n");
exi... | 0 |
#include <pthread.h>
int x = 0;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
void *thread_func (void * arg)
{
while(1)
{
pthread_mutex_lock(&mut);
x=5;
x+=10;
printf("x is %d in thread %lu\\n",x,pthread_self());
sleep(1);
pthread_mutex_unlock(&mut);
}
}
int main()
{
pthread_... | 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) {
pt... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
int numthrds;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[2];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len, numthrds, myid;
long mythrd;
double mysum, *... | 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_th(const char *name) {
int i, len;... | 0 |
#include <pthread.h>
pthread_mutex_t g_TrackMutex;
int isMutexInit = 0;
int isLogged = 0;
void track(const char* fun_name, int fun_line, const char *format,... )
{
va_list args;
struct tm *pstTm;
FILE *pFILE = 0;;
long lClock;
char cMsg[256] = {'\\0'};
char cString[128] = {'\\0'};
if(... | 1 |
#include <pthread.h>
const char *names[5] = { "Aristotle", "Kant", "Spinoza", "Marx", "Russell" };
pthread_mutex_t forks[5];
const char *topic[5] = { "Spaghetti!", "Life", "Universe", "Everything", "Bathroom" };
void print(int y, int x, const char *fmt, ...)
{
static pthread_mutex_t scree... | 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;
int f_id;
struct foo *f_next;
};
struct foo *
foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(st... | 1 |
#include <pthread.h>
static int next_free_id = 1;
struct poll_record *head = 0;
pthread_mutex_t list_mutex;
char *lock_owner = 0;
void pr_init()
{
pthread_mutexattr_t attr;
if (pthread_mutexattr_init(&attr))
perror("ERROR => Error attempting to init mutexattr. The error was:");
if (pthr... | 0 |
#include <pthread.h>
int smoother_init(struct smoother_t *smoother) {
int rc;
smoother->pos = 0;
smoother->ready = 0;
rc = pthread_mutex_init(&(smoother->mtx), 0);
return rc;
}
void smoother_push(struct smoother_t *smoother, float timestamp, float value)
{
pthread_mutex_lock(&(smo... | 1 |
#include <pthread.h>
pthread_mutex_t sum_mutex1;
int a[1000], sum;
void initialize_array(int *a, int n) {
int i;
for (i = 1; i <= n; i++) {
a[i-1] = i;
}
}
void print_signal(int signum) {
printf("Signalll.... : signal number : %d\\n", signum);
}
void *thread_add(void *... | 0 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mut;
int number=0, i;
void *thread1()
{
printf ("thread1 : I'm thread 1\\n");
for (i = 0; i < 10; i++)
{
printf("thread1 : number = %d\\n",number);
pthread_mutex_lock(&mut);
... | 1 |
#include <pthread.h>
buffer_item buffer[5];
int insert_item(buffer_item item) {
for (int i = 0; i < 5; i++)
{
if(buffer[i] == -1){
buffer[i] = item;
printf ("producer produced %d\\n", item);
return 0;
}
}
return -1;
}
int remove_item(buffer_item *item) {
for (int i = 0; i < ... | 0 |
#include <pthread.h>
double x[100];
int tid[100 -1];
pthread_mutex_t mutex[100];
pthread_mutex_t mSwap;
pthread_barrier_t barrier;
int globalSwap = 1;
int run = 1;
void threadSwap(void* args)
{
int index = (int)(*args);
int swap = 0;
double help;
while(run)
{
swap = 0;
pthrea... | 1 |
#include <pthread.h>
int in = 0;
int out = 0;
int buff[30] = {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 < 30; i++)
printf("%d ", buff[i]);
printf("\\n");
}
void *product()
{
... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
int count = 0;
char argv_g[3][20] = {0};
void open_file(FILE **fp1, FILE **fp2)
{
*fp1 = fopen(argv_g[1], "r");
if(0 == *fp1)
{
printf("open file %s error", argv_g[1]);
exit(1);
}
*fp2 = fopen(argv_g[2], "r... | 1 |
#include <pthread.h>
struct product_cons
{
int buffer[5];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
}buffer;
void init(struct product_cons *p)
{
pthread_mutex_init(&p->lock, 0);
pthread_cond_init(&p->notempty, 0);
pthrea... | 0 |
#include <pthread.h>
static void process_function_actual(int job_type);
static int process_judege(struct Job *job);
static void debug_print_file(struct Job *current_job,char *subpath);
static void debug_write_data(char file[],char *data,int data_length);
static void *process_function(void *);
sta... | 1 |
#include <pthread.h>
int total_chars = 0;
int total_words = 0;
char *lines[8];
pthread_mutex_t lines_mutex;
bool producer_finished = 0;
char *take() {
int i;
char *ret = "";
if (*lines[0] != '\\0') {
pthread_mutex_lock(&lines_mutex);
for (i=8; i>0; --i) {
if (*lines[i-1] != '... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t cond_consumer, cond_producer;
int buffer = 0;
void* producer(void *ptr)
{
int i;
for (i = 1; i <= 10; i++)
{
pthread_mutex_lock(&the_mutex);
while(buffer != 0)
{
pthread_cond_wait(&cond_producer, &the_... | 1 |
#include <pthread.h>
struct queue {
int a;
int available;
int arr[20];
int front;
int count;
int inserted;
int deleted;
pthread_mutex_t mutex;
pthread_cond_t produce_more;
pthread_cond_t consume_more;
};
void do_some_work(int);
int done = 0;
int que... | 0 |
#include <pthread.h>
time_t start;
volatile unsigned long time_to_exe;
volatile int n_cats = 0;
volatile int n_dogs = 0;
volatile int n_birds = 0;
volatile int cats = 0, dogs = 0, birds = 0;
volatile int tot_cats = 0, tot_dogs = 0, tot_birds = 0;
struct monitor_vars{
pthread_mutex_t lock;
pthrea... | 1 |
#include <pthread.h>
pthread_mutex_t global_mutex ;
int global = 0;
void handle_signal(int param)
{
printf("received signal %d\\n", param);
pthread_mutex_lock(&global_mutex);
global ++;
pthread_mutex_unlock(&global_mutex);
}
void handle_signal_user1(int param)
{
printf(... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void *
thr_fn(void *arg)
{
int err, signo;
for(;;)
{
err = sigwait(&mask, &signo);
if (err != 0)
err_exit(err, "sigwait failed"... | 1 |
#include <pthread.h>
double ni = 0;
int numOfThreads;
int numOfReps;
double threadReps;
pthread_mutex_t mutex;
void *best(void *i) {
double id = atof(i);
double region = 1.0/ numOfThreads;
double start = id * region;
double stop = start + region;
double step = 1.0 / threa... | 0 |
#include <pthread.h>
{
unsigned char status;
char data[32];
}Block_Info;
pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;
Block_Info memory_block_arr[8];
static int initindicator = 0;
int init()
{
pthread_mutex_lock(&gmutex);
if (0 == initindicator)
{
memset(memory_block_arr, 0, 8... | 1 |
#include <pthread.h>
pthread_mutex_t chopstick[5];
void pickup(int me)
{
if ((me%5) == 0)
{
pthread_mutex_lock(&chopstick[(((me)+1)%5)]);
pthread_mutex_lock(&chopstick[me]);
}
else
{
pthread_mutex_lock(&chopstick[me]);
pthread_mutex_loc... | 0 |
#include <pthread.h>
struct buttonControl
{
pthread_mutex_t mutexPtr;
bool buttonState;
bool takePhoto;
int exitCount;
bool exitCountReached;
} buttonControl;
void *myButtonPoll(void *voidButtonControl)
{
struct buttonControl *buttonControl = voidButtonCon... | 1 |
#include <pthread.h>
void error(char *msg)
{
perror(msg);
exit(1);
}
struct file_desc
{
int sock_fd_no;
struct file_desc * next;
};
struct file_desc *top;
struct file_desc *current;
struct file_desc *fd_new;
struct file_desc *temp;
int requests=0,flag=1;
pthread_mutex_t mutex;... | 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>
pthread_mutex_t opr_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
int avail[1000];
int draw[1000];
int avail_len = 1000;
int draw_len = 0;
int lucky_num = 0;
void *init... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.