text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct msg {
struct msg *m_next;
char *data;
};
struct msg *workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
void
process_msg(int thread)
{
struct msg *mp;
for (;;) {
pthread_mutex_lock(&qlock);
... | 1 |
#include <pthread.h>
char** field;
char** new_field;
int n, m;
int total_number_of_threads;
int total_number_of_iterations;
struct segment_t* segments;
pthread_t* threads;
char* finished_treads;
int number_of_finished_treads;
pthread_mutex_t mutex;
pthread_cond_t conditional;
int number_of_acti... | 0 |
#include <pthread.h>
struct ID_object{
int objID;
struct position *pos;
};
pthread_mutex_t obj_lock;
static struct ID_object *obj_list;
void set_num_obj(int num){
if (pthread_mutex_init(&obj_lock, 0) != 0){
pexit("Mutex init failed: ");
}
if ((obj_list = calloc(num ,sizeof(str... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
long long int *MatrixA,*MatrixB,i,j,k,nRows,nThread,offset;
long long int sum=0;
void * multiply(void *arg)
{
long long int row=*(long long int*)arg;
long long int mysum=0;
int i;
for(i=0;i<offset;i++)
mysum=mysum+MatrixA[row*offset+i]*MatrixB[row*offs... | 0 |
#include <pthread.h>
static char encoding_table[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd'... | 1 |
#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;
int main(int argc, char *argv[])
{
pthread_t t1, t2;
struct arg_set args1, args2;
... | 0 |
#include <pthread.h>
struct fuse_session *fuse_session_new(void)
{
struct fuse_session *se = (struct fuse_session *) malloc(sizeof(*se));
if (se == 0) {
fprintf(stderr, "fuse: failed to allocate session\\n");
return 0;
}
memset(se, 0, sizeof(*se));
return se;
}
void fuse_session_add_c... | 1 |
#include <pthread.h>
static pthread_mutex_t mallocMutex;
void initMeMalloc()
{
pthread_mutex_init(&mallocMutex, 0);
}
void deinitMeMalloc()
{
pthread_mutex_destroy(&mallocMutex);
}
void *MeAlloc( long nbytes, const char *file, int line )
{
void *ptr = ( void * )malloc( nbytes );
if ( ptr ==... | 0 |
#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;
... | 1 |
#include <pthread.h>
int array[4];
int array_index = 0;
pthread_mutex_t mutex;
void *thread(void * arg)
{
pthread_mutex_lock(&mutex);
array[array_index] = 1;
pthread_mutex_unlock(&mutex);
return 0;
}
void *main_continuation (void *arg);
pthread_t t[4];
int main()
{
int i;
... | 0 |
#include <pthread.h>
void *fetch_data(void *filename);
void exit_handler (int sigNum);
int file_request_count;
float file_access_time;
pthread_mutex_t count_lock;
pthread_mutex_t avg_lock;
int main() {
pthread_t thread1;
int status;
char cmd[80];
srand(time(0));
signa... | 1 |
#include <pthread.h>
{
struct node *next;
} node;
{
node *head;
node *tail;
pthread_mutex_t GlobalLock;
} queue;
void Queue_Init(struct queue *q);
void Queue_Enqueue(struct queue *q);
int Queue_Dequeue( struct queue *q);
void* Thread_Enqueue(void *q);
void* Thread_Dequeue(void *q);
int ma... | 0 |
#include <pthread.h>
char buf[1] = {0};
pthread_mutex_t rlock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t wlock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t can_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t can_write = PTHREAD_COND_INITIALIZER;
void* write_buf(void * p)
{
char c;
int i = 0;
... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PHTREAD_MUTEX_INITIALLIZER;
extern char **environ;
static void thread_init()
{
pthread_key_create(&key, free);
}
char *getenv(const char *name)
{
int i, len;
char *... | 0 |
#include <pthread.h>
pthread_t philosopher[5];
pthread_mutex_t chopstick[5] = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER};
struct philosopher_t {
int nr;
int left;
... | 1 |
#include <pthread.h>
static inline struct msglist *get_msglist(struct threadqueue *queue)
{
struct msglist *tmp;
if(queue->msgpool != 0) {
tmp = queue->msgpool;
queue->msgpool = tmp->next;
queue->msgpool_length--;
} else {
tmp = (struct msglist *)malloc(... | 0 |
#include <pthread.h>
struct signal {
int active;
pthread_mutex_t mutex;
sem_t semaphore;
};
static struct signal sig;
void* thread (void* param)
{
sleep(5);
pthread_mutex_lock(&sig.mutex);
sig.active = 1;
pthread_mutex_unlock(&sig.mutex);
sem_post(&sig.... | 1 |
#include <pthread.h>
void *hit(void *);
float elapsed_time_msec(struct timespec *, struct timespec *, long *, long *);
long num_hits=0, num_threads=0;
pthread_mutex_t mutex;
int main (int argc, char *argv[])
{
float pi;
pthread_t tid[32];
int i, myid[32];
struct timespec t0, t1;
unsig... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full;
sem_t empty;
char bufferpool[5][100];
int in = 0;
int out = 0;
pthread_t producers[3];
pthread_t consumers[4];
void* produce(void* args);
void* consume(void* args);
FILE* file;
int t[4]={1,2,3,4};
int main(){
pthread_mutex_init(&mu... | 1 |
#include <pthread.h>
struct pair_count {
short pair;
int count;
};
pthread_mutex_t mutex;
struct pair_count pc[100000];
int pair_num = 0;
int find_pair(short* pair)
{
int i;
for (i = 0; i < pair_num; i++)
{
if (pc[i].pair == pair)
return i;
}
return -1;
}
void add_pair(short* pa... | 0 |
#include <pthread.h>
long long sum;
pthread_mutex_t sumLock;
int gcd(int a, int b) {
return a < b ? gcd(b, a) : b == 0 ? a : gcd(b, a % b);
}
int phi(int n) {
int i, r = 0;
for( i=1; i<n; i++ )
if ( gcd(n, i) == 1 ) r++;
return r;
}
void* threadRoutine(void* arg)
{
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *producer(void *arg)
{
long int i;
long int loops = (long int)arg;
for (i=0; i<loops; i++) {
pthread_mutex_lock(&mutex);
if (buffer_is_full())
pt... | 0 |
#include <pthread.h>
pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;
int mean, samples, total;
void *report_stats(void *p)
{
int caught;
sigset_t sigs_to_catch;
printf("\\nreport_stats() started.\\n");
sigemptyset(&sigs_to_catch);
sigaddset(&sigs_to_catch, SIGUSR1);
for ... | 1 |
#include <pthread.h>
struct list_head {
struct list_head *next ;
struct list_head *prev ;
};
struct s {
int datum ;
struct list_head list ;
};
struct cache {
struct list_head slot[10] ;
pthread_mutex_t slots_mutex[10] ;
};
struct cache c ;
static inline void INIT_LIST_HEAD(struct ... | 0 |
#include <pthread.h>
pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex;
int num_str=1, flag=0;
void* thread_func_writer(void * arg){
char str[30];
time_t cur_time;
struct tm * tv;
int i, try_lock, fd;
int len_str;
if ((fd = open("./File.txt", O_RDWR | O_CREAT, 0744... | 1 |
#include <pthread.h>
struct cycle_buf_t {
uint32_t size;
uint32_t in;
uint32_t out;
uint8_t *buf;
pthread_mutex_t rw_lock;
};
static struct cycle_buf_t* cycle_init(void)
{
struct cycle_buf_t* cycle_p;
cycle_p = calloc( 1, sizeof(*cycle_p) );
if ( !cycle_p )
{
exit( 1 );
}
cycle_p->b... | 0 |
#include <pthread.h>
int id, eat_count;
pthread_t thread;
struct fork *right_neighbor, *left_neighbor;
}ph;
int num;
pthread_mutex_t mutex;
}fr;
void* ph_life(ph* p){
srand(time(0));
int i = 0;
for(i = 0; i < p -> eat_count; ++i){
printf("philosopher %d is sleep \\n", p->id);
sleep(ra... | 1 |
#include <pthread.h>
int balance = 1000;
int credits = 0;
int debits = 0;
pthread_mutex_t lock;
void * transactions(void * args){
int i,v;
for(i=0;i<100;i++){
pthread_mutex_lock(&lock);
v = (int) random() % 100;
if( random()% 2){
balance = balance + v;
... | 0 |
#include <pthread.h>
{
int count;
int *array;
}arr_num;
double shared_x;
pthread_mutex_t lock_x;
void swap(int* a, int* b)
{
int aux;
aux = *a;
*a = *b;
*b = aux;
}
int divide(int *vec, int left, int right)
{
int i, j;
i = left;
for (j = left + 1; ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int counter = 0;
void* justAnotherFunction(void* arg) {
long threadID = (long) arg;
pthread_mutex_lock(&mutex);
counter++;
pthread_mutex_unlock(&mutex);
pthread_exit((void*) threadID);
}
int main() {
long tID;
int r... | 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 = 0;
int signo = 0;
while(1)
{
err = sigwait(&mask, &signo);
if (err !=... | 1 |
#include <pthread.h>
static char Message_Buffer[10000];
static pthread_mutex_t Si_Ui_Mutex;
static int Message_Pos;
static char Message_String[SI_UI_MAX_MESSAGE_SIZE];
static char Command_Delim;
void si_ui_init(void)
{
Command_Delim = ';';
si_comm_open();
pthread_... | 0 |
#include <pthread.h>
int rbuf_writeto(struct io_params *iop)
{
struct rbuf_entry *w_ptr;
int i, r;
w_ptr = iop->rbuf_p;
if (pthread_mutex_lock(&w_ptr->lock) != 0)
log_die("pthread_mutex_lock locking error %d");
pthread_mutex_lock(&iop->listlock);
*iop->listready = 1;
pthread_mutex_unloc... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_mutex_t minBarrier;
pthread_mutex_t maxBarrier;
pthread_mutex_t rowBarrier;
int numWorkers;
int sum;
int nextRow = 0;
int value;
int xIndex;
int yIndex;
} MINMAX;
MINMAX min;
MINMAX max;
double read_timer() {
static bool init... | 0 |
#include <pthread.h>
struct data
{
int *a;
int *b;
int len;
int offset;
int sliceSt;
int sliceEnd;
long *myList;
};
pthread_t threads[1];
pthread_mutex_t mutex_sum;
double sum;
void *dot(void *arg)
{
int i;
int start;
int end;
struct data *d = (struct data*) arg;
pthread_mu... | 1 |
#include <pthread.h>
static int next_rank = 0, next_tid = 0;
static pthread_key_t datakey;
static pthread_t tids[P5_MAX_THREADS];
static pthread_mutex_t dprintf_lock;
static void freedata(void *);
static void freedata(void *p)
{
free(p);
}
void p5_init(int flag)
{
int *p;
if (flag)... | 0 |
#include <pthread.h>
double mivta[5][31];
double totalgral=0.0;
double totalsuc[5];
void *sumoVentas(void *sucursalid);
void *cargoVentas(void *);
pthread_mutex_t cargada_mutex1;
pthread_mutex_t cargada_mutex[5];
int cargadas[5];
pthread_cond_t sucursales[5];
int main (int argc, char *argv[]... | 1 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void *doSomeThing(void *arg)
{
pthread_mutex_lock(&lock);
unsigned long i = 0;
counter += 1;
printf("\\n Job %d started\\n", counter);
for(i=0; i<(0xFFFFFFFF); i++);
printf("\\n Job %d finis... | 0 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void thread_init(void) {
pthread_key_create(&key, free);
}
char *getenv_(const char *name) {
... | 1 |
#include <pthread.h>
static char db_root[256];
static char homedir[256];
static char import_root[256];
static char import_homedir[256];
static volatile bool stop = 0;
static volatile bool exec = 0;
static volatile bool quit = 0;
static volatile bool timeout_enable = 1;
pthread_mutex_t mutex;
i... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void err_thread(int ret, char *str)
{
if (ret != 0) {
fprintf(stderr, "%s:%s\\n", str, strerror(ret));
pthread_exit(0);
}
}
void *tfn(void *arg)
{
srand(time(0));
int ret;
while (1)
{
if((ret=pthread_mut... | 1 |
#include <pthread.h>
struct process_fcgs {
char * name;
int line;
int (*func) (void *);
void * arg;
double init;
struct process_fcgs * next;
};
static ProcessFCFS head;
static int init = 0;
static int running = 0;
static pthread_mutex_t head_lock;
static pthread_mutex_t ... | 0 |
#include <pthread.h>
buffer_item buffer[10];
int insertnum,removenum,all;
pthread_mutex_t mutex;
sem_t mo1,mo2;
sem_t empty;
sem_t full;
int cnt;
void *monitoring(void *para)
{
while(1)
{
sem_wait(&mo2);
printf("Acknowledge no : %d -> count==:%d\\n",++all,cnt);
sem... | 1 |
#include <pthread.h>
char * TimeStr[4] = {"2/4", "3/4", "4/4", "6/8"};
int main(void)
{
char c;
int success;
run = False;
keepgoing = 1;
success = init_LED ();
if (success == -1)
return -1;
init_KEY ();
status = 3;
location = 0;
tempo = 90;
run = False;
printf (... | 0 |
#include <pthread.h>
pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void ofunc(void);
void* threadfunc(void *);
void cleanup(void *);
void handler(int, siginfo_t *, void *);
int
main(int argc, char *argv[])
{
pthread_t thread;
struct sigaction act... | 1 |
#include <pthread.h>
int ** bigmatrix;
int r = 5;
int c = 5;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int ** AllocMatrix(int r, int c)
{
int ** a;
int i;
a = (int**) malloc(sizeof(int *) * r);
assert(a != 0);
for (i = 0; i <... | 0 |
#include <pthread.h>
int process_var3(char* input_path, char* output_path) {
struct sigaction sa;
memset (&sa, 0, sizeof(sa));
sa.sa_handler = &timer_handler;
sigaction (SIGALRM, &sa, 0);
struct itimerval timer;
timer.it_value.tv_sec = 0;
timer.it_value.tv_usec = 1000;... | 1 |
#include <pthread.h>
sem_t wrt;
int read_cnt = 0;
pthread_mutex_t mutex;
FILE * Wp;
struct file_id {
FILE *Rp;
};
struct file_id * file_array;
void * writer(void *param){
char c[2];
while(1){
c[0] = rand()%94+32;
c[1] = '\\0';
sem_wait(&wrt);
fwrite(c,sizeof(char),1,Wp);
... | 0 |
#include <pthread.h>
double* a;
double* b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void* dotprod(void* arg)
{
int i, start, end, len;
long offset;
double mysum, *x, *y;
offset = (long)arg;
len = dotstr.veclen;
sta... | 1 |
#include <pthread.h>
void initLoadAdaptation() {
pthread_mutex_init(&ionum_mutex, 0);
pthread_mutex_init(&worknum_mutex, 0);
pthread_mutex_init(&clientsconn_mutex, 0);
pthread_mutex_init(&inputworks_mutex, 0);
clients_connected = 0;
input_works = 0;
iothreads_num = 0;
workerthreads_num... | 0 |
#include <pthread.h>
pthread_mutex_t mcount;
pthread_cond_t mcount_threshold;
void get_memory_from_pool ( void *ptr );
void put_memory_into_pool ( void *ptr );
{
int thread_no;
int mem_count;
} meminfo;
void init_mem_info(struct mem_info * m) {
m->mem_count = 100 ;
}
int ma... | 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 (count == 12) {... | 0 |
#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... | 1 |
#include <pthread.h>
int counter;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
void *doit( void * );
int main( int argc, char **argv )
{
pthread_t tidA, tidB;
pthread_create( &tidA, 0, doit, 0 );
pthread_create( &tidB, 0, doit, 0 );
pthread_join( tidA, 0 );
pthread_join( ... | 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 == ... | 1 |
#include <pthread.h>
struct list_head {
struct list_head *next ;
struct list_head *prev ;
};
struct s {
int datum ;
struct list_head list ;
};
struct cache {
struct list_head slot[10] ;
pthread_mutex_t slots_mutex[10] ;
};
struct cache c ;
static inline void INIT_LIST_HEAD(s... | 0 |
#include <pthread.h>
static struct usb_device *current_device = 0;
static char hidraw_path[20];
static int hidraw_fd = -1;
static pthread_mutex_t device_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t device_cond = PTHREAD_COND_INITIALIZER;
static int usbdevice_added(const char *de... | 1 |
#include <pthread.h>
static unsigned int avail = 0;
static int work_pipe[2];
static pthread_mutex_t mtx_work = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static unsigned int producers = 10000;
unsigned int random_uint(unsigned int max)
{
float tmp... | 0 |
#include <pthread.h>
int n=0;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
void* thread_func(void* arg) {
int param = (int) arg;
char c='A'+param;
int ret, i=0;
for(; i < 10; i++) {
pthread_mutex_lock(&mylock);
... | 1 |
#include <pthread.h>
void *snapshot_fun()
{
int cmd;
while(1)
{
pthread_mutex_lock(&mutex_snapshot);
pthread_cond_wait(&cond_snapshot,&mutex_snapshot);
cmd = msg.cmd;
pthread_mutex_unlock(&mutex_snapshot);
switch(cmd)
{
case SNAPSHOT_ON:
system("killall mjpg_stre... | 0 |
#include <pthread.h>
pthread_mutex_t monitor;
pthread_cond_t red[5];
int fork[5]={1,1,1,1,1};
char philosophers[5]={'O','O','O','O'};
void think() {
sleep(3);
}
void eat (int n){
int i;
pthread_mutex_lock(&monitor);
philosophers[n]='o';
while (fork[n]==0 || fork[(n+1)%5]==0){... | 1 |
#include <pthread.h>
int g_buff[3];
int g_write_index = 0;
int g_read_index = 0;
pthread_mutex_t lock;
pthread_cond_t consume_cond, produce_cond;
void* produce(void *ptr){
int idx = *(int*)ptr;
printf("in produce %d %d %d\\n",idx, g_write_index, g_read_index);
while(1){
p... | 0 |
#include <pthread.h>
pthread_mutex_t finish_mutex;
pthread_cond_t finish_condvar;
int pool = 1;
int arsize = 10000;
void* single (void*);
int rs = 0;
int bs = 0;
int main (int argc, char** argv) {
int i, sum1, sum2;
struct sync_queue_t queue;
struct params *stp;
counter = 0;
... | 1 |
#include <pthread.h>
void *philosopher (void *id);
int food_on_table ();
pthread_mutex_t chopstick[5];
pthread_mutex_t food_lock;
pthread_t philo[5];
int sleep_seconds = 0;
int main (int argn, char **argv)
{
long i;
if (argn == 2)
sleep_seconds = atoi (argv[1]);
pthread_mutex_in... | 0 |
#include <pthread.h>
struct thread_args {
int tid;
int inc;
int loop;
};
int count = 0;
pthread_mutex_t count_mutex;
void *inc_count(void *arg)
{
int i,loc;
struct thread_args *my_args = (struct thread_args*) arg;
loc = 0;
{
for (i = 0; i < my_args->lo... | 1 |
#include <pthread.h>
void *area_thread ( void *arg );
double integral ( double h );
double ntr;
double nt;
double area = 0.0;
double ls = 4.0;
double li = 0.0;
pthread_mutex_t *flag_mutex;
int main ( int argc, char **argv )
{
ntr = atoi ( argv[1] );
nt = atoi ( argv[2] );
... | 0 |
#include <pthread.h>
struct thread_info{
int id;
int reader_or_writer;
int resource_id;
int arrive_t;
int burst_t;
};
struct thread_pool{
int value;
pthread_mutex_t wl;
pthread_mutex_t rl;
pthread_mutex_t can_read;
pthread_mutex_t can_write;
int w_number;
int r_number;
};
int number;... | 1 |
#include <pthread.h>
int g_num = 0;
int nNum = 0;
int nLoop = 0;
{
int numID;
}threadID;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *pthread_routine(void *arg)
{
threadID tmp = *(threadID *)arg;
pthread_mutex_lock(&mutex);
++g_num;
printf("tid = %d, g_num = %d, tmp.numID = %d... | 0 |
#include <pthread.h>
static pthread_mutex_t getservby_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
convert (struct servent *ret, struct servent *result,
char *buf, int buflen)
{
int len, i;
if (!buf) return -1;
*result = *ret;
len = strlen (ret->s_name) + 1;
if (len > bufle... | 1 |
#include <pthread.h>
pthread_mutex_t barrier_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t barrier_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t alive_mutex = PTHREAD_MUTEX_INITIALIZER;
int barrier_count = 0;
int barrier_id = 0;
pthread_t *threads;
int nb_threads;
int threads_per_row;
int ... | 0 |
#include <pthread.h>
static pthread_t thread;
static pthread_cond_t r_cond;
static pthread_mutex_t r_mutex;
struct ring_buffer {
int buffer[8];
int head;
int tail;
};
void put_value(rbuf *r, int *value)
{
int align = sizeof(r->buffer) / sizeof(int);
r->head = r->head % alig... | 1 |
#include <pthread.h>
pthread_mutex_t my_mutex;
int my_count;
void *thread_function(void *ptr );
void
my_increment_count_function()
{
pthread_mutex_lock(&my_mutex);
my_count = my_count + 1;
pthread_mutex_unlock(&my_mutex);
}
int
my_fetch_count_function()
{
int count;
count = my_coun... | 0 |
#include <pthread.h>
static pthread_mutex_t logLock;
int bhdapp_logging_init(void)
{
int rv = 0;
FILE *fp;
rv = pthread_mutex_init(&logLock, 0);
_BHDAPP_ASSERT_NET_ERROR( (rv == 0), "BHDAPP : Error creating logging mutex \\n");
fp = fopen(BHDAPP_COMMUNICATION_LOG_FILE_NE... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
pthread_mutex_t mutexsum;
DOTDATA dotstr;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
len = dotstr.veclen;
start = offs... | 0 |
#include <pthread.h>
double* x;
double* c;
double** A;
double* y;
int n;
int t;
int threadCount;
int type;
int barrierCount = 0;
pthread_mutex_t lock;
pthread_cond_t cond;
pthread_barrier_t barrier;
int* getRange(int myrank, int n, int p) {
int quotient = n / p;
int remainder = n % p;
in... | 1 |
#include <pthread.h>
pthread_mutex_t locka, lockb, lockc, lockd, locke, lockf, lockg, lockh, locki;
sem_t semi,sema,semb,semc,semd,semef,semg,semh,semi;
void *fa(void *arg){
pthread_mutex_lock(&locka);
fprintf(stdout,"a");
pthread_mutex_unlock(&lockb);
pthread_mutex_unlock(&lockc);
pthre... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5];
sem_t philosopherGoEat[5];
pthread_mutex_t fork_status;
bool fork_available[5];
bool canEat(bool fork1_available, bool fork2_available){
if(fork1_available ==1 && fork2_available == 1){
fork1_available = 0;
fork2_available = 0;
return 1;
}... | 1 |
#include <pthread.h>
pthread_cond_t conditionVar;
pthread_mutex_t mutex;
void *thread1CallBack(void *arg) {
pthread_mutex_lock(&mutex);
printf("hello\\n");
pthread_cond_wait(&conditionVar, &mutex);
int *tmp = (int *)arg;
printf("thread 1 is runing\\n");
printf("thread 1 get ... | 0 |
#include <pthread.h>
int q[5];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 5)
... | 1 |
#include <pthread.h>
int thread_count;
pthread_mutex_t mutex;
double sum = 0;
int n = 1024;
void * threadSum (void * rank){
long my_rank = (long) rank;
double factor;
long long i;
long long myN = n/thread_count;
long long myFirstI = myN * my_rank;
long long myLastI = myFir... | 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 loop = (int)(*((int*)arg));
while(loop-- >0){
pthread_mutex_lock(&mtx1);
pthread_mutex_lock... | 1 |
#include <pthread.h>
int global_int;
pthread_mutex_t lock;
pthread_cond_t cond;
void *fn_1(void *args){
pthread_mutex_lock(&lock);
while(global_int != 999)
pthread_cond_wait(&cond, &lock);
printf("fn1: read global_int: %d\\n", global_int);
global_int++;
printf("fn1:... | 0 |
#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... | 1 |
#include <pthread.h>
PROCESS process;
void* arg;
struct worker *next;
}CThread_worker;
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker * queue_head;
pthread_t *threadid;
int max_threads;
int cur_queue_len;
int shutdown;
}CThread_pool;
static CThread_pool ... | 0 |
#include <pthread.h>
static volatile int run_flag = 1;
pthread_mutex_t m ;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
pthread_cond_t w = PTHREAD_COND_INITIALIZER;
int done=0;
int sent=1;
float pitch_buffer[151];
float roll_buffer[151];
float avg_val[2]={0,0};
void do_when_interrupted()
{
ru... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int sum=0;
void* p_func(void* p)
{
int i;
pthread_mutex_lock(&mutex);
pthread_mutex_lock(&mutex);
printf("I am child\\n");
pthread_mutex_unlock(&mutex);
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
int main()
{
int ret;
pthread_mutexattr_t ... | 0 |
#include <pthread.h>
int CADEIRAS;
int TIMEWAIT_MAX;
volatile int running = 1;
pensar,
fome,
comer,
} Filosofos;
void rel(int filosofo, int comeu,int pensou,int tentou);
int Filosofos_esquerda(int filo_n);
int Filosofos_direita(int filo_n);
void *Filosofos_checkin(void *filo);
pthr... | 1 |
#include <pthread.h>
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_num = PTHREAD_COND_INITIALIZER;
static int num = 0;
static int next(int a)
{
if (a + 1 == 4)
return 0;
return a + 1;
}
void *thr_func(void *arg)
{
int i = (int)arg;
char ch = i + '... | 0 |
#include <pthread.h>
int somme_val=0;
int nbre_thread=0;
int signal_envoye=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
void *print_thread(){
pthread_mutex_lock(&mutex);
if(signal_envoye==0){
pthread_cond_wait(&cond, &mutex);
}
prin... | 1 |
#include <pthread.h>
struct socket_context* incoming_queue;
struct socket_context* output_list;
struct socket_context* storage_cache;
int add(struct socket_context* storage, struct socket_context* sc);
struct socket_context* find(struct socket_context* storage, int sock);
pthread_mute... | 0 |
#include <pthread.h>
pthread_cond_t sem;
pthread_mutex_t read;
pthread_mutex_t write;
pthread_mutex_t count;
int sem_count = 0;
int sem_b = 0;
int isWriteReady = 0;
int data = 1;
void CreateSemaphore()
{
if(pthread_cond_init(&sem, 0) != 0)
{
printf("Semaphore creation failed\\n");
exit(0... | 1 |
#include <pthread.h>
struct msg{
char *str;
int row;
int delay;
int dir;
};
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
int setup(int strnum, char *strings[], struct msg msgs[])
{
int i;
int num_msg = (strnum > 10 ? 10 : strnum);
for(i = 0; i < strnum; i++){
msgs[i].str = strings... | 0 |
#include <pthread.h>
struct iSharePrivate
{
unsigned char destroy;
pthread_mutex_t token;
char * shm_pointer;
};
int iShare_Init(struct iShare * iShare)
{
key_t key;
int shmflg;
int shmid;
int size;
char * shm;
struct iSharePrivate * private_struct;
key = iShareGetSHMKey(*iSh... | 1 |
#include <pthread.h>
int eye_update_interval = 50;
int smallest_head;
float smallest_val;
bool eye_terminate = 0;
bool ball_inside = 0;
pthread_mutex_t nav_mutex;
pthread_t eye_tid;
void reset_value(){
smallest_head = 0;
smallest_val = 9999.0;
}
void * eye_check(){
int detected_col... | 0 |
#include <pthread.h>
int server_running;
pthread_t *ping_threads;
pthread_t serverthread;
char *dev;
void *ping_thread(void *arg)
{
if (arg != 0)
{
struct cfgData *data = (struct cfgData *)arg;
if (data->status == tUp)
{
if (ping(&data->ip) != 0)
... | 1 |
#include <pthread.h>
void* task(void* argument);
int var=0;
int max= -2147483647;
int min= +2147483647;
pthread_mutex_t lock;
int main(void)
{
pthread_mutex_init(&lock,0);
pthread_t threads[8];
int threadArgs[8];
int t;
for(t=0; t<8; t++ ){
threadArgs[t]= t;
p... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
int count = 0;
int task[3];
void *consumer(void *arg)
{
for (;;)
{
int num;
pthread_mutex_lock(&mutex);
if (count > 0)
{
count--;
num = task[count];
printf("Consumer processed item: %d\\n", num);
}
pthread_... | 1 |
#include <pthread.h>
int n, C, T, N;
FILE* fout;
char* out;
pthread_t car;
pthread_t passenger[10];
pthread_mutex_t mutex;
int passenger_time[10] = {0};
int car_time = 0;
int on_board[10] = {0};
int on_board_count = 0;
int ending = 0;
sem_t queue, checkin, boarding, riding, unloading;
void* Pa... | 0 |
#include <pthread.h>
extern pthread_mutex_t __sfp_mutex;
extern pthread_cond_t __sfp_cond;
extern int __sfp_state;
int __swalk_sflush()
{
register FILE *fp, *savefp;
register int n, ret, saven;
register struct glue *g, *saveg;
pthread_mutex_lock(&__sfp_mutex);
__sfp_state++;
pthread_mutex_... | 1 |
#include <pthread.h>
int fin_fd;
size_t entry_count;
int fin_new(char* filename){
mode_t mode=S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH;
int fd=open(filename,O_RDWR|O_CREAT|O_EXCL,mode);
if (fd==-1){
perror("create fin:");
return -1;
}
fin_fd=fd;
entry_count=0;
return fd;
}
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.