text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
void * start_job(void * args){
struct pool_args * pool_args = (struct pool_args *)args;
struct job * job;
while(1){
pthread_mutex_lock(pool_args->jobs->mutex);
while(!pool_args->jobs->head){
if(pool_args->jobs->completed_jobs ... | 1 |
#include <pthread.h>
pthread_mutex_t dict_mutex;
pthread_mutex_t log_mutex;
char* read_next_line(FILE* file) {
char* ret = 0;
size_t size = 0;
size_t len;
pthread_mutex_lock(&dict_mutex);
len = getline(&ret, &size, file);
if (len == -1) {
perror("read_next_lin... | 0 |
#include <pthread.h>
pthread_mutex_t coarse_mutex;
void* value;
int key;
volatile struct _setos_node* next;
} setos_node;
setos_node* head;
int setos_init(void)
{
if (pthread_mutex_init(&coarse_mutex, 0) != 0) {
printf("mutex init failed\\n");
}
head = (setos_node*) ma... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thrd_func(void *arg);
int main(){
pthread_t thread[3];
void *tret;
pthread_mutex_init(&mutex,0);
for(int i=0;i<3;i++){
if (pthread_create(&thread[i],0,thrd_func,(void*)(long)i)!=0) {
printf("Creat... | 0 |
#include <pthread.h>
void *fly(long droneid, int *homeRow, int *homeCol, int *targetRow, int *targetCol, int mission, int *state, int *active){
if(*targetRow > *homeRow){
increaseRow( droneid, homeRow, homeCol, targetRow, targetCol);
locate(droneid);
return;
... | 1 |
#include <pthread.h>
pthread_cond_t cond1,cond2;
{
int ticketcount;
pthread_mutex_t lock;
}NODE,*pNODE;
void* sale1(void* args)
{
pNODE p = (pNODE)args;
while(1){
pthread_mutex_lock(&p->lock);
if(p->ticketcount > 0){
printf("sale1 sell the ticket is:%d\\n",p->ticketcount);
sleep(... | 0 |
#include <pthread.h>
struct sbuf_t{
int buff[5];
int in;
int out;
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
};
struct sbuf_t shared;
void* producer(void* t){
for(int i=0;i<10;i++){
sem_wait(&shared.empty);
pthread_mutex_lock(&shared.mutex);
shared.buff[shared.in] = i+1;... | 1 |
#include <pthread.h>
static int rpn2c_current_number = 0;
static int rpn2c_current_count = 0;
pthread_mutex_t rpn2c_current_mutex;
FILE* rpn2c_outputPipeHandle;
FILE* rpn2c_inputPipeHandle;
pthread_t rpn2c_pipeReadThread = 0;
char* keyMap[] = {
" -+_()%=0",
"abcABC2",
"defDEF3",
"ghiGHI4",
... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(400)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_to... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(400)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{ ERROR:
__VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
volatile int tour = 0;
void* travail (void* _numero) {
int reste = ((_numero != 0) ? 0 : 1);
int i;
for(i=0; (i < 10); i++) {
pthread_mutex_lock(&mu... | 1 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
sem_t s1;
void *thread1(void *args)
{
while(1) {
sem_wait(&s1);
pthread_mutex_lock(&m1);
pthread_mutex_lock(&m2);
printf("thread1\\n");
pthread_... | 0 |
#include <pthread.h>
int count;
int blocksize;
double sum;
int max_val;
pthread_mutex_t lock;
void *thread_sum(void *arg)
{
int * iptr = (int *)arg;
int myid = *iptr;
int mywork;
int start, end, i;
double mysum;
printf("thread_sum: start myid=%d count=%d\\n", myid, count);
... | 1 |
#include <pthread.h>
char caract;
int freq;
}lFreq;
int fd;
int inc;
}readC;
int realtime;
lFreq freqlCresc[FREQSIZE];
lFreq oldFreqlCresc[FREQSIZE];
int verificaTop5(){
int i=0;
if(showMsg == 1)
printf("\\nVerificar de top5\\n");
for(i=FREQSIZE-1;i>FREQSIZE-5;i--){
if(oldFreq... | 0 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int num = 0;
void *thread_efun()
{
pthread_mutex_lock(&mutex);
do {
if( num%2 == 0 ) {
printf("%d ", num);
num++;
} else
pthread_mutex_unlock(&mutex);
}while... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node {
int n_number;
struct node *n_next;
} *head = 0;
static void cleanup_handler(void *arg)
{
printf("Cleanup handler of second thread./n");
... | 0 |
#include <pthread.h>
void *h_read(void *arg);
void *h_input(void *arg);
pthread_mutex_t mutex;
int count;
int list[127];
int main(void)
{
void *vp;
pthread_t t_read;
pthread_t t_input;
int server, client;
struct sockaddr_in s_adr, c_adr;
int size;
int option = 1;
if(pthread_cr... | 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;
void main()
{
pthread_t thread1, thread2;
int ret1, ret2;
ret1=pthread_create( &thread1, 0,... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock;
const int n = 9;
const int graph[][2] = {
{0, 1},
{0, 2},
{0, 3},
{1, 4},
{1, 5},
{2, 6},
{3, 7},
{5, 6},
{4, 7},
};
int *visit;
i... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void* PrintHello(void* threadid)
{
pthread_mutex_lock(&lock);
printf("%ld: Hello World!\\n", (pthread_t)threadid);
pthread_mutex_unlock(&lock);
sleep((int) (rand() % 10) + 1);
pthread_mutex_lock(&lock);
... | 0 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_mutex_t minBarrier;
pthread_mutex_t maxBarrier;
int numWorkers;
int sum;
int value;
int xIndex;
int yIndex;
} MINMAX;
MINMAX min;
MINMAX max;
double read_timer() {
static bool initialized = 0;
static struct timeval start;
... | 1 |
#include <pthread.h>
int x,b;
int space=0;
int Factors[100];
int A,P;
pthread_mutex_t region_mutex = PTHREAD_MUTEX_INITIALIZER;
void* P_NO(void* no_thread);
int main(int argc, const char * argv[])
{
A = atoi(argv[1]);
P = atoi(argv[2]);
printf("NUMBER ENTERED IN THE COMMAND LINE IS : %d \\n"... | 0 |
#include <pthread.h>
pthread_mutex_t lock_v= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_v;
pthread_mutex_t lock_ai= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_ai;
pthread_mutex_t lock_ao= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_ao;
int globalwork=TRUE;
void * th_global_wd... | 1 |
#include <pthread.h>
struct Account{
int NO;
int balance;
};
struct Transfer{
int from;
int to;
int amount;
};
struct arguments{
int arg1;
int arg2;
};
struct Account accounts[100];
struct Transfer records[100];
int cur = 0;
pthread_mutex_t lockTransfer;
pthread_mu... | 0 |
#include <pthread.h>
int pile[2];
int stack_size = -1;
pthread_mutex_t mutex_stack = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_pop = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_push = PTHREAD_COND_INITIALIZER;
void push(int car)
{
pthread_mutex_lock(&mutex_stack);
while (s... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int volatile iCount = 0;
void *increament_proc(void *arg)
{
while (1)
{
pthread_mutex_lock(&mutex);
iCount++;
pthread_mutex_unlock(&mutex);
if (iCount >= 100)
{
... | 0 |
#include <pthread.h>
extern int rs, bs;
void* quicksort(void *sqp, void* sp, int flag) {
struct sync_queue_t* queue = sqp;
struct params* local = sp;
struct params *leftp, *rightp;
if (local->size > 1) {
if ((bs != 0) && (local->size <= bs)) {
bubble(sp);
... | 1 |
#include <pthread.h>
int sum=0;
pthread_mutex_t mtx;
struct csf
{
char* file;
char* word;
};
int VerifyFile(const char* fName)
{
FILE *file;
if((file = fopen(fName,"r")))
{
fclose(file);
return 1;
}
return 0;
}
void* MyThread(void* p)
{
struct csf* ceva;
int number;
char com... | 0 |
#include <pthread.h>
struct mthca_ah_page {
struct mthca_ah_page *prev, *next;
struct mthca_buf buf;
struct ibv_mr *mr;
int use_cnt;
unsigned free[0];
};
static struct mthca_ah_page *__add_page(struct mthca_pd *pd, int page_size, int per_page)
{
struct mthca_ah_page *page;
int i;
page ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
pthread_mutex_t mutex3;
void * thread_body(void * param) {
int i;
pthread_mutex_lock(&mutex2);
for (i = 0; i < 10; ++i) {
pthread_mutex_lock(&mutex3);
pthread_mutex_unlock(&mutex2);
pthread_m... | 0 |
#include <pthread.h>
struct student{
int id;
int numQuestions;
int questionNum;
struct student *next;
};
unsigned int condition, condition2;
unsigned int answeredQs;
unsigned int numStud;
unsigned int snack;
pthread_cond_t student, prof;
pthread_mutex_t lock, lock_t, lock_t2, lock_t3,lock_t4... | 1 |
#include <pthread.h>
void *processActivity(void *arg);
int counter;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int connFd;
int sockFd;
} fdStruct;
int main() {
pthread_t processThread;
struct sockaddr_in servAddr;
struct fdStruct myFdStruct;
memset(&servAdd... | 0 |
#include <pthread.h>
{
void (*func)(void *);
void *data;
} thread_gate_t;
static void *thread_gate_start_cb (void *aptr);
static thread_gate_t *thread_gate_create (void (*func)(void *), void *data);
static void thread_gate_delete (thread_gate_t *self);
pthread_t hybris_thread_start (... | 1 |
#include <pthread.h>
int mutex_number = 0;
void *thr_fn1(void *arg)
{
pthread_mutex_t *lock;
lock = (pthread_mutex_t*)arg;
pthread_mutex_lock(lock);
printf("pthread 1 get the lock\\n");
mutex_number ++;
sleep(10);
printf("pthread 1 unlock the lock\\n");
pthread_mutex_unlock(lock);
pthr... | 0 |
#include <pthread.h>
pthread_mutex_t write_data;
pthread_cond_t cv;
char message[128];
bool ready;
void gps_request(int client_sock);
int gps_request_init(){
pthread_t thread1;
pthread_mutex_init(&write_data, 0);
pthread_cond_init (&cv, 0);
int sock;
struct sockaddr_in serve... | 1 |
#include <pthread.h>
static pthread_mutex_t ast_mutex = PTHREAD_MUTEX_INITIALIZER;
void LockAsts(){
pthread_mutex_lock(&ast_mutex);
}
void UnlockAsts(){
pthread_mutex_unlock(&ast_mutex);
}
| 0 |
#include <pthread.h>
int **array;
size_t row = 1024, col = 1024;
size_t size = 0;
int counter = 0;
pthread_mutex_t mutexcounter;
double elapse(struct timeb *before, struct timeb *after) {
double t;
t = (after->time * 1000 + after->millitm)
- (before->time * 1000 + be... | 1 |
#include <pthread.h>
int is_jpeg_request(struct http_url_t *url)
{
char *ext = extension(url->path);
if (ext == 0)
return 0;
char *ext_lower = strdup(ext);
if (ext_lower == 0) {
fprintf(stderr, "Insufficient memory\\n");
exit(1);
}
tolower_str(ext, ext_lower);
int ret_val =... | 0 |
#include <pthread.h>
pthread_mutex_t lock_flag;
int flag = 1;
void *handlerA(void *arg)
{
int count = 0;
while(1)
{
if(count >=10)
{
break;
}
pthread_mutex_lock(&lock_flag);
if(flag == 1)
{
printf("A");
flag = 2;
count++;
}
pthread_mutex_unlock(&lock_flag);
}
retur... | 1 |
#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);
number++;
... | 0 |
#include <pthread.h>
int value;
pthread_mutex_t mutex;
}ResourceA;
int value;
pthread_mutex_t mutex;
}ResourceB;
ResourceA *ra;
ResourceB *rb;
}Storage;
void *a_fn(void *arg) {
Storage *s = (Storage *)arg;
pthread_mutex_lock(&s->ra->mutex);
sleep(1);
printf("0x%lx is wait for Resource... | 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)];
int shared_rd[(32768)];
int shared_rdwr[(32768)];
int num_threads;
static void* thread(void *num)
{
int l = (in... | 0 |
#include <pthread.h>
pthread_t *tRobots;
pthread_mutex_t *nivelMtxs;
pthread_cond_t *nivelConds;
void * robotCtrl(void*);
int pesoRobot[5];
int pesoPisos[5];
int pesoTotal[5];
int main(void)
{
tRobots = (pthread_t*)malloc(5 * 2 * sizeof(pthread_t));
nivelMtxs = (pthread_mutex_t*)mal... | 1 |
#include <pthread.h>
int global_PULSE[4] = {1000,1000,1000,1000};
int order[4] = {0,1,2,3};
int buffer[4] = {0,0,0,0};
int buffer2[4] = {0,0,0,0};
int difference[4] = {0,0,0,0};
int PIN[4]= {7,0,2,3};
pthread_mutex_t lock;
void setup()
{
wiringPiSetup ();
int PULSE = 1000;
pinMode (PIN[0],OU... | 0 |
#include <pthread.h>
struct file{
char serv_name[256];
int port;
char *f_name;
int req_per_con;
pthread_t f_tid;
int index;
} file[1];
float *t_arr;
pthread_mutex_t arr_mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_runner(void*);
int main(int argc, char* argv[]) {
if(argc < 6){ pe... | 1 |
#include <pthread.h>
pthread_t threads[2];
{
pthread_mutex_t mutex;
int sondaggi[4][2];
float avg[4];
int n;
} Gestore;
Gestore g;
void * persona_thread(void * t)
{
int tid = (int) t;
pthread_mutex_lock(&g.mutex);
for(int i=0; i < 4; i++)
{
g.n++;... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int var;
} data_t;
data_t g_data;
void * writing_process(void * arg){
pthread_mutex_lock(&g_data.mutex);
g_data.var=5;
printf("write var before sending signal: %d\\n", g_data.var);
sleep(2);
pthread_c... | 1 |
#include <pthread.h>
void do_something(int *);
void do_something_else(int *);
void do_wrap_up(int, int);
int r1 = 0, r2 = 0;
int r3;
pthread_mutex_t r3_mutex = PTHREAD_MUTEX_INITIALIZER;
int rtn;
int main(int argc, char ** argv){
pthread_t thread1, thread2;
if (argc < 2){
perro... | 0 |
#include <pthread.h>
int fd;
int left, middle, right;
int x, y;
void mouse_connect()
{
const char *pDevice = "/dev/input/mice";
fd = open(pDevice, O_RDWR);
int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
if(fd == -1)
{
printf("ERROR Ope... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer[5];
int in = 0, out = 0;
void *producer(void *ptr) {
int i;
for (i = 0; i < 10; i++) {
pthread_mutex_lock(&the_mutex);
while (((in + 1) % 5) == out)
pthread_cond_wait(&... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0) {
fprintf(stderr, "sigwait failed:... | 1 |
#include <pthread.h>
void *MyThread(void *);
pthread_mutex_t mutex;
main()
{
pthread_t idA, idB;
if (pthread_mutex_init(&mutex, 0) < 0) {
perror("pthread_mutex_init");
exit(1);
}
if (pthread_create(&idA, 0, MyThread, (void *)"A") != 0) {
perror("pthread_c... | 0 |
#include <pthread.h>
int main()
{
char *shm1="myshm";
char *shm2="youshm";
int shm_id_1,shm_id_2;
char *buf;
pid_t pid;
pthread_mutex_t *mutex;
pthread_mutexattr_t mutexattr;
shm_id_2=shm_open(shm2,O_RDWR|O_CREAT,0644);
ftruncate(shm_id_2,100);
mutex=(pthread_mutex_t*)mmap(0,100,... | 1 |
#include <pthread.h>
int log_to_stderr = 1;
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... | 0 |
#include <pthread.h>
void atomic_array_init(struct atomic_array *aa) {
pthread_mutex_init(&aa->mutex, 0);
}
int atomic_array_get(struct atomic_array *aa, int id) {
int res;
pthread_mutex_lock(&aa->mutex);
res = aa->arr[id];
pthread_mutex_unlock(&aa->mutex);
return res;
}
void atomic_array... | 1 |
#include <pthread.h>
int n_gen = 10;
struct coll_msg_t {
char msg[100][255];
int w_index;
int r_index;
int items;
pthread_mutex_t m_index;
};
pthread_cond_t signal_collector;
struct coll_msg_t mqueues[10];
static inline int msgq_is_empty(const struct coll_msg_t *mq)
{
retu... | 0 |
#include <pthread.h>
void health_init ( void ) {
pthread_mutex_init( &health.mutex, 0 );
return;
}
void health_exit ( void ) {
pthread_mutex_destroy( &health.mutex );
return;
}
void health_update ( void ) {
long double a[4], b[4], num, den, cpu;
FILE *fp;
fp = fopen( "/proc/stat", "... | 1 |
#include <pthread.h>
void get_thread_id(char *buff, int size)
{
int ret = 1;
pthread_t self;
self = pthread_self();
if (ret || !buff[0])
ret = snprintf(buff, size, "%04X", (unsigned) self);
}
FILE *flog;
int accum_log_file = 0;
int log_flush = 1;
static int log_level = SSA_LOG_DEFAU... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
struct foo *
foo_alloc(int id)
{
struct foo *fp;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
fp->f_id = id;
if (pthread_mutex_init(&fp->f_lock, 0) !=... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cua_cons, cua_prod;
int buffer;
int buit;
int numIters;
void *productor(void *arg)
{
int i;
for(i = 1; i <= numIters; i++) {
pthread_mutex_lock(&mutex);
if (!buit)
pthread_cond_wait(&cua_prod, &mutex);
printf("Produ... | 0 |
#include <pthread.h>
pthread_mutex_t verrou = PTHREAD_MUTEX_INITIALIZER;
struct matricule
{
int chiffre[3];
char lettre[3];
int chiffreFix[2];
};
void * monMatricule(void *par)
{
pthread_t moi = pthread_self();
printf("thread : %u, proc : %d \\n", moi, getpid());
pthread_mutex_lock(&verr... | 1 |
#include <pthread.h>
struct arp_packet
{
u_char targ_hw_addr[6];
u_char src_hw_addr[6];
u_short frame_type;
u_short hw_type;
u_short prot_type;
u_char hw_addr_size;
u_char prot_addr_size;
u_short op;
u_char sndr_hw_addr[6];
u_char sndr_ip_addr[4];
u_char... | 0 |
#include <pthread.h>
void init_matrix (int **matrix, int fils, int cols) {
int i, j;
for (i = 0; i < fils; i++) {
for (j = 0; j < cols; j++) {
matrix[i][j] = 1;
}
}
}
int **matrix1;
int **matrix2;
int **matrixR;
int matrix1_fils;
int matrix1_cols;
int matrix2_fils;
int matrix2_cols;
... | 1 |
#include <pthread.h>
{
char buf[3];
int occupied;
int nextin, nextout;
pthread_mutex_t mutex;
pthread_cond_t more;
pthread_cond_t less;
} buffer_t;
buffer_t buffer;
int done = 0;
int sleep_time;
void * producerFunction(void *);
void * consumerFunction(void *);
pthread_t producerThread... | 0 |
#include <pthread.h>
static pthread_mutex_t testlock;
pthread_t test_thread;
void *test()
{
pthread_mutex_lock(&testlock);
printf("thread Test() \\n");
pthread_mutex_unlock(&testlock);
}
int main()
{
pthread_mutex_init(&testlock, 0);
pthread_mutex_lock(&testlock);
printf("Main lock \\n");
pthr... | 1 |
#include <pthread.h>
pthread_mutex_t request_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_cond_t got_job_request = PTHREAD_COND_INITIALIZER;
int num_requests = 0;
int done_creating_jobRequests = 0;
struct arg_structure
{
int arg1;
int arg2;
};
struct Job
{
int... | 0 |
#include <pthread.h>
struct node{
int data;
struct node *next;
}*start=0;
struct node *tmp_node;
struct node *prev;
int rs,count=0;
struct node *current;
struct node *lct;
void * dis(void *);
void * del(void *);
pthread_mutex_t lc;
pthread_t tid[2];
int bignum = 0;
int turn;
void create()
{
... | 1 |
#include <pthread.h>
void usage(char *prog) {
fprintf(stderr, "usage: %s [-v] [-n num]\\n", prog);
exit(-1);
}
int verbose;
int nthread=2;
char *dir="/tmp";
char *file;
struct work_t *next;
} work_t;
work_t *head,*tail;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t con... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_task_H,mutex_task_O;
pthread_cond_t task_O,task_H,next_task_O,next_task_H;
long n,m;
int notask=0;
int H=0,O=0,H2O=0;
void* create_molec_H(void* rank){
long my_rank = (long) rank;
pthread_mutex_lock(&mutex_task_H);
H++;
pthread_mutex_unlock(&mutex_... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_t... | 0 |
#include <pthread.h>
void show_alloc_mem(void)
{
pthread_mutex_lock(mutex_sglton());
print_mem(FALSE);
pthread_mutex_unlock(mutex_sglton());
}
void show_freed_mem(void)
{
pthread_mutex_lock(mutex_sglton());
ft_putstr("Memory freed:\\n");
print_mem(TRUE);
pthread_mutex_unlock(mutex_sglton()... | 1 |
#include <pthread.h>
static void *self;
static int uim_fd;
static char *prop;
static pthread_t twatch;
static pthread_mutex_t mutex;
static void *uimwatch(void *);
static ssize_t xwrite(int fd, const char *buf, size_t size);
const char*
load(const char* dsopath)
{
struct sockaddr_un server;
... | 0 |
#include <pthread.h>
unsigned int TEST_VALUE_D[3][3] = {
{REG_INTERRUPT_MASK_0, 0x555555, FALSE},
{REG_INTERRUPT_MASK_1, 0x123456, FALSE},
{REG_USB, 0xFF7777, FALSE}
};
int VT_mc13783_D_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783_D_cleanup(void) {
... | 1 |
#include <pthread.h>
int r;
pthread_t t;
int thread_status[32];
int thread_stop[32];
int thread_time[32];
int thread_time_max[32];
int print_rt_stat() {
int i;
for(i = 0; i < 5; i++) {
printf("rt_thread_status [%d] = %d",i,thread_status[i]);
printf("\\033[1E");
}
r... | 0 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
... | 1 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t conda = PTHREAD_COND_INITIALIZER;
pthread_cond_t condb = PTHREAD_COND_INITIALIZER;
pthread_cond_t condc = PTHREAD_COND_INITIALIZER;
char * msg = "A";
void * printA(void * arg){
int i;
for(i = 0 ; i < 10 ... | 0 |
#include <pthread.h>
int n = 0;
pthread_mutex_t myLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qReady = PTHREAD_COND_INITIALIZER;
void * threadFunc(void *);
int main(int argc, const char *argv[])
{
int err = 0;
pthread_t tid[3];
void *tret;
for (int i = 0; i < 3; ++i) {
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1;
pthread_cond_t mutex1c;
Bool cont = FALSE;
unsigned int score1 = 0;
unsigned int score2 = 0;
void battleship(void *battleshiparg);
pthread_mutex_t mutex2;
pthread_cond_t mutex2c;
Bool MainThreadWaiting = FALSE;
void *simulation(void *simulationx){
... | 0 |
#include <pthread.h>
static char running = 1;
static long long counter = 0;
pthread_mutex_t c_mutex;
int i;
void *process (void *arg)
{
while (running) {
pthread_mutex_lock (&c_mutex);
if (i > 4)
pthread_exit (0);
counter++;
pthread_mutex_unlock... | 1 |
#include <pthread.h>
pthread_mutex_t Mutex;
pthread_mutexattr_t MutexAttr;
pthread_cond_t Cond = PTHREAD_COND_INITIALIZER;
int Resource = 10;
void *producer(void *arg)
{
int id = *(int *)arg;
while (1)
{
pthread_mutex_lock(&Mutex);
while (Resource > 0)
{
printf("p%d: wait\... | 0 |
#include <pthread.h>
int buffer = 5;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *Productor(void *threadid)
{
printf("Productor\\n");
while (1){
sleep(5);
if (buffer == 10){
}else{
printf("Produciendo...\\t");
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int test_cond = 1;
void* producerFun1(void *arg)
{
pthread_mutex_t mutex1;
pthread_mutex_init(&mutex1,0);
printf("func:%s arg:%d\\n", __func__ , (*(int*)arg));
while(1)
{
pthread_mutex_lock(&mutex1);
if(test_cond == 1)
... | 0 |
#include <pthread.h>
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 = 1;
}
block = 1;
if (!(blo... | 1 |
#include <pthread.h>
struct _node *next;
unsigned int size;
bool inuse;
} Node;
unsigned int amtfree;
Node *head = 0;
Node *tail = 0;
pthread_mutex_t lock;
void setbit(int* number, int pos){
*number |= 1 << pos;
}
void clearbit(int* number, int pos){
*number &= ~(1 << pos);
}
int checkbi... | 0 |
#include <pthread.h>
int key;
struct __node_t *next;
} node_t;
node_t *head;
pthread_mutex_t lock;
} list_t;
void List_Init(list_t *L) {
L->head = 0;
pthread_mutex_init(&(L->lock), 0);
}
int List_Insert(list_t *L, int key) {
node_t *new = malloc(sizeof(node_t));
... | 1 |
#include <pthread.h>
char g_s[10] = "hello";
pthread_mutex_t mtx ;
extern pid_t gettid() {
return syscall(SYS_gettid);
}
void *ThreadFun(void *arg) {
int i, n;
n = *(int *)arg;
pthread_detach(pthread_self());
printf("thread(%d) %d try to lock...\\n", gettid(), n);
pthread_mutex_lock(&mt... | 0 |
#include <pthread.h>
int masa[4];
int counter=0;
int ivan_pos=0;
int mother_pos=0;
pthread_mutex_t lock;
void* bake(void* arg) {
while(counter<1000){
pthread_mutex_lock(&lock);
if(masa[mother_pos]==0){
masa[mother_pos] = 1;
counter+=rand()%101;
printf("Baked on : %d\\n", mothe... | 1 |
#include <pthread.h>
extern void __VERIFIER_error() ;
int __VERIFIER_nondet_int(void);
void ldv_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
pthread_t t1;
pthread_mutex_t mutex;
int pdev;
void *thread1(void *arg) {
pthread_mutex_lock(&mutex);
pdev = 6;... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
static struct foo *g_fp = 0;
struct foo *foo_alloc(int id) {
struct foo *fp;
if((fp = malloc(sizeof(struct foo))) != 0){
fp->f_count = 1;
fp->f_id = id;
if(pthread_mutex... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int buffer[10];
int duration = 20;
int length = 0;
void *producer(void *arg)
{
char *str;
str=(char*)arg;
for(int i = 0; i < duration; i++) {
pthread_mutex_lock(&mutex);
while(length == 10) {
... | 0 |
#include <pthread.h>
struct simplethreadpool* threadpool_init(int poolsize, int queue_max_num)
{
int i;
struct simplethreadpool* threadpool
= (struct simplethreadpool*)malloc(sizeof(struct simplethreadpool));
if(threadpool == 0)
{
printf("thread pool malloc error\\n");
return 0;
}
th... | 1 |
#include <pthread.h>
void* mutex_keeper(void* w_args)
{
struct sema_mutex_args_struct* args = (struct sema_mutex_args_struct*)w_args;
pthread_mutex_t* pmutex = args->mutex;
int* status = args->status;
pthread_barrier_t* barr = args->barr;
while(*status != -1)
{
pt... | 0 |
#include <pthread.h>
void* multiplica_matriz(void *p){
int linhas, colunas;
int i,j,aux,somaprod;
i = (int)(size_t)p;
printf("inicio da thread %d\\n", i);
linhas = matrizA->qtd_linhas;
colunas = matrizA->qtd_colunas;
pthread_mutex_lock(&mutex);
for(j=0;j<colunas;++j){
somaprod=0;
... | 1 |
#include <pthread.h>
pthread_cond_t Cond_Var;
pthread_cond_t Cond_Var2;
pthread_mutex_t Lock;
pthread_t Thread_Id;
} Shared_Task;
int timec;
int TaskN;
} arguments_T;
Shared_Task Shared_T;
arguments_T arguments_Task;
struct TSK Tasks;
struct timespec ts;
struct timespec nextperiod;... | 0 |
#include <pthread.h>
static int glob = 0;
static pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER;
static void *
threadFunc1(void *arg)
{
int s;
pthread_mutex_lock(&mtx1);
s=pthread_mutex_trylock(&mtx2);
if(s==0){
glob += 1;
printf... | 1 |
#include <pthread.h>
{
THINKING,
EATING,
HUNGRY,
} pStatus;
struct philospher
{
pStatus status;
semaphore sem;
};
union semun
{
int val;
struct semid_ds* buf;
unsigned short* array;
};
static struct philospher person[5];
static pthread_mutex_t mutex=PTHREAD_MUTE... | 0 |
#include <pthread.h>
int controladora = 0;
pthread_mutex_t x_mutex;
pthread_cond_t x_cond;
void *A (void *t) {
printf("1: Comecei\\n");
printf("Tudo bem?\\n");
pthread_mutex_lock(&x_mutex);
controladora++;
printf("1: controladora = %d, vai sinalizar a condicao \\n", controladora);... | 1 |
#include <pthread.h>
pthread_t phil[10];
pthread_mutex_t chopstick[10];
int n;
void* func(int i)
{
printf("Philosopher %d is thinking\\n",i+1);
pthread_mutex_lock(&chopstick[i]);
pthread_mutex_lock(&chopstick[i+1]);
printf("Philosopher %d is eating\\n",i+1);
sleep(2);
pthread_mutex_unlock(&chops... | 0 |
#include <pthread.h>
pthread_mutex_t insert_mutex;
pthread_mutex_t pause_searches;
pthread_mutex_t searches;
int MAX_SEARCHES = 10;
int MAX_INSERT = 5;
int MAX_DELETE = 2;
int max_value = 20;
struct node{
int value;
struct node* next;
};
int num_searches = 0;
int pause = 0;
struct node * head... | 1 |
#include <pthread.h>
struct header
{
int size;
int is_free;
struct header *next;
};
struct header *head = 0, *tail = 0;
pthread_mutex_t global_malloc_lock;
int countt,bsize,pos;
char* line;
struct header *get_free_block(int size)
{
struct header *curr = head;
while(curr)
{
if(curr->is_... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.