text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct product_cons
{
int buffer[5];
pthread_mutex_t lock;
int readpos,writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
}buffer;
void init(struct product_cons *p)
{
pthread_mutex_init(&p->lock,0);
pthread_cond_init(&p->notempty,0);
pthread_cond_ini... | 1 |
#include <pthread.h>
int is_prime[1000000];
int TCOUNT=0, COUNT_LIMIT=0;
int count = 0, latest_prime = 2;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void set_up_primetable () {
int i, j;
for (i=0; i<1000000; i++)
is_prime[i] = 1;
is_prime[0] = is_prime... | 0 |
#include <pthread.h>
{
int *arr, *ret, l, r;
pthread_mutex_t *mutex;
} ds_pthread;
void pthread_diff(void *ps)
{
int idx_i, local = 0;
ds_pthread *p = (ds_pthread *) ps;
for(idx_i = p->l + 1; idx_i <= p->r; idx_i++)
local += (p->arr)[idx_i] - (p->arr)[idx_i - 1];
pthread_... | 1 |
#include <pthread.h>
struct thread_data {
int t_index;
};
int global_count = 0;
pthread_t thread_id[10];
pthread_mutex_t cnt_mutex;
pthread_cond_t cnt_cond;
void *thread_start_A(void *param)
{
struct thread_data *t_param = (struct thread_data *) param;
int tid = (*t_param).t_ind... | 0 |
#include <pthread.h>
pthread_cond_t vacio, lleno;
pthread_mutex_t lock;
int array[10];
int n_elementos=0;
void * productor();
void * consumidor();
int main(int argc, char ** argv){
srand(time(0));
int i;
pthread_mutex_init(&lock, 0);
pthread_cond_init(&vacio, 0);
pthread_cond_init... | 1 |
#include <pthread.h>
struct account{
int balance;
int credits;
int debits;
pthread_mutex_t lock;
};
struct account accounts[10];
void * transactions(void * args){
int i,v;
int a1,a2;
for(i=0;i<100;i++){
v = (int) random() % 100;
a1 = (int) random() % 10;
w... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t people_garden = PTHREAD_COND_INITIALIZER;
long int size = 0;
void update_garden() {
int i, random1, random2;
for (i = 0; i < 100; i++) {
pthread_mutex_lock(&mutex);
if (size == 1000) {
... | 1 |
#include <pthread.h>
int MAX_CUPCAKES = 10;
int total_cupcakes = 5;
pthread_mutex_t cupcake_lock = PTHREAD_MUTEX_INITIALIZER;
void *bakery();
void *producer();
void *consumer();
bool check = 1;
int main()
{
pthread_t bakery_thread;
pthread_create(&bakery_thread, 0, bakery, 0);
pthread_join... | 0 |
#include <pthread.h>
static struct rimage *wait_for_image(struct wthread *wt)
{
return get_rimg_by_name(wt->snapshot_id, wt->path);
}
uint64_t forward_image(struct rimage *rimg)
{
uint64_t ret;
int fd = proxy_to_cache_fd;
pthread_mutex_lock(&(rimg->in_use));
pr_info("Forwarding %s:%s (%lu ... | 1 |
#include <pthread.h>
void *producer (void *args);
void *consumer (void *args);
int buf[10];
long head, tail;
int full, empty;
pthread_mutex_t *mut;
pthread_cond_t *notFull, *notEmpty;
} queue;
queue *queueInit (void);
void queueDelete (queue *q);
void queueAdd (queue *q, int in);
void q... | 0 |
#include <pthread.h>
struct data {
int tid;
char buffer[100];
} tdata1, tdata2;
pthread_mutex_t lock1;
pthread_mutex_t lock2;
pthread_cond_t cond1;
pthread_cond_t cond2;
int mySharedCounter = 0;
int go1 = 0;
int go2 = 0;
void helper(void *tdata, pthread_mutex_t *l1, pthread_cond_t *c1, in... | 1 |
#include <pthread.h>
int bufer[10], contador[10];
sem_t full[3], empty;
pthread_mutex_t ex_buf = PTHREAD_MUTEX_INITIALIZER,
ex_cont = PTHREAD_MUTEX_INITIALIZER;
int
main (void)
{
int i;
extern sem_t full[3], empty;
extern int contador[10];
pthread_t consumidor[3], productor;
int... | 0 |
#include <pthread.h>
PENSANDO, HAMBRIENTO, COMIENDO
} status;
status estado[5];
sem_t mutex, s[5];
pthread_cond_t no_comida;
pthread_mutex_t cmutex;
int comida = 0;
void Pensar(int);
void Comer(int);
void CogerTenedores(int);
void SoltarTenedores(int);
void Comprobar(int);
void *Cocine... | 1 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
int i = 0;
void *
fn1(void *arg) {
pthread_t tid = pthread_self();
printf("thread1 %lu\\n", tid);
while (1) {
sleep(1);
printf("loop in thread1\\n");
pthread_mutex_lock(&mutex);
pthread_con... | 0 |
#include <pthread.h>
int thread_flag;
pthread_cond_t thread_flag_cv;
pthread_mutex_t thread_flag_mutex;
void initialize_flag()
{
pthread_mutex_init(&thread_flag_mutex, 0);
pthread_cond_init(&thread_flag_cv, 0);
thread_flag = 0;
}
void do_work()
{
printf("hello\\n");
}
void* thread... | 1 |
#include <pthread.h>
struct timespec ts;
pthread_mutex_t chopstick_mutex[5];
pthread_cond_t chopstick_conds[5];
int philo_states[5];
int phil_to_chopstick(int phil_id, direction_t d){
return (phil_id + d) % 5;
}
int chopstick_to_phil(int stick_id, direction_t d){
return (stick_... | 0 |
#include <pthread.h>
union mynum {
long long longlong;
double flonum;
};
int nthreads;
int pleasequit=0;
long long maxiterations=0;
pthread_barrier_t barrier;
pthread_mutex_t maxiter_mutex=PTHREAD_MUTEX_INITIALIZER;
void * calculate(void *param) {
double localpi=0.0;
... | 1 |
#include <pthread.h>
{
float alpha1;
float alpha2;
float beta0;
float beta1;
float beta2;
} parameters;
parameters fastFilter;
pthread_mutex_t paramMutex;
void* fastFilterThread(void*);
void* slowFilterThread(void*);
int main( void )
{
pthread_t fastFilterThreadID;
pthread... | 0 |
#include <pthread.h>
pthread_mutex_t verrou = PTHREAD_MUTEX_INITIALIZER;
int IMAGE[10];
int QuelThreadTravail[10];
struct data {
int i;
}data;
void * Travail(void *par){
sleep(rand()%5);
struct data *mon_D1 = (struct data*)par;
pthread_t moi=pthread_self();
if(mon_D1->i==1){
pri... | 1 |
#include <pthread.h>
int kbhit(void)
{
struct termios oldt, newt;
int ch;
int oldf;
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
fcntl(STDIN_FILENO, F_SETFL, oldf... | 0 |
#include <pthread.h>
pthread_mutex_t buffer_mutex;
int fill = 0;
char buffer[100][50];
char *fetch(char *link) {
int fd = open(link, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "failed to open file: %s", link);
return 0;
}
int size = lseek(fd, 0, 2);
assert(size >= 0);
char ... | 1 |
#include <pthread.h>
struct async_waitlist
{
int counter;
struct sigevent sigev;
struct waitlist list[0];
};
int
getaddrinfo_a (int mode, struct gaicb *list[], int ent, struct sigevent *sig)
{
struct sigevent defsigev;
struct requestlist *requests[ent];
int cnt;
volati... | 0 |
#include <pthread.h>
int msglevel = LOG_INFO;
FILE *log_file = 0;
void pmesg(int level, const char *source, long int line_number, const char *format, ...)
{
va_list args;
char log_type[10];
int new_msglevel = msglevel % 10;
if (level > new_msglevel)
return;
switch (level) {
case... | 1 |
#include <pthread.h>
struct cl_listener *cl_listener_alloc()
{
struct cl_listener *p = smalloc(
sizeof(struct cl_listener), cl_listener_free);
cl_listener_init(p);
return p;
}
void cl_listener_init(struct cl_listener *p)
{
INIT_LIST_HEAD(&p->head);
... | 0 |
#include <pthread.h>
struct data {
long counter[256];
};
const int SIZE = sizeof(struct data);
static pthread_mutex_t output_mutex;
static struct data data;
void *run(void *raw_name) {
time_t thread_start = time(0);
char *name = (char *) raw_name;
int fd = -1;
time_t ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex[5];
void* philosopher(void* arg)
{
int *number;
number=(int*) arg;
while(1)
{
int result=0;
sleep(1);
printf("philosopher %d is thinking\\n",*number );
sleep(1);
pthread_mutex_lock(&mutex[*number]);
result=pthread_mutex_trylock... | 0 |
#include <pthread.h>
double* A;
double* B;
double produto_escalar = 0;
int id;
} TArgs;
pthread_mutex_t s;
void* trabalhador(void* args){
TArgs* arg = (TArgs*) args;
int id = arg->id;
int inicio, fim, i;
double soma;
inicio = id*(6/2);
fim = inicio + (... | 1 |
#include <pthread.h>
static pthread_mutex_t mtxCpt;
static FILE* f;
static pthread_mutex_t mtxAffichage;
static int get_prime_factors(uint64_t n,uint64_t* factors)
{
uint64_t i;
int nb_factors=0;
if(n!=1)
{
uint64_t fin = n;
for( i=2 ; i<=fin && n!=1 ; i++)
{
while(n%i == 0)
{
... | 0 |
#include <pthread.h>
int* contador;
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
void* Contagem(void* arqid){
int input, fid = *((int *)arqid);
FILE* f;
char FileName[10];
sprintf(FileName,"%d.in",fid);
f = fopen(FileName,"rt");
do{
input = -1;
fscanf(f," %d",&input);
if(input ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_in_circle;
int in_circle = 0;
void* calculate_PI(void* arg) {
int i, in_circle_loc = 0;
double x, y, point;
int *p = (int*)arg;
for(i = 0; i < *p; i++) {
x = (double)rand() / 32767;
y = (double)rand() / 32767;
point = x*x + y*y;
if (point... | 0 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *
foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) != 0) {
f... | 1 |
#include <pthread.h>
int somme;
pthread_mutex_t mutex_somme = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_cond = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int cpt = 0;
pthread_t tid[10];
pthread_t tid2;
void* affiche(){
pthread_cond_wait(&cond,&mutex_cond);... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lockAir = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condTravelers=PTHREAD_COND_INITIALIZER,condAirPlane=PTHREAD_COND_INITIALIZER,condTravelersDis = PTHREAD_COND_INITIALIZER;
int nrOfTrav=0;
int N,MAX;
void *tra... | 1 |
#include <pthread.h>
pthread_mutex_t counter_mutex;
int counter = 0;
char *file_list[] = {"10G.data1","10M.data1","10G.data2","10M.data2","10G.data3","10M.data3","10G.data4","10M.data4","10G.data5","10M.data5","10G.data6","10M.data6","10G.data7","10M.data7","10G.data8","10M.data8","10G.da... | 0 |
#include <pthread.h>
pthread_mutex_t buflock;
static char mt_cmd[1000], mt_result[1000];
int read_ok=0;
pthread_cond_t cond_read_ok;
pthread_mutex_t lock_read_ok;
int parent_mt( void )
{
while(1){
char result[1000];
char *p = readline( "aho>" );
if( p ==0 )exit(0)... | 1 |
#include <pthread.h>
int global_variable_count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void* IncrementVariable(void *id)
{
int i;
int threadID = (int)id;
printf("Starting IncrementVariable(): thread %d\\n", threadID);
for (i=0; i < 5; i++) {
... | 0 |
#include <pthread.h>
int x, N, n = 0;
float xN, factN, resultado = 0.0;
pthread_mutex_t tomar, poner;
void *calculaXN ();
void *calculaFactN ();
int main(int argc, char *argv[])
{
int i;
pthread_t hilo_productor, hilo_consumidor;
printf("\\n\\t\\tEste programa calcula el valor de e^x\\n\\n")... | 1 |
#include <pthread.h>
static void process_function_actual(int job_type);
static int process_judege(struct Job *job);
static void *process_function(void*);
static int hash_index;
static int get_user_pass(const int len, const char *source)
{
const char *pointer = source;
int ret, new_len = len;... | 0 |
#include <pthread.h>
{
int row_num;
int col_num;
int luggage;
} tag;
tag collection_box[4 * 9];
pthread_mutex_t ticket_lock = PTHREAD_MUTEX_INITIALIZER;
void create_a_tag(int col, int row)
{
static int count = 0;
collection_box[count].col_num = col;
collection_box[count].row_num = row;
... | 1 |
#include <pthread.h>
extern int global_port;
extern int max_slave_server;
static int active_ports=0;
void push_thread(struct threadID * temp_thread)
{
pthread_mutex_lock(&mutex_variable);
if(thread_header==0)
{
thread_header=temp_thread;
thread_header->next=0;
}
else
{
temp_thread-... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
int my_id = (int)t;
for (i=0; i < 10; i++)
{
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12)
... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc,condp;
int buffer=0;
void *producer(void* ptr)
{
int i;
for(i=1;i<=10000;i++)
{
pthread_mutex_lock(&the_mutex);
while(buffer != 0)
{
pthread_cond_wait(&condp,&the_mutex);
}
buffer = i;
printf("producer:%d\\n"... | 0 |
#include <pthread.h>
struct job {
struct job* next;
int num;
};
struct job* job_queue;
struct job* tail;
void print_list(struct job * job_list){
int i;
i=1;
struct job* aux = job_queue;
while(aux != 0){
printf("%d) %d\\n",i,aux->num);
aux = aux->next;
i++;
}
}
char* is_prime(int ... | 1 |
#include <pthread.h>
struct rwlock_t
{
pthread_mutex_t rdlock;
int count;
pthread_mutex_t wrlock;
};
int my_rwlock_init(struct rwlock_t *rwlock)
{
pthread_mutex_init(&rwlock->rdlock);
rwlock->count = 0;
pthread_mutex_init(&rwlock->wrlock);
return 0;
}
int my_rwloc... | 0 |
#include <pthread.h>
bool packet_queue_init(struct ff_packet_queue *q)
{
memset(q, 0, sizeof(struct ff_packet_queue));
if (pthread_mutex_init(&q->mutex, 0) != 0)
goto fail;
if (pthread_cond_init(&q->cond, 0) != 0)
goto fail1;
av_init_packet(&q->flush_packet.base);
q->flush_packet.base.... | 1 |
#include <pthread.h>
static int _sd;
static pthread_mutex_t sd_mutex;
void init_gui_trans(int sd){
int val = 1;
ioctl(sd, FIONBIO, &val);
pthread_mutex_init(&sd_mutex,0);
_sd = sd;
}
void gui_send(int x,int y){
int buf[2];
buf[0] = x; buf[1] = y;
pthread_mutex_lock... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int counter = 0;
int lagerGrosse = 10;
int itemBuffer[10];
void producer(void *ptr);
void consumer(void *ptr);
void insertItem(int item);
void removeItem(int *item);
void producer(void *tid)
{
while(1)
{
int event;
scanf("%d",&... | 1 |
#include <pthread.h>
int key, value;
struct __node_t * next;
} node_t;
node_t * head;
pthread_mutex_t lock;
pthread_mutexattr_t __lock_attr;
} list_t;
void list_init(list_t *lst) {
lst->head = 0;
Pthread_reentrant_mutex_init(&lst->lock, &lst->__lock_attr);
}
int li... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_barrier_t barrier;
int flag =0 ;
void * pthread_a(void *arga){
fprintf(stderr ,"start a barrier\\n");
pthread_barrier_wait (&barrier);
fprintf(stderr,"1 - flag a ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int thread_num;
int* counter;
pthread_t *thread;
int *mem = 0;
int sum = 0;
int itr = 1024 / 16;
void external_calculate(void* arg) {
int i = 0, j = 0, k = 0;
int n = *((int*) arg);
for (k = n; k < 10; k += thread_num) {
char a[3]... | 0 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queu... | 1 |
#include <pthread.h>
static int vvprintf_init = 0;
static pthread_mutex_t vvprintf_mutex = PTHREAD_MUTEX_INITIALIZER;
static char msgbuf[1024*10];
static int vvprintf_socket;
static struct sockaddr_in vvprintf_serveraddr;
int vvprintf(const char *format,...)
{
va_list myargs;
__builtin_va_st... | 0 |
#include <pthread.h>
int arreglo[100000];
int total=0;
int indice=0;
pthread_mutex_t m1;
pthread_mutex_t m2;
void *PrintHello(void *threadid){
int *id_ptr, taskid;
int miIndice;
int parcial=0;
id_ptr = (int *) threadid;
taskid = *id_ptr;
while(indice < 100000){
pthread... | 1 |
#include <pthread.h>
void increase_actors(struct notifyfshm_directory_struct *directory)
{
struct notifyfshm_lock_struct *lock=0;
if (directory->shared_lock==(unsigned short) -1) {
lock=notifyfshm_malloc_lock();
if (lock) directory->shared_lock=lock->index;
} else {
l... | 0 |
#include <pthread.h>
pthread_mutex_t output_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t watchdog_thread;
unsigned int watchdog_tick = 1;
bool running = 0;
void c_output(const char *format, ...)
{
if (!running)
return;
pthread_mutex_lock(&output_mutex);
va_list args;
__builtin_va_sta... | 1 |
#include <pthread.h>
int shared = 5;
pthread_mutex_t lock;
void sendreply(int replyfrompno,int replytopno,int ts)
{
FILE *ptr;
if(replytopno==1)
{
ptr = fopen("file1.txt","a");
}
if(replytopno==2)
{
ptr = fopen("file2.txt","a");
}
if(replytopno==3)
{
ptr = fopen("file3.txt","a");
}... | 0 |
#include <pthread.h>
pthread_mutex_t *mutex_init(){
pthread_mutex_t *m = calloc(1, sizeof(*m));
pthread_mutex_init(m, 0);
return m;
}
void mutex_destroy(pthread_mutex_t *mutex){
free(mutex);
}
void mutex_lock(pthread_mutex_t *mutex){
if (mutex == 0) return;
pthread_mute... | 1 |
#include <pthread.h>
struct stack {
char x[65535];
};
static pthread_mutex_t mutex[(503)];
static int data[(503)];
static struct stack stacks[(503)];
static void* thread(void *num)
{
int l = (int)(uintptr_t)num;
int r = (l+1) % (503);
int token;
while(1) {
pthread_mutex_... | 0 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static void *thr_primer(void *p);
int main()
{
int i,j,mark;
int err;
pthread_t tid[4];
for(i = 0; i < 4 ; i++)
{
err = pthread_create(tid+i,0,thr_primer,(void *)i);
if(err)
{
... | 1 |
#include <pthread.h>
int voti[5];
int votazioni_terminate[5];
pthread_mutex_t mutex_voti[5];
void inizializza_voti() {
int i;
for (i = 0; i < 5; i++) {
voti[i] = 0;
votazioni_terminate[i] = 0;
}
}
void inizializza_mutex_voti() {
int i;
for (i = 0; i < 5; i++) {
pthread_mut... | 0 |
#include <pthread.h>
pthread_mutex_t g_mutex;
pthread_cond_t g_cond;
char buf[5];
int count;
} buffer_t;
buffer_t g_share = {"", 0};
char g_ch = 'A';
void* producer( void *arg )
{
printf( "Producer starting.\\n" );
while( g_ch != 'Z' ) {
pthread_mutex_lock( &g_mutex );
... | 1 |
#include <pthread.h>
int id;
double a;
double b;
double step;
} job;
double result = 0;
pthread_mutex_t lock;
void* calc(void *args);
int main(int argc, char** argv)
{
assert(argc == 3);
int p = atoi(argv[1]);
int n = atoi(argv[2]);
assert(p > 0);
assert... | 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,offset,len;
double mysum,*x,*y;
offset=(int)arg;
len=dotstr.veclen;
start = offset*le... | 1 |
#include <pthread.h>
char _getch()
{
struct termios old, new;
char ch;
tcgetattr(0, &old);
new = old;
new.c_lflag &= ~(ICANON | ECHO);
tcsetattr(0, TCSANOW, &new);
ch = getchar();
tcsetattr(0, TCSANOW, &old);
return ch;
}
void* printThreads(void* data_temp)
{
struct Data data;
data = ... | 0 |
#include <pthread.h>
int busy = 0;
int waiting = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t OKtoread = PTHREAD_COND_INITIALIZER;
pthread_cond_t OKtowrite = PTHREAD_COND_INITIALIZER;
int readercount = 0;
void readerStart(){
pthread_mutex_lock(&mutex);
if (busy == 1){
... | 1 |
#include <pthread.h>
char *pbs_geterrmsg(
int connect)
{
char *errmsg;
if ((connect < 0) || (connect > PBS_NET_MAX_CONNECTIONS))
{
return(0);
}
pthread_mutex_lock(connection[connect].ch_mutex);
errmsg = connection[connect].ch_errtxt;
pthread_mutex_unlock(connection... | 0 |
#include <pthread.h>
int NUM_INT;
int BUFFER_SIZE;
int NUM_PROD;
int NUM_CON;
int counter = 0;
int *buffer;
int *pid;
int *cid;
int buf_index = -1;
int ctotal = 0;
int cnum;
sem_t spaces;
sem_t items;
pthread_mutex_t prod_mutex;
pthread_mutex_t con_mutex;
pthread_mutex_t buffer_mutex;
struc... | 1 |
#include <pthread.h>
void *createplane(void *args);
void startlanding (int pno, int rno);
int pno;
int arrived;
pthread_t tid;
int fcap;
int emeflag;
int p;
int landflag;
}plane;
int number;
int occupied;
}runwayst;
pthread_mutex_t runway;
pthread_mutex_t runway2;
pthread_mutex_t runwa... | 0 |
#include <pthread.h>
int main()
{
pthread_mutex_t mutex;
int rc;
if((rc=pthread_mutex_init(&mutex,0)) != 0) {
fprintf(stderr,"Error at pthread_mutex_init(), rc=%d\\n",rc);
return PTS_UNRESOLVED;
}
if((rc=pthread_mutex_lock(&mutex)) == 0) {
pthread_mutex_unlock(&mutex);
printf("Tes... | 1 |
#include <pthread.h>
int mediafirefs_chown(const char *path, uid_t uid, gid_t gid)
{
printf("FUNCTION: chown. path: %s\\n", path);
(void)path;
(void)uid;
(void)gid;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pthread_mutex_loc... | 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;
struct cha... | 1 |
#include <pthread.h>
int sharedByteRead = 0;
int sharedTotalCount = 0;
FILE *fp;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
{
int thread_no;
} tname;
int string_search(char *data, int length, char *target)
{
int i;
int f... | 0 |
#include <pthread.h>
struct List *list = 0;
pthread_mutex_t stdoutLock;
void lockstdout (void) {
pthread_mutex_lock(&stdoutLock);
}
void unlockstdout (void) {
pthread_mutex_unlock(&stdoutLock);
}
void printMsg (int id, char *msg) {
lockstdout();
printf("Thread %d: %s\\n",id,msg... | 1 |
#include <pthread.h>
int parse_data(char *data, char u_name[], char password[])
{
char *p;
p=strchr(data, '=');
if(p == 0)
return -1;
strncpy(u_name, data, p-data);
u_name[p-data]='\\0';
strcpy(password, p+1);
return 0;
}
int user_reg(int connfd, char *data)
{
FILE *f;
char *p;
char... | 0 |
#include <pthread.h>
char *head, *tail;
pthread_cond_t cond;
pthread_mutex_t m;
volatile int le_lock;
void *probably_malloc(long n) {
void *x = mmap(0, n, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, 0 ,
0);
if (x == MAP_FAILED) {
fprintf(stderr, "mmap failed %ld %d %d\\n", n, x, err... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static size_t i_gloabl_n = 0;
void *thr_demo(void *args)
{
printf("this is thr_demo thread, pid: %d, tid: %lu\\n", getpid(), pthread_self());
pthread_mutex_lock(&mutex);
int i;
int *pa = (int *)args;
size_t tid = pth... | 0 |
#include <pthread.h>
static pthread_mutex_t gtw_next_lock;
static void *
worker_function(void *thread_data)
{
(void)thread_data;
while (1) {
void* run_data;
pthread_mutex_lock(>w_next_lock);
run_data = gtw_next();
pthread_mutex_unlock(>w_next_lock);
... | 1 |
#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;
sigset_t peing;
printf("thr_fn sleep(10) to ready pengingset\\n");
sleep(10);
for(;;){
... | 0 |
#include <pthread.h>
int source[7];
int minBound[2];
int maxBound[2];
int channel[2];
int th_id = 0;
pthread_mutex_t mid;
pthread_mutex_t ms[2];
int findmin (int x, int y)
{
int idx = -1;
int val = source[x];
for (int i = x+1; i < y; i++)
{
if (val > source[i])
{
idx... | 1 |
#include <pthread.h>
int state[5];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutexattr_t attr;
void think(int i);
void take_forks(int i);
void eat(int i);
void put_forKs(int i);
int test(int i);
void *philosopher(void *i);
void *philosopher(void *i)
{
int *num=(int *)i;
thi... | 0 |
#include <pthread.h>
func_malloc _origin_malloc;
func_free _origin_free;
pthread_mutex_t lock_foot;
void* origin_malloc(size_t size) {
assert(_origin_malloc);
return _origin_malloc(size);
}
void origin_free(void *ptr) {
assert(_origin_free);
return _origin_free(ptr);
}
int isFootInit = ... | 1 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mut;
int number=0, i;
void *ptr;
void *thread1()
{
printf ("thread1 : I'm thread 1\\n");
void *aa = malloc(128);
free(ptr);
for (i = 0; i < 10; i++)
{
printf("thread1 : number = %d\... | 0 |
#include <pthread.h>
static struct hosts_info hosts_ = {{0, 0}, -1, 0, 0, ""};
static char *path_hosts_ = 0;
static pthread_mutex_t hosts_mutex_ = PTHREAD_MUTEX_INITIALIZER;
int hosts_file_modified_r(struct timespec *ts)
{
struct stat st;
log_debug("checking if file \\"%s\\" was modifie... | 1 |
#include <pthread.h>
int g1, g2, g3;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
void *t1(void *arg) {
pthread_mutex_lock(&mutex1);
pthread_mutex_lock(&mutex2);
g1 = g2 + 1;
pt... | 0 |
#include <pthread.h>
long module_tick_ts_diff(struct timespec *ts_a, struct timespec *ts_b)
{
long nsec = (ts_a->tv_nsec - ts_b->tv_nsec);
nsec += (ts_a->tv_sec - ts_b->tv_sec)*1000000000;
return nsec;
}
void module_tick_master_upd_out(struct module_tick *list)
{
struct modu... | 1 |
#include <pthread.h>
void *functionA();
void *functionB();
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
main(){
pthread_t thread1, thread2, thread3;
int rc1, rc2, rc3;
printf("\\033[2J");
printf("\\033[%d;%dH", 0 ,0);
printf("THREAD ONE\\n");
printf("===... | 0 |
#include <pthread.h>
pthread_t tid[2];
pthread_mutex_t lock;
sem_t done_filling_list;
sem_t filling_list;
extern void Sim808_GPS_GSM_Module_Power();
extern int sendGPSData() ;
extern int receiveGPSData() ;
void* gpsDataReceiverTask(void *arg)
{
unsigned long i = 0;
pthread_t id = pthrea... | 1 |
#include <pthread.h>
pthread_t atendentes [5];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
int filas_vazias=5;
pthread_t gclientes;
int clientes=50;
int clientes_atendidos=0;
int fil... | 0 |
#include <pthread.h>
pthread_mutex_t max_mutex = PTHREAD_MUTEX_INITIALIZER;
float max_temp = -1;
void * registerTemperature(void *arg) {
float temp = *((float*)arg);
free(arg);
pthread_mutex_lock(&max_mutex);
if(temp > max_temp) {
printf("Server: updating maximum tem... | 1 |
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 6