text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int ny,nl,n;
int flagy[10000]={0},flagl[10000]={0};
sem_t buf_limit,seml,semy;
sem_t sl;
sem_t sy;
int nwaity=0,nwaitl=0;
void *Yenter(void *ii);
void *Lenter(void *ii);
pthread_mutex_t mutex;
int main()
{
printf("Number of Yorks:");
scanf("%d",&ny);
printf("\\nNumber of L... | 1 |
#include <pthread.h>
void PL_wifi_signal_thread()
{
int goterr = 0;
char ap_addr_outcome[255];
char signal_indicator[2];
uint8_t connection_test;
uint8_t signal_level;
FILE * f;
PL_debug("PL_wifi_signal_thread: starting");
while(1)
{
signal_level = 0;
system("... | 0 |
#include <pthread.h>
const char *
getexecname(void)
{
static char execname[PATH_MAX + 1] = "";
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
char *ptr = 0;
ssize_t rc;
pthread_mutex_lock(&mtx);
if (strlen(execname) == 0) {
rc = readlink("/proc/self/exe",
execname, sizeof ... | 1 |
#include <pthread.h>
char str1[9999999];
long n = 5242880, lc, buffer_size;
struct timeval t;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
long timediff(clock_t t1, clock_t t2)
{
long elapsed;
elapsed = ((double)t2 - t1) / CLOCKS_PER_SEC * 1000000 ;
return elapsed;
}
double ge... | 0 |
#include <pthread.h>
double counter = 0;
pthread_mutex_t lock;
void* counting(void *);
int main(void) {
pthread_t tid[200];
int i=0;
if (pthread_mutex_init(&lock, 0) != 0)
{
printf("\\n mutex init failed\\n");
return 1;
}
for( i=0; i<200; i++){
pthread_create (&tid[i],... | 1 |
#include <pthread.h>
int totalSlots;
int levels;
int parkingSpaces;
int** parking;
FILE *file;
int identifierMax=0;
pthread_cond_t parkingFull = PTHREAD_COND_INITIALIZER;
pthread_cond_t leaveSpace = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutexin = PTHREAD_MUTEX_INITIALIZER;
pthread_mu... | 0 |
#include <pthread.h>
pthread_mutex_t mut0 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t inutil = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int nom_incr;
void sigint_handler(int s)
{
pthread_mutex_destroy(&mut0)... | 1 |
#include <pthread.h>
static void read_quicktime(frame, number)
unsigned char *frame[];
long number;
{
int i, j;
int r, g, b;
int y, u, v;
double cr, cg, cb, cu, cv;
char name[128];
unsigned char *yp, *up, *vp;
static unsigned char *u444, *v444, *u422, *v422;
static double coef[7][3] = {
... | 0 |
#include <pthread.h>
struct connection ** connection_tbl = 0;
struct connection *last_connection;
pthread_mutex_t mutex;
int init_connection_tbl_status = 0;
fpos_t pos;
char str_status[6][7] = {"NEW", "SEND", "RECV", "CONNECT" , "LISTEN", "FIN"};
void init_connection_tbl() {
if(!init_connectio... | 1 |
#include <pthread.h>
void pthread_huidiao(void)
{
}
void lizhi1_huidiao_init(struct pthread_huidiao_1 *p)
{
p->clocktime=0;
p->flag_appact=0;
p->funpthread_hui=pthread_huidiao;
pthread_mutex_init(&p->all,0);
p->funpthread_hui=lizhi1_huidiao_f1;
}
void lizhi1_huidiao_destroy(str... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int i = 0 ;
void* thd_handle(void* arg)
{
int *pval = (int *)arg;
int cnt = 10 ;
while(cnt > 0)
{
pthread_mutex_lock(&lock);
printf("thread %d lock\\n", *pval);
i ++ ;
pthread_mutex_unlock(&lock);
printf("thread %d unlock\\n", *p... | 1 |
#include <pthread.h>
static pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
void
lock_mutex(void)
{
pthread_mutex_lock(&mx);
}
void
unlock_mutex(void)
{
pthread_mutex_unlock(&mx);
}
void
myClear(void)
{
pthread_mutex_lock(&mx);
clear();
pthread_mutex_unlock(&mx);
}
void
myFlash(voi... | 0 |
#include <pthread.h>
void* thread_function(void* arg);
pthread_mutex_t work_mutex;
char work_area[4];
int time_to_exit = 0;
int main()
{
int res;
pthread_t a_thread;
void* thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if(res){
perror("Mutex initialization failed.\\n");
exit... | 1 |
#include <pthread.h>
int init_disk_controller(struct dctrl *dc) {
int rc;
pthread_mutex_init(&dc->dc_mutex, 0);
pthread_cond_init (&dc->dc_io_req, 0);
rc = pthread_create(&dc->dc_thread, 0, disk_controller, dc);
if (rc)
return -1;
return 0;
}
int close_disk_controller(struct dctrl *... | 0 |
#include <pthread.h>
struct timeval t0;
struct timeval t1;
static unsigned len = 2000000;
pthread_t tid[16];
pthread_mutex_t full_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t left_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t right_mutex = PTHREAD_MUTEX_INITIALIZER;
int v;
struc... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int message_available;
char** messages;
void* Send_msg(void* rank);
int main(void) {
pthread_t* thread_handles;
long thread;
long thread_count = 2;
message_available = 0;
messages = malloc(1 * sizeof(char *));
pthread_mutex_init(&mutex, 0);
thr... | 0 |
#include <pthread.h>
int nb_philo;
int nb_Grain_De_Riz = 8;
int * baguettes_prises;
int doitPrioriser;
int aPrioriser;
int * toursSansManger;
pthread_mutex_t * mutexs;
pthread_mutex_t global;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct philo
{
int identifiant;
};
int mod... | 1 |
#include <pthread.h>
pthread_t threads[2];
int rr_max_priority;
int count = 0;
pthread_mutex_t count_mutex1, count_mutex2;
pthread_cond_t count_threshold_cv1, count_threshold_cv2;
volatile unsigned long long total_cost;
volatile unsigned long long start1, end1;
volatile unsigned long long s... | 0 |
#include <pthread.h>
pthread_cond_t notFull, notEmpty;
pthread_mutex_t mutex;
int buffer[10];
int head = 0, tail = 0, size = 0;
int counter_producers = 0, counter_consumers = 0;
void* producer(void *arg) {
int product;
srand(time(0));
while (counter_producers < 50) {
pthread_mutex_lock(&mute... | 1 |
#include <pthread.h>
static int last = -1;
static int shared = 0;
static pthread_mutex_t a1;
static pthread_mutex_t a2;
static pthread_mutex_t a3;
static pthread_mutex_t a4;
static pthread_mutex_t a5;
static pthread_mutex_t a6;
static pthread_mutex_t a7;
static pthread_mutex_t a8;
static pthre... | 0 |
#include <pthread.h>
struct wait4context {
struct nodeID* node;
struct cloud_helper_context *cloud;
struct timeval *tout;
int *user_fds;
pthread_mutex_t wait_mutex;
pthread_cond_t wait_cond;
int status;
int source;
};
static void* wait4data_wrapper(void *ctx)
{
struct ... | 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>
pthread_t workers[PTHREAD_NUM];
int connPool[PTHREAD_NUM];
int workerInit()
{
printf("start\\n");
int i;
pthread_attr_t attr;
pthread_attr_init(&attr);
printf("num:%d\\n", PTHREAD_NUM);
for (i = 0; i < PTHREAD_NUM; i++)
{
int arg = i;
... | 1 |
#include <pthread.h>
static void* reader_thread(void* param) {
struct lastline* ll = (struct lastline*)param;
char buf[512];
while (1) {
if (fgets(buf, sizeof(buf), ll->file) == 0) {
pthread_mutex_lock(&ll->mutex);
ll->eof = 1;
if (ll->stopping)
free(ll);
pthread_mutex_unlock(... | 0 |
#include <pthread.h>
int count, commit;
pthread_t DPW_recv_f_t, DPW_recv_m_t[NUM_M], DPW_recv_b_t, DPW_send_b_t;
pthread_mutex_t save_mutex;
struct log_data *list;
static struct timespec DPW_DA_begin_time;
void *DPW_recv_f_task(void *arg);
void *DPW_recv_m_task(void *arg);
void *DPW_recv_b_task(... | 1 |
#include <pthread.h>
sem_t suma_total;
int total = 0;
int vect1[1000000];
int vect2[1000000];
pthread_mutex_t lock;
struct parametros_hilo{
int min;
int max;
int suma_temp;
};
void prodVect(void* parametros){
struct parametros_hilo* params = (struct parametros_hilo*) parametros... | 0 |
#include <pthread.h>
char ch;
int y;
int x;
}Char;
Char chars[20];
int end=0;
int good=0;
int loss=0;
pthread_mutex_t m;
void clrscr(){
int i,j;
for(i=0;i<LINES;i++){
for(j=0;j<COLS;j++){
if(!end) mvaddch(i,j,' ');
else return;
}
}
refresh();
}
void * thdShow(void *p){
int i;
... | 1 |
#include <pthread.h>
int v[3];
pthread_mutex_t mtx;
void* incVars(void *arg) {
int i;
for(i = 0 ; i < 5 ; ++ i) {
int x = rand();
pthread_mutex_lock(&mtx);
printf("Thread %lld generated %d\\n", (long long)pthread_self(), x);
printf("So the values are: %... | 0 |
#include <pthread.h>
pthread_mutex_t mutexes[4];
pthread_cond_t conditionVars[4];
int permits[4];
pthread_t tids[4];
int data = 0;
void * Philosopher(void * arg){
int i;
i = (int)arg;
pthread_mutex_lock(&mutexes[i%4]);
while (permits[i%4] == 0) {
pthread_cond_wait(&conditionVars... | 1 |
#include <pthread.h>
int var = 0;
int var2 = 100000;
pthread_mutex_t mutex_1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_2 = PTHREAD_MUTEX_INITIALIZER;
void* sumar();
void* restar();
int main(){
pthread_t suma;
pthread_t resta;
pthread_create(&suma,0,sumar,0);
pthread_create(&re... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_t threads[10];
static void* greeter();
static void* greeter()
{
int i;
for (i = 0; i < 15; i++) {
pthread_mutex_lock(&the_mutex);
printf("hello ");
printf("world!\\n");
pthread_mutex_unlock(&the_mutex);
}
pthread_exit(... | 1 |
#include <pthread.h>
static int iTThreads = 2;
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_loc... | 0 |
#include <pthread.h>
char w[8192][8192];
char neww[8192][8192];
int w_X, w_Y;
static int count;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int fin;
struct thd_info {
pthread_t tid;
int beg_idx;
int num_cells;
};
void init1(int X, int Y)
{
int i, j;
w_X = X, w_Y ... | 1 |
#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) {
printf("sign wait error\\n");
}
... | 0 |
#include <pthread.h>
int data[10],dosignal=0;
int nval=0,ndata=0;
bool ready;
pthread_mutex_t mutex;
pthread_cond_t cond;
void* producer()
{
for(;;)
{
pthread_mutex_lock(&mutex);
if(nval > 10)
{
printf("Buffer is full\\n");
pthread_mutex_unlock(&mute... | 1 |
#include <pthread.h>
void monitor_leave(struct cart_t* cart)
{
int i;
int j;
int signalling;
pthread_mutex_lock(&gl_monLock);
fprintf(stderr, "[Cart]\\tCart %i from direction %c leaves intersection\\n",
cart->num,
cart->dir);
signallin... | 0 |
#include <pthread.h>
int s = 0;
pthread_mutex_t mutex;
void F() {
pthread_mutex_lock(&mutex);
s++;
pthread_mutex_unlock(&mutex);
}
void G() {
pthread_mutex_lock(&mutex);
F();
pthread_mutex_unlock(&mutex);
}
void *ExecutaTarefa (void *threadid) {
int i;
int tid = (int... | 1 |
#include <pthread.h>
double balance;
pthread_mutex_t mutex;
} account;
account joint;
const char* delimiter_character_line;
const char* delimiter_character_col;
void read_balance(char *c_id) {
printf("Customer %s reads balance:%lf\\n", c_id, joint.balance);
fflush(stdout);... | 0 |
#include <pthread.h>
unsigned int gSharedValue = 100;
pthread_mutex_t gSharedMemoryLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t readPhase = PTHREAD_COND_INITIALIZER;
pthread_cond_t writePhase = PTHREAD_COND_INITIALIZER;
int waitingReaders = 0;
int activeReaders = 0;
int main(int argc, ch... | 1 |
#include <pthread.h>
volatile int nShared = 0;
pthread_mutex_t verrou;
pthread_cond_t condEmpty;
void* decr(void* ptr)
{
char* msg = (char*) ptr;
int count = 10000;
while(count>0)
{
pthread_mutex_lock(&verrou);
while(nShared<=0)
{
pthread_cond_wait(&condEmpty, &verrou);
printf("%s... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
struct timespec timeout;
int use_timeout;
void *run(void *arg) {
int retcode;
printf("in child: sleeping\\n");
sleep(2);
if (use_timeout) {
retcode = pthread_mutex_timedlock(&mutex, &timeout);
} else {
retcode = pthread_mutex_lock(&mu... | 1 |
#include <pthread.h>
pthread_mutex_t mutex, mutex2, mutex3;
time_t init_time;
int cnt, cnt2;
void espera_activa( int tiempo) {
time_t t;
t = time(0) + tiempo;
while(time(0) < t);
}
int get_the_time(){
return (time(0) - init_time);
}
void *tareaA( void * args) {
printf("%d::A::voy a... | 0 |
#include <pthread.h>
struct job {
struct job *next;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
void *initialize_job_queue()
{
job_queue = 0;
sem_init(&job_queue_count, 0, 0);
}
void *thread_function(void *arg)
{
... | 1 |
#include <pthread.h>
char buf[1024];
pthread_mutex_t g_mutex;
pthread_cond_t g_cond;
void *input_buffer(void *arg)
{
int index = 0;
while(1)
{
pthread_mutex_lock(&g_mutex);
sprintf(buf, "%d number", index);
printf("[%s][%d] >\\n", __func__, index++);
pthread_... | 0 |
#include <pthread.h>
pthread_t *tab;
int valeur = 0;
int val_thread_max = 0;
int val_thread_courant = 0;
int condition =0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *funcThread(void *arg){
pthread_mutex_lock(&mutex);
val_thread_coura... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_mutex_t lock2;
int value;
int value2;
sem_t sem;
void *functionWithCriticalSection(int* v2) {
pthread_mutex_lock(&(lock));
pthread_mutex_lock(&(lock2));
value = value2 + *v2;
value2 = value;
pthread_mutex_unlock(&(lock2));
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t notFull;
pthread_cond_t notEmpty;
int cnt;
int first, last;
int buf[1];
} buffer;
int tot = 0;
buffer buf = { .first = 0, .last = 1 -1, .cnt = 0 };
void store(int item, buffer *pb){
pb->buf[(pb->first)+(pb->cnt)%1] = i... | 1 |
#include <pthread.h>
struct dane {
int start;
int koniec;
};
struct wynik_programu {
int primes[500];
int curr_p;
pthread_mutex_t m;
}wynik;
void *f( void *i ) {
struct dane *dana = i;
int start = dana->start;
int koniec = dana->koniec;
int j, k;
for ( j = start; j < koniec; j++)... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void * thread_body(void * param) {
int i;
pthread_mutex_lock(&mutex);
pthread_cond_signal(&cond);
for (i = 0; i < 10; ++i) {
pthread_cond_wait(&cond, &mutex);
printf("Child : %d\\n", i);
pthre... | 1 |
#include <pthread.h>
pthread_mutex_t locki[32];
int inode[32];
pthread_mutex_t lockb[26];
int busy[26];
void* thread(void* arg)
{
int i = (*(int*)arg) % 32;
pthread_mutex_lock(locki + i);
if (inode[i] == 0)
{
int b = (i * 2) % 26;
while (1)
{
pthread_m... | 0 |
#include <pthread.h>
struct group {
pthread_mutex_t a;
pthread_mutex_t b;
int v;
};
struct group * g ;
void functionA();
void functionB();
void * init_fun();
pthread_mutexattr_t mutexAttribute;
pid_t get_tid ()
{
return syscall(SYS_gettid);
}
int main()
{
int rc1, rc2;
pthread_t threa... | 1 |
#include <pthread.h>
pthread_cond_t prod = PTHREAD_COND_INITIALIZER,
cons = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutexP = PTHREAD_MUTEX_INITIALIZER,
mutexC = PTHREAD_MUTEX_INITIALIZER;
int prod_pos = 0,
cons_pos = 0,
stock = 0,
dataProd = 0,
buffer... | 0 |
#include <pthread.h>
double *b;
double *a;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThr[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 value, wakeups;
Mutex *mutex;
Cond *cond;
} Semaphore;
void *check_malloc(unsigned n)
{
void *res = malloc(n);
assert(res != 0);
return res;
}
Mutex *make_mutex(void)
{
Mutex *ret = check_malloc(sizeof (Mutex));
pthread_mutex_init(ret, 0);
return ret;
}
... | 0 |
#include <pthread.h>
void *agent();
void *tobacco();
void *match();
void *paper();
pthread_mutex_t s_lock, s_agent, s_tobacco,s_paper, s_match;
void main(){
pthread_t agent_thread, paper_thread, tobacco_thread, match_thread;
int a, b, c, d;
pthread_mutex_init(&s_lock, 0);
pthread_mut... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int block;
int busy;
int inode;
pthread_mutex_t m_inode;
pthread_mutex_t m_busy;
void *allocator(){
pthread_mutex_lock(&m_inode);
if(inode == 0){
pthread_mutex_lock(&m_busy);
busy = 1;
pthread_mutex_unlock(&m_busy);
inode... | 0 |
#include <pthread.h>
void slowstop();
void slowstop()
{
SerCmdGotoEncSync(CNT_LATD, motc.declinazione, 2, 5);
SerCmdGotoEncSync(CNT_AR, motc.ascRetta, 10, 5);
SerCmdGotoEncSync(CNT_PREC, motc.precessione, 10, 5);
}
int plazero(void)
{
lock();
pSharedData->PlaMode = MODE_ZERO;
pSh... | 1 |
#include <pthread.h>
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
{
int f_count;
pthread_mutex_t f_lock;
int f_id;
struct foo *f_next;
}foo;
foo *fh[29];
foo *foo_alloc(int id)
{
foo *fp = 0;
int idx = 0;
if ((fp = (foo *)malloc(sizeof(foo))) != 0... | 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 res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if(res != 0){
perror("Mutex initialization failed");
e... | 1 |
#include <pthread.h>
void *piggy(void *arg);
void *read_thread(void *ptr);
FILE*file;
int num;
}ph;
ph _p1, _p2, _p3, _p4, _p5;
pthread_mutex_t mutex;
FILE*hw10;
int process=0;
int main(void) {
pthread_mutex_init(&mutex, 0);
FILE*file;
int end=0;
file = fopen("test.txt", "r");
file = f... | 0 |
#include <pthread.h>
{
int id;
int seed;
int meter;
}
parameters;
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
int seat[2];
void *doTA();
void *doStudent();
int main(int argc, char *argv[]){
printf("CS149 Sleeping TA from Yehia Qtaish\\n");
s... | 1 |
#include <pthread.h>
void add_oxygen_atom_to_air(void);
void * active_carbon_atoms(void *);
pthread_mutex_t lock;
int oxygen_atoms = 0;
int co2_count;
int O_inAir = 0;
void add_carbon_dioxyde(void)
{
co2_count ++;
}
void * generate_oxygen(void * dummy)
{
int i;
for(i=0; i < 1... | 0 |
#include <pthread.h>
pthread_mutex_t g_tLock = PTHREAD_MUTEX_INITIALIZER;;
pthread_mutex_t g_tLockCVar = PTHREAD_MUTEX_INITIALIZER;;
pthread_cond_t g_Cond = PTHREAD_COND_INITIALIZER;
static int g_charNumArray[7]={0,0,0,0,0,0,0};
static int g_numChars=0;
static char g_myChar=EOF;
static char g_m... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
void *thread_A (void *arg) {
int random_time;
while (1) {
srand(time(0));
random_time = rand() % 10;
printf("[%s]Sleeping for %d seconds\\n", __FUNCTION__, random_time);
sleep... | 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;
le... | 1 |
#include <pthread.h>
int *a, *b;
long sum=0;
pthread_mutex_t lock;
{
int counter;
int finished;
pthread_mutex_t block;
pthread_cond_t bcond;
} my_barrier_t;
my_barrier_t my_barrier;
void my_barrier_create(my_barrier_t* barrier,int NUM)
{
barrier->counter = NUM;
barrier->finished... | 0 |
#include <pthread.h>
int G_CHUNK_SIZE;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
large_uint G_current_start;
large_uint G_subset_count;
int G_terminated_flag;
large_uint G_steps;
void increment_step() {
pthread_mutex_lock(&mutex);
G_steps++;
pthread_mutex_unlock(&mutex);
}
struct ... | 1 |
#include <pthread.h>
pthread_mutex_t dir_mutex;
int dir_mutex_enabled = 1;
int compat_init(void)
{
if(pthread_mutex_init(&dir_mutex, 0) < 0)
return -1;
return 0;
}
void compat_lock_enable(void)
{
dir_mutex_enabled = 1;
}
void compat_lock_disable(void)
{
dir_mutex_enabled = 0;
}
void dir_... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t countMutex;
pthread_cond_t countThreshold;
void *incrementCount(void *tid)
{
int i;
long threadID = (long)tid;
while (count != 10) {
pthread_mutex_lock(&countMutex);
count++;
printf ("\\nIncrement-thread %ld: Count incr... | 1 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
if(... | 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 = (struct foo *)malloc(sizeof(struct foo));
if (fp != 0) ... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int chunk_size,nRows,nCols,padding,nThread;
int seek=0,fd;
pthread_t *t;
int thread_block;
int *MatrixA,*MatrixB,*MatrixC;
void fillMatrix(char *name)
{
FILE *fp=fopen(name,"w+");
if(fp==0)
{
perror("Error in opening file");
exit(1);
}
in... | 0 |
#include <pthread.h>
char *message = "HELLO B78! WELCOME TO THE CHAT EDGE. START CHATTING WITH YOUR FRIENDS.\\n welcome :";
pthread_mutex_t mutex;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct sockaddr_in sock_addr, sock_addr2;
int len;
int sd, fd[500], count = 0, file_d;
pthread_t tid... | 1 |
#include <pthread.h>
int counter=0;
void thread1(void *arg);
void thread2(void *arg);
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
int err = 0;
int main(int argc, char *argv[])
{
pthread_t id1,id2;
if(err = pthread_mutexattr_init(&attr) != 0){
printf("init attr failed!\\n");
exit(1);
... | 0 |
#include <pthread.h>
pthread_mutex_t table;
pthread_cond_t self;
struct resource {
int tob, mat, pap, agent;
} * res;
void putdown(int type);
void pickup(int id);
void * agent(void * args) {
int a,b=0;
printf("Agent started !\\n");
while(b <10){
a = rand()%3;
putdown(a);
sleep(1);
b... | 1 |
#include <pthread.h>
volatile int shared_counter = 0;
pthread_t people[100];
pthread_mutex_t lock;
void* returnToChair() {
pthread_mutex_lock(&lock);
for(int i=0; i<1000;i++) {
shared_counter++;
}
pthread_mutex_unlock(&lock);
return 0;
}
int main(void) {
if (... | 0 |
#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;
main(int ac, char *av[])
{
pthread_t t1, t2;
struct arg_set args1, args2;
void * count... | 1 |
#include <pthread.h>
static FILE *logger = 0;
static pthread_mutex_t lock;
static const char* logFilePath = 0;
void initializeC(const char* _logFilePath) {
if (pthread_mutex_init(&lock, 0) != 0) {
printf("%s[%d] mutex initialization failed.", __FUNCTION__, 21);
assert(0);
... | 0 |
#include <pthread.h>
struct range {
int begin;
int end;
};
int *array = 0;
int N = 0;
pthread_mutex_t queue_mutex;
pthread_cond_t queue_cond;
int completed = 0;
pthread_mutex_t completed_mutex;
bool is_completed() {
pthread_mutex_lock(&completed_mutex);
bool res = (completed == N);
... | 1 |
#include <pthread.h>
sem_t semA, semB;
int max_kapacita;
int kapacita = 0;
int pocet_kobyl;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
void * spravca(void * param)
{
while(1)
{
pthread_mutex_lock(&mut);
kapacita = max_kapacita;
printf("Spravca naplnil valov\... | 0 |
#include <pthread.h>
int thread_no;
int *data;
pthread_mutex_t *mutex;
} thread_arg_t;
void thread_func(void *arg) {
thread_arg_t *targ = (thread_arg_t *)arg;
int i, result;
for (i = 0; i < 10; i++) {
pthread_mutex_lock(targ->mutex);
result = targ->data[i] + 1;
sched_yield();
ta... | 1 |
#include <pthread.h>
pthread_mutex_t counter_lock;
pthread_cond_t counter_nonzero;
int counter = 0;
int estatus = -1;
void *decrement_counter(void *argv)
{
printf("counter decrement: %d\\n", counter);
pthread_mutex_lock(&counter_lock);
while(counter == 0)
{
pthread_cond_wait(&counter_nonze... | 0 |
#include <pthread.h>
static pthread_mutex_t baguette[3];
void error(int err, char *msg) {
fprintf(stderr,"%s a retourné %d message d'erreur : %s\\n",msg,err,strerror(errno));
exit(1);
}
void mange(int id) {
printf("Philosophe [%d] mange\\n",id);
for(int i=0;i< rand(); i++) {
}
}
... | 1 |
#include <pthread.h>
void runner(void *dir);
int carNum=0;
int car=0;
int WestC=0,EastC=0,NorthC=0,SouthC=0;
pthread_mutex_t n_mutex,
s_mutex,
w_mutex,
e_mutex,
cnter_mutex;
sem_t queueNorth,
queueSouth,
queueWest,
queueEast;
pthread_cond_t firstNorth,
firstSouth,
... | 0 |
#include <pthread.h>
pthread_mutex_t phdmutex;
pthread_cond_t condSell, condSupply;
void *fSellTickets(void *arg)
{
int *tick = (int *)arg;
int tmp;
int sum = 0;
while(1)
{
pthread_mutex_lock(&phdmutex);
while(*tick == 0)
{
pthread_cond_signal(&condSupply);
pthread_cond_w... | 1 |
#include <pthread.h>
void init(int decimation, int pixel_buffer_size) {
if (rp_Init() != RP_OK) {
perror("Red Pitaya API init failed!");
exit(1);
}
init_control(decimation);
init_tcp(pixel_buffer_size);
}
void end(){
end_control();
end_tcp();
rp_Release();
}
void routine(int16_t... | 0 |
#include <pthread.h>
pthread_mutex_t reading_room_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t num_readers_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t readers = PTHREAD_COND_INITIALIZER;
pthread_cond_t writers = PTHREAD_COND_INITIALIZER;
int num_readers = 0;
int reading_room_taken = 0;... | 1 |
#include <pthread.h>
int svalue;
sem_t sread, sthreads, sbuff;
pthread_mutex_t lock;
char* buffer[BUFFER_SIZE];
void initBuffer() {
int i;
for(i=0; i<BUFFER_SIZE; i++){
buffer[i]="empty";
}
}
void printBuffer() {
int i;
for(i=0; i<BUFFER_SIZE; i++) {
printf("i: %d, buffer[i]: %s\\n... | 0 |
#include <pthread.h>
static struct {
int portnumber;
char hostname[1020];
} q[256];
static volatile int ihead = 0;
static volatile int itail = 0;
static volatile int _ufdb_httpsq_n_queued = 0;
static pthread_mutex_t httpsq_lock = UFDB_STATIC_MUTEX_INIT;
static pthread_cond_t empty = PTHR... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t entra = PTHREAD_COND_INITIALIZER;
pthread_cond_t sale = PTHREAD_COND_INITIALIZER;
void * entra_persona(void *);
void * sale_persona(void *);
int in = 0, out = 0, count = 0, entradas = 0, salidas = 0;
int buffer... | 0 |
#include <pthread.h>
void *anti_syn_flood_check(void *I_do_not_use_this_var )
{
int n;
struct timeval begin;
int count;
gettimeofday(&begin,0);
for (n=count=0 ; n < e->max_tab_size ; n++)
if (e->msg_tab[n].c_syn_tv_sec && (begin.tv_sec - e->msg_tab[n].c_syn_tv_sec) > GARBAGE_RETE... | 1 |
#include <pthread.h>
int knockCount;
int idCount;
pthread_mutex_t gateLock;
pthread_mutex_t threadLock[50];
pthread_mutex_t idLock;
pthread_t gateThread;
pthread_t waitingThreads[50];
void knockKnock()
{
pthread_mutex_lock(&gateLock);
knockCount++;
pthread_mutex_unlock(&gateLock);
}
int g... | 0 |
#include <pthread.h>
static pthread_mutex_t m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
char *ts="[??:??:??]";
struct tm * now;
time_t nw;
pthread_mutex_lock(&m_trace);
nw = time(0);
now = localt... | 1 |
#include <pthread.h>
void generate(int n);
void Read(int n);
void *func1(void *arg);
void *func2(void *arg);
void *func3(void *arg);
void calculate();
void resultToFile();
int A[1000];
int B[20][1000];
int prefix_sum[20][1000]={0};
pthread_t tids[20][1000];
pthread_mutex_t mutex;
int n;
stru... | 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_top(void)
{
t... | 1 |
#include <pthread.h>
int buf_1=0;
int buf_2=0;
pthread_mutex_t l1;
pthread_mutex_t l2;
void *prod1()
{
int aux=0;
while(1){
pthread_mutex_lock(l1);
if(buf_1 < 6){
aux=buf_1;
buf_1=aux+1;
aux=0;
}
pthread_mutex_unlock... | 0 |
#include <pthread.h>
void *print(void *m);
struct data {
pthread_mutex_t mainlock;
pthread_mutex_t childlock;
pthread_mutex_t thirdlock;
};
int main ()
{
int rt;
pthread_t tid;
pthread_attr_t attr;
struct data d;
struct data *dPtr = &d;
rt = pthread_mutex_init(&(d.main... | 1 |
#include <pthread.h>
void matrixMultiply(void* params);
void matrixLoad(int rc, int**mat, FILE* fr1);
int matSize(char *line);
int rc;
int num_thrd;
pthread_mutex_t lock;
struct matrixMultParam{
int** matrix1;
int** matrix2;
int** solution;
int slice;
};
int main(int argc,... | 0 |
#include <pthread.h>
struct protoent *getprotobyname(const char *name)
{
char *buf = _proto_buf();
if (!buf)
return 0;
return getprotobyname_r(name, (struct protoent *) buf,
buf + sizeof(struct protoent), PROTO_BUFSIZE);
}
struct protoent *getprotobyname_r(const char *name, struct pr... | 1 |
#include <pthread.h>
void * (*process)(void *arg);
void * arg;
struct worker* next;
}CThread_worker;
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker *queue_head;
int shutdown;
pthread_t * threadid;
int max_thread_num;
int cur_queue_size;
}CThread_pool;
int ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.