text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
char** theArray;
pthread_mutex_t mutex;
int aSize = 100;
int usr_port;
void* ServerEcho(void *args);
int main(int argc, char * argv []){
printf("creating mutex \\n");
pthread_mutex_init(&mutex,0);
int n = atoi(argv[2]);
usr_port = atoi(argv[1]);
if( (n==10)||... | 1 |
#include <pthread.h>
volatile int *signalArray;
struct timeval *readTimeStamp,*detectTimeStamp;
int N,NTHREADS,alarm_seconds;
volatile int readSum,detectedSum,changedSignal;
pthread_mutex_t changedSignal_mtx;
void exitfunc(int sig)
{
int i,usecRead,usecDetect,detectionSpeed;
int inTimeDetect... | 0 |
#include <pthread.h>
void* pass(void*);
double timer();
int token;
pthread_mutex_t mtx;
pthread_cond_t cnd;
}lock;
int ID;
int rounds;
lock* left;
lock* right;
}args;
int main(int argc, char* argv[]){
int p;
int r;
double start;
double end;
p = (argc > 1) ? atoi(argv[1]) : 100... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
long counter[256];
void *thread_counting(void *ptr)
{
int fd;
int i;
int ending;
char buffer[16384];
char *filename = (char*) ptr;
pthread_mutex_lock(&lock);
for(i=0;i<257;i++)
{
counter[i] = 0L;
}
fd = open(filename, O_RDONLY);
if (fd < ... | 0 |
#include <pthread.h>
pthread_t philosopher[5];
pthread_mutex_t forks[5];
unsigned int randr (unsigned int min, unsigned int max)
{
double scaled = (double)rand()/32767;
return scaled*(max - min + 1) + min;
}
void *func(void *id){
long n = (long)id;
while(1){
printf("... | 1 |
#include <pthread.h>
int g_positions[3] = {0};
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
void* foo(void* p_param)
{
int t_index = (intptr_t) p_param;
while(g_positions[t_index] < 4)
{
if(t_index == 0)
... | 0 |
#include <pthread.h>
sem_t semaforo;
pthread_mutex_t mutex;
void *body(void *arg)
{
int i, j;
char * mychar = (char*) arg;
for (j=0; j<10; j++)
{
pthread_mutex_lock(&mutex);
for (i=0; i<1000000; i++);
for (i=0; i<4; i++)
{
fprintf(stderr, mychar);
}
pthread_mutex_un... | 1 |
#include <pthread.h>
int fd;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void analyse_port_info(unsigned int msg_data)
{
info.data = msg_data;
if (PORT != data_id) return;
if (PLUG_IN == data_info) {
printf("PORT change: port%d plugged in\\n", data_no);
} else if ... | 0 |
#include <pthread.h>
static long hits_to_circle_area = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
{
long number_of_points;
long thread_id;
} pthread_input_t;
void*
number_of_hits( void* input )
{
pthread_input_t* pt_input = ( pthread_input_t* )input;
double x... | 1 |
#include <pthread.h>
static struct log * stat_log;
static pthread_mutex_t stat_lock = PTHREAD_MUTEX_INITIALIZER;
int ccnfstat_init(char * filename)
{
stat_log = malloc(sizeof(struct log));
char log_name[256];
snprintf(log_name, 256, "ccnf_stats_%u", g_nodeId);
if (log_init(log_na... | 0 |
#include <pthread.h>
int main(int argc, char *argv[])
{
int err;
struct timespec tout;
struct tm *tmp = 0;
char buf[64] = "";
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&lock);
printf("mutex is locked\\n");
clock_gettime(CLOCK_REALTIM... | 1 |
#include <pthread.h>
unsigned int led_speed;
pthread_mutex_t lock;
static void *LEDMod(void *dummy)
{
unsigned int led_period;
int tmp;
tmp = open("/sys/class/leds/led-ds23/brightness", O_WRONLY);
if (tmp < 0)
exit(1);
while (1) {
pthread_mutex_lock(&loc... | 0 |
#include <pthread.h>
void* producer(void*);
void* consumer(void*);
struct Context{
pthread_cond_t* cond;
pthread_mutex_t* mutex;
char holder;
int error;
};
int main(){
volatile struct Context context;
context.cond = (pthread_cond_t*)malloc(siz... | 1 |
#include <pthread.h>
void *consumidor(int *v);
void quitaritem(int* v);
void * productor(int *v);
void poneritem(int* v);
void imprimir(int *v,char *c);
int vacio=5,lleno=0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t si_vacio = PTHREAD_MUTEX_INITIALIZER;
stat... | 0 |
#include <pthread.h>
unsigned int counter = 0;
unsigned int result = 0;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t result_mutex = PTHREAD_MUTEX_INITIALIZER;
void* chain( void* );
void main()
{
setvbuf(stdout, 0, _IONBF, 0);
int i;
pthread_t thr[4];
for ( i... | 1 |
#include <pthread.h>
int *washedcars;
int *machine;
double *timeWash;
int *flag;
pthread_mutex_t mutex;
pthread_cond_t IsMachine;
struct timeval startT, nowT;
int RunThread(void* id)
{
int ID=(int)id;
struct timeval Wasingtime;
pthread_mutex_lock(&mutex);
if(*machine<=0)
pt... | 0 |
#include <pthread.h>
pthread_mutex_t apopen_mutex = PTHREAD_MUTEX_INITIALIZER;
struct popen_list_item {
struct popen_list_item *next;
FILE *f;
pid_t pid;
};
static struct popen_list_item *popen_list ;
FILE *apopen(const char *command, const char *modes)
{
FILE *fp;
struct popen_list_... | 1 |
#include <pthread.h>
double red[10000] = {100.0, 0.0};
double blk[10000] = {100.0, 0.0};
pthread_t ids[10000];
int sizep[10000];
int nprocs;
struct ARGS {
int beg, end, t, id;
} sp[10000];
pthread_mutex_t *mut;
void *slave(void *p)
{
int i, ii, ini, fim, ticks, id, cnt = 0;
ini = ((s... | 0 |
#include <pthread.h>
struct mpd_connection *conn;
pthread_mutex_t mpd_mutex;
pthread_t mpd_fred;
long ts_stop = 0;
int easympd_internal_debug;
static int handle_error(struct mpd_connection *c) {
assert(mpd_connection_get_error(c) != MPD_ERROR_SUCCESS);
fprintf(stderr, "%s\\n", mpd_con... | 1 |
#include <pthread.h>
static pthread_mutex_t gAllocMutex;
int MSGBUF_SYS_init (void)
{
pthread_mutex_init (&gAllocMutex, 0);
return 0;
}
void * MSGBUF_SYS_malloc
(
size_t xSize
)
{
void * pData;
pthread_mutex_lock (&gAllocMutex);
pData = malloc (xSize);
pthread_mutex_unlock (&g... | 0 |
#include <pthread.h>
static int sPowerStatefd;
static const char *pwr_state_mem = "mem";
static const char *pwr_state_on = "on";
static pthread_t tinasuspend_thread;
static pthread_mutex_t tinasuspend_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t tinasuspend_cond = PTHREAD_COND_INI... | 1 |
#include <pthread.h>
double red[200];
pthread_mutex_t lock;
pthread_t threads[200];
struct RedEnvelo
{
double money;
int num;
}re;
struct Person
{
int id;
double m;
int flag;
}per[200];
void CreatRedenve(double m,int n)
{
pthread_mutex_lock(&lock);
re.money... | 0 |
#include <pthread.h>
int memory[(2*960+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top;
int index_malloc(){
int curr_alloc_idx = -1;
pthread_mutex_lock(&m);
if(next_alloc_idx+2-1 > (2*960+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx ... | 1 |
#include <pthread.h>
struct _image_t {
int width;
int height;
image_t *next;
unsigned char data[1];
};
static inline unsigned int get_pixel (image_t *img, int x, int y)
{
return (unsigned int) img->data[(img->width * y) + x];
}
static inline void set_pixel (image_t *img, int x, int y, unsi... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void unlock(void *p)
{
printf(" call the cleanup to unlock\\n");
}
void *thread_func1(void *p)
{
pthread_cleanup_push(unlock,0);
pthread_mutex_lock(&mutex);
long int i=0;
sleep(1);
while(i<1000000)
{
i++;
(*(long int*)p)++;
}
pthread_e... | 1 |
#include <pthread.h>
void usync_queue_init(struct usync_queue *q)
{
pthread_mutex_init(&q->qlist_mutex, 0);
pthread_cond_init(&q->qlist_cond, 0);
ulist_head_init(&q->qlist);
ulist_head_init(&q->accum_list);
q->active = 1;
}
inline void usync_queue_push_list_(struct usync_queue *q,
stru... | 0 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_t thr[(10)];
int pass[(10)] = {0};
void* thread_func(void *arg)
{
size_t index = (size_t)arg;
pass[index] = 1;
pthread_mutex_lock(&mut);
pthread_mutex_unlock(&mut);
return 0;
}
void DetachPin(u... | 1 |
#include <pthread.h>
int buff[100];
int i=0;
int produrre=100000;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condizione=PTHREAD_COND_INITIALIZER;
void *produttori(void *arg){
int indice =*(int*)arg;
while(i<produrre){
pthread_mutex_lock(&mutex);
buff[i]=rand()%1... | 0 |
#include <pthread.h>
void Emove_player(){
int f=0;
float x=0, y=0, z=0;
pthread_mutex_lock(&Tlock_input);
x = EGinput.v_move_rel[0];
y = EGinput.v_move_rel[2];
z = EGinput.v_move_rel[1];
if(EGplayer.look[0]>90) EGplayer.look[0]=90;
if(EGplayer.look[0]<-90)EGplayer.look[0]=-90;
if(E... | 1 |
#include <pthread.h>
pthread_mutex_t lock_flag;
int flag = 1;
int num = 1;
int ret;
int fd1;
int fd2;
int fd3;
int fd4;
char buff1[1024]={0};
char buff2[1024]={0};
char buff3[1024]={0};
char buff4[1024]={0};
void *handler1(void *arg)
{
ret = write(fd1,"A.",2);
int i = 0;
while(1)
{
if(i >= ... | 0 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static unsigned int seed0;
static unsigned int seed1;
static int have_init = 0;
static int read_dev_random (void *buffer, size_t buffer_size)
{
int fd;
ssize_t status = 0;
char *buffer_position;
size_t yet_to_... | 1 |
#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(int id){
struct foo *fp;
int idx;
if((fp=malloc(sizeof(struct foo)))!=0){
f... | 0 |
#include <pthread.h>
pthread_t threadArray[10];
static pthread_mutex_t lock;
void* feldThread(void* arg) {
int i;
for (i = 0; i < 10; i++) {
if (pthread_equal(threadArray[i], pthread_self())) {
pthread_mutex_lock(&lock);
struct Position ps = gibStartPosition(i);
do {
char ... | 1 |
#include <pthread.h>
pthread_t thread_ids[8];
pthread_mutex_t twos_mutex, threes_mutex, fives_mutex;
int twos, threes, fives;
void *f(void *arg) {
while(1) {
pthread_mutex_lock(&twos_mutex);
pthread_mutex_lock(&threes_mutex);
pthread_mutex_lock(&fives_mutex);
... | 0 |
#include <pthread.h>
void * serverthread(void * parm);
pthread_mutex_t mut;
int visits = 0;
main (int argc, char *argv[])
{
struct hostent *ptrh;
struct protoent *ptrp;
struct sockaddr_in sad;
struct sockaddr_in cad;
int sd, sd2;
int port;
int alen;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
char *word;
int count;
struct dict *next;
} dict_t;
dict_t *d;
char *
make_word( char *word ) {
return strcpy( malloc( strlen( word )+1 ), word );
}
dict_t *
make_dict(char *word) {
dict_t *nd = (dict_t *) malloc( sizeof(dict_t) );
nd->wo... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
char global[2000] = "";
void * ThreadOne(void * a)
{
char character[3];
FILE *fp;
fp = fopen("data1.txt", "r");
if (fp == 0) {
printf("Can't open input file data1.txt!");
exit(1);
}
while (fscanf(fp, "%s", cha... | 1 |
#include <pthread.h>
int g_SOMA_tam, g_SOMA_nThreads, g_SOMA_maiorIndice=0;
float **g_SOMA_A;
double *g_SOMA_somasColunas, g_SOMA_maiorElemento=0;
pthread_mutex_t g_SOMA_maiorIndice_mutex, g_SOMA_maiorElemento_mutex;
void *thread_soma_coluna(void* arg){
int i, j, index = *( (int*) arg);
for(j=i... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condizione=PTHREAD_COND_INITIALIZER;
int contatore=0;
int limite=0;
void *somma(void *param){
int i=0;
int a,b,c=0;
while(i<1000 && contatore <=limite){
pthread_mutex_lock(&mutex);
a=rand()%10;
b=rand()... | 1 |
#include <pthread.h>
float hole= 0;
int flag= 0;
pthread_mutex_t lock_hole;
void delay(){
int aux2;
for (aux2= 600000; aux2 > 0; aux2--);
return;
}
void delay2(){
int aux2;
for (aux2= 100000; aux2 > 0; aux2--);
return;
}
double get(){
int aux1;
pthread_mutex_lock(&lock_hole);
aux1= hol... | 0 |
#include <pthread.h>
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
int balance=1000;
void deposit(void *ptr)
{
int i;
for(i=1;i<=50;i++)
{
pthread_mutex_lock(&mymutex);
balance=balance+50;
printf("\\nBALANCE AFTER %d DEPOSIT:\\t%d\\n",i,balance);
pthread_mutex_un... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int minD = 1000;
long formula(long n){
return n*(3*n-1)/2;
}
int is_pentagonal(long s){
unsigned delta = sqrt(1+24*s);
if( delta*delta == (1+24*s) && (1+ delta)%6 == 0)
return 1;
return ... | 0 |
#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_lock(&chopstick[(((me)+1)%5)]);
}
}
v... | 1 |
#include <pthread.h>
const char *
c_getenv(const char *variable)
{
return getenv(variable);
}
bool
c_setenv(const char *variable, const char *value, bool overwrite)
{
return setenv(variable, value, overwrite) == 0;
}
void
c_unsetenv(const char *variable)
{
unsetenv(variable);
}
ch... | 0 |
#include <pthread.h>
int ocupacion=0;
pthread_mutex_t m;
pthread_cond_t barbero_durmiendo;
pthread_cond_t corte_pelo;
void CortarElPelo() {
printf("Estoy cortando el pelo....ocupacion=%d\\n",ocupacion);
sleep(3);
printf("He terminado de cortar el pelo!!!\\n");
}
void * barbero ()
{... | 1 |
#include <pthread.h>
volatile int arg;
volatile int res;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c1 = PTHREAD_COND_INITIALIZER,
c2 = PTHREAD_COND_INITIALIZER;
void *
thread_routine(void *dummy)
{
while(1) {
pthread_mutex_lock(&mutex);
if(arg < 0)... | 0 |
#include <pthread.h>
void *thread_function (void *arg);
pthread_mutex_t x_mutex;
int x;
int test_ready = 0;
int
main ()
{
int res;
pthread_t threads[4];
int i;
pthread_mutex_init (&x_mutex, 0);
for (i = 0; i < 4; ++i)
{
res = pthread_create (&threads[i],
0,
t... | 1 |
#include <pthread.h>
void handler(int);
void *threadroutine(void *);
pthread_mutex_t mt;
pthread_cond_t cv;
void
handler(int sig)
{
return;
}
void *
threadroutine(void *arg)
{
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGALRM);
pthread_sigmask(SIG_UNBLOCK, &set, 0);
pthread_m... | 0 |
#include <pthread.h>
char *num_str[] = { "one", "two", "three", "four", "five", "six", "seven",
"eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen",
"fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "twenty",
"twenty one", "twenty two", "twenty three", "twenty four", ... | 1 |
#include <pthread.h>
int clientCount = 0;
int byteCount = 0;
pthread_mutex_t lock;
struct serverParm{
int connectionfd;
int clientNO;
};
static int callback(void *data, int argc, char **argv, char **azColName) {
int *fileDesc;
fileDesc = (int *) data;
int i;
for (i = 0; i < argc; i++)... | 0 |
#include <pthread.h>
struct student
{
int id;
int age;
int name;
}stu;
int i;
pthread_mutex_t mutex;
void *thread_fun1(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
stu.id = i;
stu.age = i;
stu.name = i;
i++;
if(stu.id !=stu.age ||stu.id!=stu.name||stu.age!=stu.name )
... | 1 |
#include <pthread.h>
static int led_isOn = CONTROL_UNKNOWN;
static int led_green_isOn = CONTROL_UNKNOWN;
static int led_red_isOn = CONTROL_UNKNOWN;
static int nChargingFull = CONTROL_UNKNOWN;
static int nChargingRemoved = CONTROL_UNKNOWN;
void turn_led_on()
{
if (led_isOn == CONTROL_ON)
return;... | 0 |
#include <pthread.h>
static int *buffer;
static int size;
static int num_producers;
static int cindex;
static int pindex;
pthread_t thread;
int id;
} thread_data;
struct thread_data *producers;
struct thread_data *consumers;
static sem_t spaces;
static sem_t items;
static pthread_mutex... | 1 |
#include <pthread.h>
int shared_x = 0;
int resource_counter = 0;
int waiting_readers = 0;
int NUM_READS = 5;
int NUM_WRITES = 5;
int NUM_READERS = 10;
int NUM_WRITERS = 3;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_write = P... | 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 *idp)
{
int j,i;
double result=0.0;
int *my_id = idp;
for (i=0; i < 8; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (co... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t writer_condition = PTHREAD_COND_INITIALIZER;
pthread_cond_t reader_condition = PTHREAD_COND_INITIALIZER;
int waitingReaders = 0;
int resource_counter = 0;
int variable = 0;
void *writer(void *param);
voi... | 0 |
#include <pthread.h>
pthread_t dipendenti[10];
pthread_t cuoco;
{
int primi_piatti_consumati;
sem_t primo_piatto, secondo_piatto, seconda_fase, posto_libero;
pthread_mutex_t lock;
} Mensa;
Mensa mensa;
void * cuoco_thread(void * t)
{
unsigned int tempo_di_preparazione;
... | 1 |
#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 (co... | 0 |
#include <pthread.h>
struct mymesg
{
long mtype;
char mtext[512 + 1];
};
struct threadinfo
{
int qid;
int fd;
int len;
pthread_mutex_t mutex;
pthread_cond_t ready;
struct mymesg m;
};
void*
helper (void* arg)
{
int n;
struct threadinfo* tip = arg;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutexvar=PTHREAD_MUTEX_INITIALIZER;
int Matrix_rows,Matrix_cols,Vector_size;
double **Matrix,*Vector,*Result_matrix;
void * mul(void *l)
{
int j;
double sum=0;
int a=(int)l;
for(j=0;j<Vector_size;j++)
sum=sum+(Matrix[a][j]*Vector[j]);
pthread_mutex_lock... | 0 |
#include <pthread.h>
static void fail( char const *message ) {
fprintf( stderr, "%s\\n", message );
exit( 1 );
}
int *numList;
int numCount = 0;
int total = 0;
sem_t s;
int numWorked = 0;
int finished = 0;
pthread_mutex_t mon = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t workWa... | 1 |
#include <pthread.h>
int * subset;
int N;
int len;
int start;
int end;
int * counter;
pthread_mutex_t * mutex_o;
}Task;
int countsumOf(int * set, int len, int index)
{
if(len > (pow(2, len) - 1))
{
printf("This program cannot handle more than %f length of set", (pow(2... | 0 |
#include <pthread.h>
int quit,sum;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc =PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int j = 0;
printf("thr_fn\\n");
if (j==0){
printf("the init j success\\n");
while(j<101){
pthread_mutex_lo... | 1 |
#include <pthread.h>
struct process_mufi {
char * name;
int line;
int (*func) (void *);
void * arg;
int priority;
int started;
double init;
struct process_mufi * next;
};
static ProcessMUFI head;
static int init = 0;
static int running = 0;
static pthread_mutex... | 0 |
#include <pthread.h>
int nitems;
struct{
pthread_mutex_t mutex;
int buff[ 100000];
int nput;
int nval;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
void *produce( void*), *consume( void*), consume_wait( int i);
int main( int argc, char** argv)
{
int i, nthreads, count[ 100];
pthr... | 1 |
#include <pthread.h>
pthread_mutex_t print_region = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t crit_region = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t *mutex_p;
pthread_cond_t *cond_p;
char *philosophers;
int n;
int all_together;
void print(){
pthread_mutex_lock(&print_region);
... | 0 |
#include <pthread.h>
pthread_mutex_t toggleMutex;
char* fileName = "invalid";
int num_threads = 4;
int num_threads_merge = -1;
char *pbuf;
ssize_t numRead;
char *addr;
size_t len = 0;
FILE *fileIn;
int fileNum;
char *thread_offset;
long num_records_per_thread;
int increment_offset;
struct stat sb;
... | 1 |
#include <pthread.h>
struct fifo_s
{
uint32_t count;
void *buffer;
ssize_t size;
struct fifo_s *next;
};
struct fifo_s *
fifo_push (struct fifo_s *fifo, char *buffer, ssize_t size)
{
struct fifo_s *entry;
struct fifo_s *last;
entry = fifo... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cwait = PTHREAD_COND_INITIALIZER;
void *
thr_fn(void *arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0) {
perror("sigwait failed");... | 1 |
#include <pthread.h>
static pthread_mutex_t forks[5];
static void lfsr_next(uint32_t * state)
{
uint32_t state_value = *state;
uint32_t bit = ((state_value >> 0) ^ (state_value >> 10) ^ (state_value >> 30) ^ (state_value >> 31)) & 1;
*state = (state_value >> 1) | (bit << 31);
... | 0 |
#include <pthread.h>
pthread_t *tab;
int val = 0;
int valTab = 0;
int condition = 0;
static int valThread = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_attr_t attr;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *funcThread(void *arg){
pthread_mutex_lock(&mutex);
valThre... | 1 |
#include <pthread.h>
int numMax;
int nthreads;
int i_global = 0;
int soma = 0;
pthread_mutex_t mutex;
int ehPrimo(long long int n){
int i;
if (n <= 1) return 0;
if (n == 2) return 1;
if (n%2 == 0) return 0;
for (i = 3; i < sqrt(n) + 1; i += 2)
if(n%i == 0) return 0;
return 1;
}
voi... | 0 |
#include <pthread.h>
int **matrice = 0;
int rows = 0, cols = 0;
int x = 0;
int contatore = 0;
struct posizione{
int individuato;
int riga;
int colonna;
};
struct posizione *trovati = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
... | 1 |
#include <pthread.h>
static int fd = -1;
static bool add_time = 0;
static bool initial = 1;
static pthread_mutex_t mutex;
static char *trace;
static int end;
static int pos = 0;
static bool wrapped = 0;
void start_timed_trace()
{
add_time = 1;
}
void report(char *format, ...)
{
if... | 0 |
#include <pthread.h>
void
ptq_init(struct ptq *ptq, size_t q_size)
{
ptq->q_size = q_size;
ptq->count = ptq->wr = ptq->rd = 0;
pthread_mutexattr_t mutex_attr;
pthread_mutexattr_init(&mutex_attr);
pthread_mutex_init(&ptq->mutex, &mutex_attr);
pthread_cond_init(&ptq->con... | 1 |
#include <pthread.h>
unsigned int TEST_REG_RO[4] = { REG_MC34704_GENERAL3,
REG_MC34704_FAULTS,
REG_MC34704_REG4SET2,
REG_MC34704_VGSET2,
};
unsigned int TEST_REG_NA[3] = { 0x00,
0x20,
0x60,
};
unsigned int TEST_EVNT_NA[1] = { EVENT_NB };
int TEST_VALUE = 0xFFF000;
int VT_m... | 0 |
#include <pthread.h>
struct threadParameter{
int* nbThreadTotal;
int* nbThreadWaitingForSync;
int doneCreating;
pthread_mutex_t mut;
};
void initThreadParameter(struct threadParameter* p){
p->nbThreadTotal=malloc(sizeof(int*));
*(p->nbThreadTotal)=0;
p->nbThreadWaitingForSync=ma... | 1 |
#include <pthread.h>
pthread_mutex_t chopstick[5];
void pickup(int me)
{
if (me == 0)
{
pthread_mutex_lock(&chopstick[((me + 1) % 5)]);
pthread_mutex_lock(&chopstick[me]);
}
else
{
pthread_mutex_lock(&chopstick[me]);
pthread_mutex_lock(&c... | 0 |
#include <pthread.h>
int a[20];
int b[20];
int c[20];
int array_index;
int global_sum;
int counter;
pthread_mutex_t mutex;
} sem_var_t;
sem_var_t shared_variables;
void *Producer(void *arg) {
int index = (int) arg;
while (shared_variables.array_index < 20... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t thread_cond = PTHREAD_COND_INITIALIZER;
struct com_data
{
int a;
int b;
};
struct com_data mydata;
void *do_write(void *data)
{
mydata.a = 0;
mydata.b = 0;
while(1)
{
pthread_mutex_lock(&... | 0 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
struct work_struct{
int readcount;
int lastreadby;
char work_area[1024];
};
struct work_struct ws;
int time_to_exit = 0;
int main()
{
int res;
pthread_t a_thread;
pthread_t a_thread1;
void *thread_result;
... | 1 |
#include <pthread.h>
int global_value = 0;
pthread_mutex_t global_value_mutex;
void *writer(void *arg);
void *reader(void *arg);
int main(int argc, char **argv)
{
pthread_mutexattr_t mutexattr;
pthread_mutexattr_init(&mutexattr);
pthread_mutex_init(&global_value_mutex, &mutexattr);
... | 0 |
#include <pthread.h>
int VAGAS = 4;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t baia = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t chefe_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t lotou = PTHREAD_COND_INITIALIZER;
pthread_cond_t acorda_chefe = PTHREAD_COND_INITIA... | 1 |
#include <pthread.h>
void *fun1(void *);
void *fun2(void *);
struct tag {
int shared_data;
pthread_mutex_t mutex;
pthread_cond_t cond1;
pthread_cond_t cond2;
} abc = {0,PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER,PTHREAD_COND_INITIALIZER};
int main (void)
{
pthread_t thread1;
pthrea... | 0 |
#include <pthread.h>
enum {
SWITCH_ON,
SWITCH_OFF,
GET_STATUS
};
struct command {
uint8_t code;
unsigned lamp;
};
struct switch_answ {
uint8_t code;
};
struct status_data {
unsigned lamps[LAMPS];
};
static struct {
unsigned lamps[LAMPS];
pthread_mutex_t mutex;
struct tcp_server serv... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
l... | 0 |
#include <pthread.h>
char *sieve;
long sieve_size;
pthread_mutex_t mutex;
long next;
long get_next() {
long res;
pthread_mutex_lock(&mutex);
while (sieve[next]) {
next++;
}
res = next;
next++;
pthread_mutex_unlock(&mutex);
return res;
}
void* sieve_worker... | 1 |
#include <pthread.h>
struct propset {
char *str;
int row;
int delay;
int dir;
};
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
int main(int ac, char *av[])
{
int c;
pthread_t thrds[10];
struct propset props[10];
void *animate();
int num_msg ;
int i;
if ( ac == 1 ){
printf... | 0 |
#include <pthread.h>
int N;
int count = 0;
pthread_mutex_t mcount = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t minterrupt = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cinterrupt = PTHREAD_COND_INITIALIZER;
pthread_cond_t ccreation = PTHREAD_COND_INITIALIZER;
pthread_cond_t ctermination = PTHREA... | 1 |
#include <pthread.h>
volatile long double area = 0.0;
pthread_mutex_t piLock;
long double intervals;
int numThreads;
void *computeArea(void *id)
{
long double x,
width,
localSum = 0;
int i,
threadID = *((int*)id);
width = 360.0/ interv... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void* p_func(void* p)
{
pthread_mutex_lock(&mutex);
int ret;
printf(" i am child ,this is wait entrance\\n" );
ret=pthread_cond_wait(&cond,&mutex);
if(0!=ret)
{
printf("pthread_cond_wait ret is %d\\n" ,ret);
}
pr... | 1 |
#include <pthread.h>
void *find_words(void*);
int map_reduce(int number_threads, char *string, struct list *list);
int main(void) {
char *string;
int cur_time, i, j;
struct list *list;
struct stat *buf;
buf = (struct stat *) malloc(sizeof(struct stat));
stat("./Don_Quixo... | 0 |
#include <pthread.h>
pthread_mutex_t fork_mutex[5];
pthread_mutex_t eat_mutex;
main()
{
int i;
pthread_t diner_thread[5];
int dn[5];
void *diner();
pthread_mutex_init(&eat_mutex, 0);
for (i=0;i<5;i++)
pthread_mutex_init(&fork_mutex[i], 0);
for (i=0;i<5;i++){
dn[i] = i;
... | 1 |
#include <pthread.h>
extern int klee_make_symbolic(void* array, size_t size, const char* name);
pthread_mutex_t cs0, cs1;
int globalX = 0;
int globalY = 0;
void
print_safe()
{
printf("-------- safe\\n");
}
void
print_deadlock()
{
printf("------------- could deadlock\\n");
}
void * work0 (... | 0 |
#include <pthread.h>
char buff[30];
pthread_mutex_t mt;
void* clnt_handling(void* param)
{
int str_len;
int clnt_sock=*((int*)param);
pthread_mutex_lock(&mt);
while(1)
{
str_len=read(clnt_sock,buff,30);
if(str_len<=0)
break;
write(clnt_sock,buff... | 1 |
#include <pthread.h>
char *pbs_locjob_err(
int c,
char *jobid,
char *extend,
int *local_errno)
{
int rc;
struct batch_reply *reply;
char *ploc = (char *)0;
int sock;
struct tcp_chan *chan = 0;
if ((jobid == (char *)0) || (*jobid == '\\0'))
{
*local_errno = PBSE_... | 0 |
#include <pthread.h>
void * adder(void *);
pthread_mutex_t m;
pthread_t tid[2];
int bignum = 0;
main( int argc, char *argv[] )
{
int i, ret;
for (i=0; i<2; i++) {
pthread_create(&tid[i], 0, adder, (void *)i);
pthread_join(tid[1], 0);
}
pthread_join(tid[0], 0);
printf... | 1 |
#include <pthread.h>
int mediafirefs_getattr(const char *path, struct stat *stbuf)
{
printf("FUNCTION: getattr. path: %s\\n", path);
struct mediafirefs_context_private *ctx;
int retval;
time_t now;
ctx = fuse_get_context()->private_data;
pthread_mutex_... | 0 |
#include <pthread.h>
static pthread_mutex_t dref_mutex = PTHREAD_MUTEX_INITIALIZER;
static unsigned long num_open_dirs;
static unsigned long num_open_dirs_max;
static void dref_lock(void)
{
if (!global_threaded)
return;
pthread_mutex_lock(&dref_mutex);
}
static void dref_unlock(void)
{
... | 1 |
#include <pthread.h>
int beers = 2000000;
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void* drink_lots()
{
int i;
pthread_mutex_lock(&beers_lock);
for (i = 0; i < 100000; i++) {
beers = beers - 1;
}
pthread_mutex_unlock(&beers_lock);
printf("beers = %i\\n", bee... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.