text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int gnum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread1(void *);
void *thread2(void *);
int main(void)
{
pthread_t t1;
pthread_t t2;
pthread_create(&t1, 0, thread1, (void *)0);
pthread_create(&t2... | 1 |
#include <pthread.h>
pthread_mutex_t mulo = PTHREAD_MUTEX_INITIALIZER;
int total;
int portNumber;
int ServerSocket;
struct sockaddr_in ServerStructure, ClientStructure;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
void *socket_connection(void *passedvalue);
int main(int argc, char *argv[])... | 0 |
#include <pthread.h>
static lp_pthread_mutex_func next_pthread_mutex_lock = 0;
static lp_pthread_mutex_func next_pthread_mutex_trylock = 0;
static lp_pthread_mutex_func next_pthread_mutex_unlock = 0;
static int
lp_hookfunc(lp_pthread_mutex_func *fptr, const char *fname)
{
char *msg = 0;
... | 1 |
#include <pthread.h>
static pthread_mutex_t nightWiringMutexes[4];
int nightWiringThreadCreate (void *(*fn)(void *))
{
pthread_t myThread;
return pthread_create (&myThread, 0, fn, 0);
}
void nightWiringLock (int key)
{
pthread_mutex_lock (&nightWiringMutexes[key]);
}
void nightWiringU... | 0 |
#include <pthread.h>
static void waitForMessage(struct DibDriverDebugInstance *i, int id)
{
i->Platform.expectedId = id;
pthread_cond_wait(&i->Platform.msgResponseCondition, &i->Platform.msgBufferLock);
}
static int regAccess(struct DibDriverDebugInstance *i, uint32_t address, uint32_t... | 1 |
#include <pthread.h>
int x = 0;
pthread_mutex_t x_mutex;
pthread_cond_t x_cond;
void *A (void *t) {
int boba1, boba2;
printf("A: Comecei\\n");
boba1=10000; boba2=-10000; while (boba2 < boba1) boba2++;
printf("HELLO\\n");
pthread_mutex_lock(&x_mutex);
x++;
if (x==2) {... | 0 |
#include <pthread.h>
int val;
pthread_mutex_t mutex;
pthread_cond_t cond;
}semaphore;
void sem_init(semaphore *Initial, int value)
{
Initial->val = value;
}
void sem_post(semaphore *sem)
{
pthread_mutex_lock(&(sem->mutex));
s->val++;
pthread_cond_signal(&(sem->cond));
pthread_mu... | 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>
int MYTHREADS = 10;
int count = 0;
int n = 10000;
int xArray[10][10000];
int yArray[10][10000];
int a = 5;
int b = 12;
int yMax = 12 * 12;
int recArea = (12 * 12) * (12 - 5);
float threadArray[10];
struct params {
pthread_mutex_t mutex;
pthread_cond_t done;
int id;
};
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_count=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_mutex1= PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_mutex2= PTHREAD_COND_INITIALIZER;
int count = 0;
void * thread1(void *ptr){
printf("This is thread 1\\n");
while(1){
pthread_mutex_lock(&mut... | 0 |
#include <pthread.h>
int val_thread_max;
int val_inside_barrier=0;
int condition = 0;
int *args;
pthread_t *tabThread;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void wait_barrier(int arg){
pthread_mutex_lock(&mutex);
val_inside_barrier+... | 1 |
#include <pthread.h>
int asc_code;
int ocorrencias;
}Caracter;
long posicao_global = 0;
long buffleng;
char *buffer;
Caracter *lista_asc;
pthread_mutex_t mutex;
Caracter* preenche_asc(){
int i;
Caracter *vetor = (Caracter*) malloc(96*sizeof(Caracter));
for(i = 0; i < 96; i++)... | 0 |
#include <pthread.h>
void* handle_client(void*);
struct sockaddr_in server;
unsigned long long n=0;
char message[45] = "GET / HTTP/1.1\\r\\nHost: 127.0.0.1\\r\\n\\r\\n";
pthread_mutex_t mutex1,mutex2;
int pool_num=-1;
int conn_pool[100];
int main(int argc , char *argv[])
{
unsigned long lon... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t blanks;
sem_t datas;
int ringBuf[30];
void *productRun(void *arg)
{
int i = 0;
while(1)
{
sem_wait(&blanks);
int data = rand()%1234;
ringBuf[i++] = data;
i %= 30;
printf("product is done... data... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex;
static pthread_cond_t cond;
static unsigned int count = 0;
void *thread1(void *dummy);
void *thread2(void *dummy);
int main (void)
{
int i, rtn;
pthread_t th1, th2;
int err;
struct timespec req, res;
req.tv_sec = 10;
req.tv_nse... | 1 |
#include <pthread.h>
static struct Entries rds[3];
pthread_mutex_t *rds_mutex;
void * RdsMain(void *args)
{
int retval, i;
time_t current;
struct timespec sleep, wait;
sleep.tv_sec = 0;
sleep.tv_nsec = 0x1dcd6500;
while (1) {
time(¤t);
retval = pthread_mutex_lock (rd... | 0 |
#include <pthread.h>
void sig_catch(int sig);
void barber(void *);
void customer(void *);
void get_hair_cut(void);
void cut_hair(void);
void line_pop(void);
void line_push(void);
struct chair {
struct chair *next;
};
struct line {
int number_of_customers;
int chairs;
stru... | 1 |
#include <pthread.h>
pthread_mutex_t fMutex;
int fCounter;
int fLoops;
char fType;
} Shared;
void *
MutexPerformanceProc(void *arg)
{
Shared * shared = (Shared *)arg;
int i;
if (shared->fType == 'm') {
for (i = 0; i < shared->fLoops; i++) {
pthread_mutex_lock(&shared->fMutex);
... | 0 |
#include <pthread.h>
int randomGaussian_r(int mean, int stddev, unsigned int* state);
void* philoFunc(void* p);
void eat(int sec, int ph);
void think(int sec, int ph);
int leftChop(int ph);
int rightChop(int ph);
int chopArray[5], eatArr[5], thinkArr[5];
pthread_mutex_t mutex;
int ph[5];
in... | 1 |
#include <pthread.h>
pthread_t thread[3];
pthread_mutex_t mut;
int number=0, i;
char buf[1024]={0},str[7]={0};
sem_t sem;
void *thread1()
{
printf ("thread1 : I'm thread 1\\n");
while(1)
{
pthread_mutex_lock(&mut);
if(number<10){
number++;
}
else
break;
pthread_mut... | 0 |
#include <pthread.h>
static const unsigned int kBaseIDNumber = 101;
static const unsigned int kNumAgents = 10;
static const unsigned int kNumTickets = 100;
static pthread_mutex_t ticketsLock;
static unsigned int remainingTickets = kNumTickets;
static void ticketAgent(size_t id) {
while (1) {
... | 1 |
#include <pthread.h>
void *find_min(void *list_ptr);
pthread_mutex_t minimum_value_lock;
int minimum_value, partial_list_size,list_elements_size;
int j=0;
main() {
int i,k;
minimum_value = 0;
pthread_mutex_init(&minimum_value_lock, 0);
int pthread_count;
printf("Enter the values for list siz... | 0 |
#include <pthread.h>
static void link(struct Area *a, struct Berth *f, struct Berth *t) {
short oldLen = f->nextcount;
char **oldAry = f->next;
f->nextcount++;
f->next = (char **) malloc(sizeof (char *)*f->nextcount);
memcpy(f->next, oldAry, sizeof (char *)*oldLen);
f->nex... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
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(vo... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;;
int global = 0;
void* thread1(void* arg)
{
pthread_cleanup_push(pthread_mutex_unlock, &mutex);
while(1)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread1's gloabl is %d\\n",++global);... | 1 |
#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");... | 0 |
#include <pthread.h>
char char_buffer[67108864];
int ascii_num[128];
pthread_mutex_t lock;
int thread_id;
int partition_bounds;
} thread_info;
void *ascii_counting (void* thread){
char current_char;
int t,thread_begin_location;
thread_info *td= (thread_info*) thread;
t = td->thread_id... | 1 |
#include <pthread.h>
struct thread_args {
int ident ;
pthread_mutex_t *resA ;
pthread_mutex_t *resB ;
};
void run_thread_one(thread_args_t *);
void run_thread_two(thread_args_t *);
int main(int argc, char** argv)
{
pthread_t thread_one;
pthread_t thread_two;
thread_ar... | 0 |
#include <pthread.h>
static int g_num=0;
static pthread_mutex_t g_mutex;
void *thread_handle(void *arg)
{
int i=0;
for(i=0;i<10;i++)
{
pthread_mutex_lock(&g_mutex);
printf("线程[1] brfore %d\\n",g_num);
g_num++;
sleep(1);
printf("线程[1] after %d\\n",g_num);
pthread_mutex_unlock(&g_mute... | 1 |
#include <pthread.h>
double total_sum = 0;
pthread_mutex_t lock;
struct meta_data {
int partition_size;
int total;
double *start;
int thread_id;
};
void run_test(int n, int threads);
void *partition_sum(struct meta_data *meta);
int main(void)
{
int threads[3] = {2, 4, 8};
int n[2] = {10... | 0 |
#include <pthread.h>
int joker_open(struct joker_t *joker)
{
struct libusb_context *ctx = 0;
struct libusb_device **usb_list = 0;
struct libusb_device_handle *devh = 0;
struct libusb_device_descriptor desc;
int usb_devs, i, r, ret, transferred;
unsigned char buf[JCMD_BUF_LEN];
unsigne... | 1 |
#include <pthread.h>
int n, capacity, linn = 0, sinn = 0, threadcount = 0;
pthread_mutex_t idlock;
sem_t fulllock, innlock, lock_first[2], lock_second[2];
int count_inside[2];
void lock_init()
{
sem_init(&fulllock, 0, capacity);
sem_init(&innlock, 0, 1);
pthread_mutex_init(&idlock, 0... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {... | 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);
}
int i,j;
padding... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int m;
int biggest = 100;
int n;
int rank;
int* array;
}arg_struct;
void *findGreatest(void* arg){
arg_struct *thread = (arg_struct *)arg;
int *segment = thread->array;
for(int i = 0; i < n; i++){
if(biggest < segment[i]){
p... | 1 |
#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;
... | 0 |
#include <pthread.h>
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=0;
q->amount=0;
}
int empty(QType * q)
{
if (q->he... | 1 |
#include <pthread.h>
int buffer[3];
pthread_mutex_t buff_lock;
void *p1()
{
int i;
int j = 1;
while(1) {
if(j >= 1000){
j = 1;
}
for(i=0; i< 3; i = i+1){
if(buffer[i] == 0){
pthread_mutex_lock(buff_lock);
buffer[i] = j;
pthread_mutex_unlock(buff_lock);
j = j ... | 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)
{
... | 1 |
#include <pthread.h>
void *count_frequency_function( void *ptr );
pthread_mutex_t count_frequency_mutex;
struct word_count
{
char ch[15];
int count;
};
struct track_thread
{
int thread_number;
char *message;
};
int main()
{
pthread_t mapper1, mapper2, mapper3;
char ch[] = "Hello Worl... | 0 |
#include <pthread.h>
pthread_cond_t cond_a = PTHREAD_COND_INITIALIZER;
int condition_a = 0, condition_b = 0;
pthread_cond_t cond_b = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_rwlock_t rwlock;
static void* pthread_a_work(void* args) {
sorm_c... | 1 |
#include <pthread.h>
struct foo{
int f_count;
pthread_mutex_t f_lock;
};
struct foo *foo_alloc(void){
struct foo *fp;
if((fp = malloc(sizeof(struct foo))) != 0){
fp->f_count = 1;
if(pthread_mutex_init(&fp->f_lock, 0) != 0){
free(fp);
return (0... | 0 |
#include <pthread.h>
int *is_processing_user_command;
void *runSensor(void *is_processing_user_command_ptr)
{
pinMode (0, INPUT);
pinMode (2, OUTPUT);
digitalWrite(2, LOW);
delay(30);
int distance;
printf("SENSOR: %d\\n", sensor);
while (1) {
pthread_mutex_lock(&sen... | 1 |
#include <pthread.h>
static void analysis_web_from_job(struct Job *current_job);
static void analysis_web_from_http_list(struct Http_List *list,time_t current_time,
struct tuple4 addr);
static void analysis_web_from_http(struct Http *http,time_t current_time,
struct tuple4 addr);
st... | 0 |
#include <pthread.h>
char buffer[65536];
int array[128];
pthread_mutex_t lock;
{
int thread, start, end;
} startEndPoint;
void *counting (void *ptr) {
startEndPoint *data = (startEndPoint *) ptr;
printf("Thread ID: %d, Start: %d, End: %d\\n", data->thread, data->start, data->... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void *thread1(void *arg);
void *thread2(void *arg);
int main(void)
{
pthread_t tid1,tid2;
printf("Start!\\n");
pthread_mutex_init(&mutex,0);
pthread_cond_init(&cond,0);
pthread_create(&tid1,0,thread1,0);
... | 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);
number++... | 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");
free... | 0 |
#include <pthread.h>
const long long MUL = 31;
int N;
pthread_mutex_t mutex;
const char *str;
const char *patt;
int pos = -1;
void update_pos(int p) {
pthread_mutex_lock(&mutex);
if (p < pos && p != -1 || pos == -1) {
pos = p;
}
pthread_mutex_unlock(&mutex);
}
void* r... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
int main()
{
pthread_t thread1, thread2, thread3;
int i1=1, i3=3;
pthread_create( ... | 0 |
#include <pthread.h>
static int s_finished_count;
static int s_set_thread_name;
static pthread_mutex_t s_mutex;
static void set_thread_name(const char* const fmt, const int arg)
{
if (s_set_thread_name)
{
int res;
char name[32];
snprintf(name, sizeof(name), fmt, arg);
n... | 1 |
#include <pthread.h>
int count = 0;
void __VERIFIER_atomic_inc()
{
__atomic_begin();
count++;
__atomic_end();
}
void __VERIFIER_atomic_dec()
{
__atomic_begin();
count--;
__atomic_end();
}
pthread_mutex_t mutexa,mutexb;
void my_thread1() {
pthread_mutex_lock(&mutexa);
__VERIFI... | 0 |
#include <pthread.h>
uint8_t hour;
uint8_t min;
uint8_t mode;
uint8_t repeat_factor;
char name[128];
struct AlarmClockInfo *next;
} AlarmClockInfo;
AlarmClockInfo **AlarmClockTab;
pthread_mutex_t AlarmClockLockTab[32];
int set_alarms = 0;
int update_alarms = 0;
int cancell... | 1 |
#include <pthread.h>
double sum;
void *runner(void *param);
struct thread_param {
int min;
int max;
};
pthread_mutex_t lock;
int main(int argc, char* argv[])
{
int n = atoi(argv[1]);
int thread_no = atoi(argv[2]);
if (thread_no < 1) {
printf("Error: There must be atleast one thre... | 0 |
#include <pthread.h>
long long int compteur = 0;
pthread_mutex_t mtx_compteur = PTHREAD_MUTEX_INITIALIZER;
void * fonction(void * arg)
{
long nb_iterations = (long) arg;
int i;
pthread_mutex_lock(& mtx_compteur);
for (i = 0; i < nb_iterations; i ++)
compteur = compteur + 1;
pthread_mutex_u... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t lleno;
pthread_cond_t vacio;
int n_elementos;
int pos_p = 0;
int pos_c = 0;
int buffer[1024];
void *Productor(void *arg);
void *Consumidor(void *arg);
int main(int argc, char *argv[]){
pthread_t th1, th2;
pthread_mutex_init(&mute... | 0 |
#include <pthread.h>
static const char rcsid[]="$Id: diag.c,v 1.7 2007/05/18 23:14:40 santinod Exp $";
static pthread_mutex_t diag_mtx=PTHREAD_MUTEX_INITIALIZER;
static FILE *lf;
int debug_level;
void diag_restart(char *log_file)
{
pthread_mutex_lock(&diag_mtx);
fclose(lf);
lf=fopen(... | 1 |
#include <pthread.h>
extern int errno;
int gridsize = 0;
int grid[10][10];
int threads_left = 0;
pthread_mutex_t lock[10][10];
time_t start_t, end_t;
int PrintGrid(int grid[10][10], int gridsize)
{
int i;
int j;
for (i = 0; i < gridsize; i++)
{
for (j = 0; j < gridsize; j++)
fprin... | 0 |
#include <pthread.h>
void *function1();
void *function2();
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond;
int my_turn = 0;
int main(int argc, char* argv[])
{
int rc1, rc2;
pthread_t thread1, thread2;
pthread_cond_init(&cond, 0);
if( (rc1=pthread_create... | 1 |
#include <pthread.h>
extern char ** environ;
pthread_mutex_t env_mtx;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void thread_init()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&env_m... | 0 |
#include <pthread.h>
struct mtx Giant;
static void
assert_mtx(struct lock_object *lock, int what)
{
mtx_assert((struct mtx *)lock, what);
}
static void
lock_mtx(struct lock_object *lock, int how)
{
mtx_lock((struct mtx *)lock);
}
static int
unlock_mtx(struct lock_object *lock)
{
struct m... | 1 |
#include <pthread.h>
char senha[11] = "ABCDEFGhIJ\\0";
char result[11] = { '\\0' };
int index_letra = 0;
pthread_t threads[4];
pthread_barrier_t barrier;
pthread_mutex_t mutex_index_letra = PTHREAD_MUTEX_INITIALIZER;
int incrementar_index_letra(int id){
int i;
pthread_mutex_lock(&mutex_... | 0 |
#include <pthread.h>
int thread_count;
double a, b, h;
int n, local_n;
pthread_mutex_t mutex;
double total;
double f(double x) {
double return_val;
return_val = x*x;
return return_val;
}
double Trap( double local_a, double local_b,int local_n,double h)
{
double integral;
... | 1 |
#include <pthread.h>
int VT_mc13783_SU_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783_SU_cleanup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783... | 0 |
#include <pthread.h>
struct job {
struct job *j_next;
struct job *j_prev;
pthread_t j_id;
};
struct queue {
struct job *q_head;
struct job *q_tail;
pthread_rwlock_t q_lock;
pthread_cond_t q_cond_lock;
pthread_mutex_t q_mutex_lock;
};
int queue_init(struct queue *qp) {
int er... | 1 |
#include <pthread.h>
pthread_mutex_t mesa = PTHREAD_MUTEX_INITIALIZER;
sem_t sem_fumar, sem_vacio, sem_fumando;
void * agente(void *);
void * fumador(void *);
void fumar(int comp);
void setcomp();
int getcomp();
int comp[2];
int main(int argc, char** argv) {
int i;
sem_init(&sem... | 0 |
#include <pthread.h>
char c;
short int x;
short int y;
short int step;
}Word;
int nums;
int step;
Word* ary;
pthread_cond_t mycond=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mymutex1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mymutex2=PTHREAD_MUTEX_INITIALIZER;
void getChars(int width,W... | 1 |
#include <pthread.h>
static int s_trace_level = DEFAULT_APPLICATION_TRACE_LEVEL;
static pthread_mutex_t s_mutex = PTHREAD_MUTEX_INITIALIZER;
FILE* s_log_file = 0;
int get_trace_level()
{
return s_trace_level;
}
void set_trace_level(int level)
{
s_trace_level = level;
}
static const in... | 0 |
#include <pthread.h>
int stack[100][10];
int size=0;
sem_t sem;
pthread_t thread[2];
pthread_mutex_t mut;
int number=1,i;
int fd;
char buf[1023]={0};
char str[1024]={0};
void *thread1()
{
while(1){
pthread_mutex_lock(&mut);
... | 1 |
#include <pthread.h>
char mapper_pool[500];
char reducer_pool[5*500];
pthread_mutex_t mapper_lock=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t reducer_lock=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t gen_read=PTHREAD_MUTEX_INITIALIZER;
sem_t sem_write,sem_read,sem_read1,sem_write1;
sem_t sem_read... | 0 |
#include <pthread.h>
int number;
pthread_mutex_t mu= PTHREAD_MUTEX_INITIALIZER;
sem_t full_sem;
sem_t empty_sem;
pthread_cond_t sig_consumer= PTHREAD_COND_INITIALIZER;
pthread_cond_t sig_producer= PTHREAD_COND_INITIALIZER;
void *consumer(void *dummy)
{
int printed= 0;
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.