text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t non_full;
pthread_cond_t non_empty;
int elemsInQueue;
int maxSize;
int countElems;
int id;
void argsNotValid(){
fprintf(stderr, "[ERROR][process_manager] Arguments not valid.\\n");
}
void errorInPM(int id){
fprintf(stderr,"[ERR... | 1 |
#include <pthread.h>
struct dmove {
int src;
int dst;
};
static pthread_mutex_t m;
struct record {
struct dmove *moves;
int capacity;
int size;
int pos;
int forward;
};
struct record *record_create(int capacity)
{
struct record *l = malloc(sizeof(st... | 0 |
#include <pthread.h>
struct releve {
char dateTime[sizeof "JJ/MM/AAAA HH:MM:SS"];
int temperature;
} releve;
time_t now;
struct tm tm_now;
pthread_t tacheReleve,tacheR1;
pthread_attr_t tacheReleve_attr,tacheR1_attr;
sem_t semR1;
pthread_mutex_t mutexReleve;
struct releve rel;
FILE... | 1 |
#include <pthread.h>
static
void init_notification_thread_command(struct notification_thread_command *cmd)
{
memset(cmd, 0, sizeof(*cmd));
CDS_INIT_LIST_HEAD(&cmd->cmd_list_node);
lttng_waiter_init(&cmd->reply_waiter);
}
static
int run_command_wait(struct notification_thread_handle *handle,
... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5] ;
void *sim(void *p)
{
int i = (int)p;
while(1)
{
printf("Philosopher %d is hungry\\n",i);
if(i == 4)
{
pthread_mutex_lock(&forks[0]);
printf("Philosopher %d taking right fork\\n",i);
sleep(1);
... | 1 |
#include <pthread.h>
extern int random_utime(void);
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t status;
int activity[5];
int activity_counter_eat[5];
enum {
THINK,
HUNGRY,
EAT
} state_t;
void pick_fork(int* id)
{
pthread_mutex_lock(&mutex);
activity[*id] = HU... | 0 |
#include <pthread.h>
void *thread_work(void* arg){
DBG_PRINT("thread_work ----------------- %s\\n",arg);
char thread_name[MAX_NAME_LEN];
strcpy(thread_name,arg);
while(1)
{
struct msgQueue_msg* msg = 0;
struct msgQueue * mq ;
mq = gMsgQueue_get_msgQueue();
if(mq!=0){
msg = msgQue... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t lock;
void *threadFunc(void *arg)
{
pthread_mutex_lock(&lock);
printf("Acquired lock!\\n");
char *str;
str=(char*)arg;
const char *cmd = "sudo gatttool -b C4:4F:B7:B1:41:D7 --char-write-req --handle=0x000f --value=0100 --lis... | 0 |
#include <pthread.h>
static void write_cancel(void*);
static void read_cancel(void*);
void rw_init(struct rwlock *L) {
L->readers_active = 0;
L->readers_wait = 0;
L->writers_wait = 0;
L->writers_active = 0;
pthread_mutex_init(&L->mutex, 0);
pthread_cond_init(&L->read, 0);
pthread_cond_... | 1 |
#include <pthread.h>
int a=0;
pthread_mutex_t lock;
void *func1(void *arg)
{
pthread_mutex_lock(&lock);
a=1;
sleep(1);
printf("%s-%d\\n",__func__,a);
pthread_mutex_unlock(&lock);
}
void *func2(void *arg)
{
pthread_mutex_lock(&lock);
a=2;
printf("%s-%d\\n",__func__,a);
pthread_mutex_unlock... | 0 |
#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("Clean up handler of second thread.\\n");
free(arg);
(... | 1 |
#include <pthread.h>
extern void __VERIFIER_error() ;
int __VERIFIER_nondet_int(void);
void ldv_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
pthread_t t1;
pthread_mutex_t mutex;
int pdev;
void *thread1(void *arg) {
pthread_mutex_lock(&mutex);
pdev = 6;... | 0 |
#include <pthread.h>
{
pthread_cond_t c;
pthread_mutex_t m;
}cond_mutex_t;
cond_mutex_t cm =
{
PTHREAD_COND_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER
};
static void * wait_thread(void * param);
static void * worker_thread(void * param);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
st... | 1 |
#include <pthread.h>
struct Thread *threads = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int JobCount = 0;
static struct Job * head = 0;
static struct Job * tail = 0;
static int threadStatus = 0;
void InitThreads... | 0 |
#include <pthread.h>
enum {sta_chk = 1, sta_err, sta_ter, sta_rd, sta_rec, sta_wr, sta_eof};
static int fd_sock = -1;
static int stop = 0;
static FILE *msg_fp = 0;
static pthread_mutex_t rec_mut = PTHREAD_MUTEX_INITIALIZER;
static int resend = 0;
static int time_to_exit = TIME_TO_EXIT;
static in... | 1 |
#include <pthread.h>
void pc_shift_left(void *not_used){
pthread_barrier_wait(&threads_creation);
int pc_temp;
while(1)
{
pthread_mutex_lock(&control_sign);
if(!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait,&control_s... | 0 |
#include <pthread.h>
int n = 100;
pthread_cond_t sig1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t sig2 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut2 = PTHREAD_MUTEX_INITIALIZER;
void* thread_function1(void* unused)
{
int i;
printf("\\n"... | 1 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mut;
int number=0, i;
void *thread1()
{
printf ("thread1 : I'm thread 1\\n");
for (i = 0; i < 10; i++)
{
printf("thread1: i=%d\\n", i);
pthread_mutex_lock(&mut);
printf("thread1 got the mut\\n");
... | 0 |
#include <pthread.h>
pthread_t tid[10000];
int counter;
pthread_mutex_t lock;
int queue[30];
int front;
int b_one_inUse;
int b_two_inUse;
int usage;
double average;
double simpleTime;
double complexTime;
double numSimple;
double numComplex;
double totalTime;
double totalWaitTime;
FILE *fp;
str... | 1 |
#include <pthread.h>
pthread_cond_t cond_reset = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_inc = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int valeur_commune = 0;
void* incr_routine(void * thread_number){
int i = *(int*) thread_number;
i += 1;
whil... | 0 |
#include <pthread.h>
volatile int thr_ready = 0;
pthread_mutex_t thr_init_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t thr_init = PTHREAD_COND_INITIALIZER;
void sig_handler(int signo);
void* thr_fn(void *arg) {
int signo;
sigset_t mask, wait;
sigfillset(&mask);
sigdelset(&mas... | 1 |
#include <pthread.h>
int main(int argc , char** argv)
{
pthread_mutex_t LOCK_A, LOCK_B, LOCK_C, LOCK_D, LOCK_E, LOCK_F, LOCK_G;
pthread_mutex_t LOCK_H, LOCK_I;
MY_INIT(argv[0]);
DBUG_ENTER("main");
DBUG_PUSH("d:t:O,/tmp/trace");
printf("This program is testing the mutex deadlock dete... | 0 |
#include <pthread.h>
pthread_mutex_t mx, my;
int x=2, y=2;
void *thread1() {
int a;
pthread_mutex_lock(&mx);
a = x;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y +... | 1 |
#include <pthread.h>
int numThreads = 0;
pthread_mutex_t mutexNumThreads;
pthread_mutex_t mutexWrite;
pthread_mutex_t mutexRecv;
{
unsigned short port_id;
char * ipaddr;
int maxthreads;
} serv_info;
void * down_client(serv_info * threadArgs)
{
FILE * writeFile = fopen("client_final.txt", ... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t can_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t can_write = PTHREAD_COND_INITIALIZER;
int i = 0;
void * do_it_a(void * p)
{
pthread_mutex_lock(&lock);
if (i != 0)
pthread_cond_wait(&can_write, &lock);
i... | 1 |
#include <pthread.h>
int shared = 5;
pthread_mutex_t lock;
int thread_num;
char buf[80];
} tinfo_t;
void*
thread_func(void *arg)
{
tinfo_t *tmp = (tinfo_t*)arg;
printf("Thread %u - modifying shared data while holding mutex\\n",
tmp->thread_num);
pthread... | 0 |
#include <pthread.h>
long sum=0;
struct interval {
long start;
long end;
int tid;
};
pthread_mutex_t sum_mutex;
void *add(void *arg)
{
intv *myinterval = (intv*) arg;
long start = myinterval->start;
long end = myinterval->end;
printf("I am thread %d and my interval is %ld... | 1 |
#include <pthread.h>
int N, NUMROWS, NUMTHREADS;
double *c, *a, *b;
pthread_mutex_t mutex;
void populate_matrices(int N){
int i,j;
srand(time(0));
a = (double*) malloc(N * N * sizeof(double));
b = (double*) malloc(N * N * sizeof(double));
c = (double*) malloc(N * N * sizeof(double));
... | 0 |
#include <pthread.h>
struct bufpool {
char *buf;
int ref_cnt;
pthread_mutex_t mutex;
};
static struct bufpool *udpbp;
static unsigned int udpbp_cnt;
static unsigned int start;
int bufpool_init(unsigned int perbuf_size, unsigned int startp, unsigned int ports)
{
char *buffers;
if (udpbp)
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t ThreadOne;
pthread_t ThreadTwo;
int mutexDestroy;
int buffer [ 10 ];
void *Consumer ( void *argument ) {
int counter;
int secondCounter;
for ( secondCounter = 0 ; secondCounter < 5 ; secondCounter++ ) {
pthr... | 0 |
#include <pthread.h>
long int reader_count;
long int writer_count;
long int reader_loop;
long int writer_loop;
int rwlock_enabled=1;
struct read_write_lock
{
pthread_mutex_t mtx;
pthread_cond_t cond;
int readers;
int writers;
};
struct read_write_lock rwlock;
pthread_spinlock_t spinlock;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int sum = 0;
void* sumfunc1()
{
int i;
for (i = 0; i < 10000 / 2; ++i)
{
pthread_mutex_lock(&mutex);
int temp_sum = sin(i) * sin(i) + cos(i) * cos(i);
sum += temp_sum;
pthread_mutex_unlock(&mutex);
}
return 0;
}
void* sumfunc2()
{
i... | 0 |
#include <pthread.h>
extern int tab[NB_LIGNE][NB_COLONNE];
extern pthread_mutex_t mutexGrille;
static bool fireOn = 1;
void nouveauCanon()
{
pthread_t thread_id;
if (pthread_create(&thread_id, 0, threadCanon, 0) != 0) {
Trace("Erreur lors du lancement du thread de gestion"
"du canon"
)... | 1 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void *
timeout_helper(void *arg)
{
struct to_info *tip;
tip = (struct to_info *)arg;
nanosleep(&tip->to_wait, 0);
(*tip->... | 0 |
#include <pthread.h>
int flag;
pthread_cond_t flag_cv;
pthread_mutex_t flag_mutex;
void *func(void * arg);
void msleep( int msec );
int procesa_args(int argc, char *argv[]);
int n_hilos;
int msec_disparo;
int msec_consumo;
int main(int argc, char *argv[])
{
pthread_t tid[20];
int i;
if (!pr... | 1 |
#include <pthread.h>
pthread_mutex_t m_access;
pthread_mutex_t m_write_num;
int write_num = 0;
char buf[1024];
void *read_hand(void * arg)
{
FILE *fp_rd = fopen("./a.txt","rb");
pthread_detach(pthread_self());
pthread_mutex_lock(&m_access);
pthread_mutex_lock(&m_write_num);
if( write_num != ... | 0 |
#include <pthread.h>
pthread_t producer[20], consumer[20];
pthread_mutex_t mutex;
int p[20], c[20];
sem_t full, empty;
int counter = 0, size;
int buffer[100];
void* ProducerFunc(void* x)
{
while (1)
{
int *num = x, i;
sem_wait(&empty);
pthread_mutex_lock(&mutex);
... | 1 |
#include <pthread.h>
int routerTable[256];
pthread_mutex_t router_mutex;
void ManageRoute_init(){
printf("ManageRoute_init\\n");
pthread_mutex_init(&router_mutex, 0);
}
void del_router(int dst){
if(dst==255){
while(system("route del default")==0);
return;
}
pthread_mutex_lock( ... | 0 |
#include <pthread.h>
float money;
int n;
int mark;
pthread_mutex_t mut;
struct INFO
{
float rmoney;
pthread_t thread;
}info[5];
int flag = 1;
void *writemoney(void)
{
money = 100.0;
mark = n = 3;
pthread_exit(0);
}
void *readmoney(void *arg)
{
int *pth = (int *)a... | 1 |
#include <pthread.h>
static pthread_t thread[256];
static pthread_mutex_t mutex[256];
static pthread_cond_t cond[256];
static volatile int full[256];
static volatile int data[256];
static int cycles;
static int tokens;
static void send_to (int i, int d)
{
pthread_mutex_lock (&(mutex[i]));
wh... | 0 |
#include <pthread.h>
struct queue_node_s *next;
struct queue_node_s *prev;
char c;
} queue_node_t;
struct queue_node_s *front;
struct queue_node_s *back;
pthread_mutex_t lock;
} queue_t;
void *producer_routine(void *arg);
void *consumer_routine(void *arg);
long g_num_prod;
pt... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thread1(void *null)
{
printf("\\n In thread1 \\n");
getchar();
if(pthread_mutex_lock(&mutex)==0)
{
getchar();
}
pthread_mutex_unlock(&mutex);
getchar();
printf("\\n Exit thread1 \\n");
pthread_exit(0);
}
void *thread2(void *null)... | 0 |
#include <pthread.h>
sem_t* taquillas;
sem_t** salas;
int total = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t inicia_pelicula = PTHREAD_COND_INITIALIZER;
void* comprarBoleto(void*);
void* reloj(void*);
int main() {
int i, j;
taquillas = (sem_t*) malloc (10 * size... | 1 |
#include <pthread.h>
struct student
{
int id;
int age;
}stu;
int i;
pthread_mutex_t mutex;
void *thread1(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
stu.id=i;
stu.age=i;
if(stu.id!=stu.age)
{
printf("id = %d ,age =%d... | 0 |
#include <pthread.h>
char character_name[30];
char symbol;
int thread_num;
int condition;
int frozen;
int position;
pthread_t thread_id;
}thread_data;
struct mutex_shared{
int BOARD[2][10];
int WINNER;
int CONDITION;
} SHARED_DATA;
pthread_mutex_... | 1 |
#include <pthread.h>
void *SighandThread(void *args)
{
while(1)
{
if(flag_mask)
{
flag_mask_copy = flag_mask;
if (flag_mask & TIMER_EVENT)
{
flag_mask ^= TIMER_EVENT;
}
if (flag_mask & ASYNC_EVENT)
{
flag_mask ^= ASYNC_EVENT;
}
if (fl... | 0 |
#include <pthread.h>
void *producer (void *args);
void *consumer (void *args);
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
sem_t notFull;
sem_t notEmpty;
int buf[4];
long head, tail;
int full, empty;
} queue;
queue *queueInit (void);
void queueDelete (queue *q);
void queueAdd (que... | 1 |
#include <pthread.h>
int R[MAX_N+1][MAX_C+1];
int thread_create(void * (*start_func)(void *), void *arg){
int status = 0;
pthread_t tid;
pthread_attr_t attr;
pthread_attr_init(&attr);
status = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
if(status == 0) status = pthread_creat... | 0 |
#include <pthread.h>
struct threadData {
char *t;
char *p;
int t_len;
int p_len;
int startpos;
};
void readtext(char *t, int len);
void *search(void *arg);
int found = 0;
int p_index;
pthread_mutex_t lock;
int main(int argc, char *argv[]) {
if (argc != 3)
... | 1 |
#include <pthread.h>
struct job{
pthread_t tid;
Job next;
int val;
};
pthread_mutex_t q_lock=PTHREAD_MUTEX_INITIALIZER;
int insert(Job head,int val,pthread_t tid)
{
Job p,q;
p=head;
if(p!=0)
{
while(p->next!=0)
{
p=p->next;
}
}
q=(struct job *)malloc(sizeof(struct job));
if(q==0)... | 0 |
#include <pthread.h>
struct melon g_melon;
int melon_init(uint32_t nb_threads)
{
uint32_t i = 0;
g_melon.stop = 0;
g_melon.fibers_count = 0;
g_melon.ready = 0;
pthread_mutexattr_t mutex_attr;
if (pthread_mutexattr_init(&mutex_attr))
return -1;
if (pthread_mutexattr_settype(... | 1 |
#include <pthread.h>
static int medium_ended;
static int go_foward;
pthread_mutex_t mutex;
void* thread1_code(void* args){
struct sched_param param;
param.sched_priority = 30;
pthread_setschedparam(pthread_self(),SCHED_FIFO,¶m);
printf("Thread basse priorite\\n");
pthread_mutex_lock(... | 0 |
#include <pthread.h>
float hole= 0;
int flag= 0;
pthread_mutex_t lock_hole;
pthread_cond_t cond_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_lo... | 1 |
#include <pthread.h>
struct foo
{
int f_count;
int f_addtimes;
pthread_mutex_t f_mutex;
};
struct foo * foo_alloc()
{
struct foo* fp;
fp = (struct foo*)malloc(sizeof(struct foo));
if(fp != 0)
{
fp->f_count = 0;
fp->f_addtimes = 0;
pthread_mutex_... | 0 |
#include <pthread.h>
void *v1(void *path){
if (start_time.tv_sec == 0 && start_time.tv_usec == 0) {
if (gettimeofday(&start_time, 0)) {
fprintf(stderr, "Failed to run Variant 1: unable to get current time\\n");
exit(1);
}
}
char *file, *file_ext, new_path[1000];
... | 1 |
#include <pthread.h>
int main(int argc,char **argv)
{
int ret;
pthread_t view_id;
pid_t view_pid=0,audio_pid=0;
fb_init();
ts_init();
show_jpglogo("./image/welcome.jpg");
sleep(3);
show_menu();
ret = pthread_create(&view_id, 0,picview_thread, 0);
if(ret == -1)
goto pthread_cre... | 0 |
#include <pthread.h>
double x;
double y;
double r;
} Ball;
struct _listNode * next;
int isblock;
Ball ball;
} listNode;
float startx;
float starty;
float endx;
float endy;
} PM;
void insert(Ball ball, int isblock);
double distance(Ball b1, Ball b2);
double m_abs(double... | 1 |
#include <pthread.h>
void *Producer();
void *Consumer();
int BufferIndex = 0;
int counter = 100;
char *BUFFER;
pthread_cond_t Buffer_Not_Full = PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar = PTHREAD_MUTEX_INITIALIZER;
int main()
{
... | 0 |
#include <pthread.h>
pthread_mutex_t gLock;
int val = 10;
void *Print(void *pArg)
{
int id = getpid();
printf("I am the PTHREAD. My PID is %d\\n", id);
pthread_mutex_lock(&gLock);
val += 1;
pthread_mutex_unlock(&gLock);
return 0;
}
int main (int argc, char **argv, char **envp)
{
pthre... | 1 |
#include <pthread.h>
char letters[26] = "abcdefghijklmnopqrstuvwxyz";
pthread_mutex_t mutex;
useconds_t delays[3];
void * invert_letters()
{
static char curr_low = 1;
while(1)
{
int i;
pthread_mutex_lock(&mutex);
for (i = 0; i < 26; ++i)
{
letters[i] += curr_low ? -32 : 32;
}... | 0 |
#include <pthread.h>
void *philosopher (void *id);
void grab_chopstick (int, int, char *);
void down_chopsticks (int, int);
int food_on_table ();
pthread_mutex_t chopstick[5];
pthread_t philo[5];
pthread_mutex_t food_lock;
int sleep_seconds = 0;
int i;
int main (int argn, char **argv){
... | 1 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
extern void __VERIFIER_error() ;
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
void ... | 0 |
#include <pthread.h>
pthread_mutex_t mutexWriter = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexReader = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condReader = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
in... | 1 |
#include <pthread.h>
char state[3][10];
pthread_mutex_t chopstick[5]=PTHREAD_MUTEX_INITIALIZER;
void *fun(int j){
printf("hungry: %d\\n",j);
if(j%2==0){
pthread_mutex_lock(&chopstick[j]);
pthread_mutex_lock(&chopstick[(j+1)%5]);
}else{
pthread_mutex_lock(&chopstick[(j+1)%5]);
pthread... | 0 |
#include <pthread.h>
struct pbxfoo *pbxfoo_alloc(void)
{
struct pbxfoo *fp = 0;
if((fp=(struct pbxfoo *)malloc(sizeof(struct pbxfoo))) != 0){
memset(fp, 0, sizeof(struct pbxfoo));
fp->f_ref = 1;
if(pthread_mutex_init(&fp->f_lock, 0) != 0 ){
free(fp);
return 0;
}
}
return fp... | 1 |
#include <pthread.h>
void *sum(void *p);
double *v1, *v2;
double sumtotal = 0.0;
int numthreads, n;
pthread_mutex_t mutex;
int main(int argc, char **argv) {
int i;
pthread_t workers[8];
struct timeval start, end;
gettimeofday(&start, 0);
pthread_mutex_init(&mutex, 0);
scanf(... | 0 |
#include <pthread.h>
int buffer[3];
int add = 0;
int rem = 0;
int num = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_cons = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_prod = PTHREAD_COND_INITIALIZER;
void *producer(void *param);
void *consumer(void *param);
int main(int ar... | 1 |
#include <pthread.h>
pthread_mutex_t mutexid;
pthread_mutex_t mutexres;
int idcount = 0;
pthread_mutex_t joinmutex[4];
int join[4];
int result[4];
int target;
int sequence[(4 * 30)];
void *thread (void *arg)
{
int id, i, from, count, l_target;
pthread_mutex_lock (&mutexid);
l_targe... | 0 |
#include <pthread.h>
struct apc100{
int fd;
struct apc100_cumulativeness cumulativenss;
pthread_t tid;
pthread_mutex_t cumulativeness_lock;
void *cb_in_arg;
void (*cb_in)(void*, struct apc100_cumulativeness *);
};
static void _noncanonical(struct termios *t)
{
t->c_lflag &= ~(ICANON ... | 1 |
#include <pthread.h>
inline unsigned int hash_pjw(const char* name)
{
unsigned int val = 0,i;
for(; *name; ++name){
val = (val << 2) + *name;
if(i = val & ~0x3fff)
val = (val ^ (i >> 12)) & 0x3fff;
}
return val;
}
void initContactorTable()
{
int i;
... | 0 |
#include <pthread.h>
void trends_pos(double *dt_p, struct task_par *tp)
{
if(((*dt_p) += 2 ) >= (dx-5))
{
rectfill(screen, d, sezy-1, d+dx, sezy-d-dy, COL_BG);
(*dt_p) = 0;
}
axis(d, sezy-d, "theta... | 1 |
#include <pthread.h>
int threads_amount;
char *file_name;
int records_to_read;
char *to_find;
int records_size = 1024;
int fd;
int END_FILE = 0;
int records_transfered;
int *finished;
pthread_key_t records;
pthread_t *threads;
pthread_mutex_t out_mutex = PTHREAD_MUTEX_INITIALIZER;
int main(... | 0 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
int sum = 0;
void *countgold(void *param)
{
int i;
for (i = 0; i < 10000000; i++) {
pthread_mutex_lock(&m);
sem_wait(&s);
sum += 1;
sem_post(&s);
pthread_mutex_unlock(&m);
}
return 0;... | 1 |
#include <pthread.h>
volatile int counter = 0;
pthread_mutex_t mutext = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void * pthread_func(void * arg){
pthread_mutex_lock(&mutext);
while(1){
do{
printf("thread2: counter = %d\\n",counter);
while(count... | 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 < 10; i++)
{
pthread_mutex_lock (&count_mutex);
... | 1 |
#include <pthread.h>
extern int makethread(void* (*)(void*), void*);
struct to_info
{
void (*to_fun)(void*);
void *to_arg;
struct timespec to_wait;
};
void
my_clock_gettime(int id, struct timespec* tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
tsp->tv_nsec = tv... | 0 |
#include <pthread.h>
void *philosopher_thread(void *);
pthread_mutex_t monitor = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t conditions[5];
int forks[5];
int main(int argc, char *argv[])
{
pthread_t philosophers[5];
for (int i = 0; i < 5; i++)
pthread_create(&philosophers[i], 0, &philosoph... | 1 |
#include <pthread.h>
struct pid_data{
pthread_mutex_t pid_mutex;
pid_t pid;
};
int set_priority(int priority){
int policy;
struct sched_param param;
if (priority < 1 || priority > 63) return -1;
pthread_getschedparam(pthread_self(), &policy, ¶m);
param.sched_priority = priority;
ret... | 0 |
#include <pthread.h>
pthread_mutex_t globalLock;
int nb_lecteur;
pthread_cond_t notif_lecteur;
pthread_cond_t notif_ecrivain;
int redacteur_attente;
int on_a_ecrivain;
int on_a_lecteur;
} lecteur_redacteur_t;
lecteur_redacteur_t lecteur_redacteur;
int iterations;
int donnee;
}... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_sum;
long int A[100][100];
long int total;
pthread_t threads[1000];
int r;
int c;
void * threadSum(void *);
int main()
{
int status;
long int i;
long int j;
long int t_no;
pthread_attr_t attr;
int num_t;
pthread_mutex_init(&mutex_sum, 0);
pthre... | 0 |
#include <pthread.h>
void* funcionProd(void * arg);
void* funcionCon(void * arg);
int tam_cola = 0,cola = 0,producidos= 0,consumidos=0,items = 0;
int hilos_prod,hilos_con;
double tprod = 0,tcon= 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condicion1 = PTHREAD_COND_INITIAL... | 1 |
#include <pthread.h>
extern char dev_camera_mask;
extern int dev_camera_fd;
extern pthread_mutex_t mutex_camera;
extern pthread_cond_t cond_camera;
void *pthread_camera (void *arg)
{
unsigned char picture = 0;
if ((dev_camera_fd = open (DEV_CAMERA, O_RDWR | O_NOCTTY | O_NDELAY)) < 0)
{
p... | 0 |
#include <pthread.h>
pthread_mutex_t mtx= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int BUFFER[5]={1,1,1,0,0};
int N=3;
void * productor(){
int i;
int j;
for(i=0;i<20;i++){
pthread_mutex_lock(&mtx);
while(N==5){
pthread_cond_wait(&cond,&mtx);
}
BUFF... | 1 |
#include <pthread.h>
extern char ** environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void thread_init (void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init (&attr);
pthread_mutexarrt_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
pt... | 0 |
#include <pthread.h>
extern int fd_export;
extern int fd_led[8];
extern int fd_led_value[8];
extern int fd_sw[8];
char ld_number[8][3] = {"61", "62", "63", "64", "65", "66", "67", "68"};
char sw_number[8][3] = {"69", "70", "71", "72", "73", "74", "75", "76"};
extern char sw_status[8];
extern int f... | 1 |
#include <pthread.h>
volatile int running_threads = 0;
pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;
void *startThread(void *vargp)
{
int myid = (int)vargp;
if (0) {
printf("Thread %d starting...\\n", myid);
}
if (0) {
printf("get_unique_id returned an ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t s[5];
state_t state[5];
int done;
int eatcount[5];
void philosopher(void *);
void think(int i);
void take_forks(int i);
void eat(int i);
void put_forks(int i);
void test(int i);
void mysleep(int milliseconds);
int main(int argc,... | 1 |
#include <pthread.h>
static int s_interrupted = 0;
pthread_mutex_t lock;
int req_num = 0;
int fd;
static void s_signal_handler (int signal_value)
{
s_interrupted = 1;
}
static void s_catch_signals (void)
{
struct sigaction action;
action.sa_handler = s_signal_handler;
action.sa_flags = 0;
si... | 0 |
#include <pthread.h>
const char* text = "Some text!";
const int text_size = 10;
const int file_size = (10 * sizeof(char));
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *thread_one( void *ptr );
void *thread_two( void *... | 1 |
#include <pthread.h>
int do_debug = 0;
int do_thread = 0;
int do_stdin = 0;
int do_sleep = 0;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
int threadcount = 0;
struct sockets {
int local;
FILE *in, *out;
};
struct sockets *get_sockets(int);
int socket_setup(void);
int debug(ch... | 0 |
#include <pthread.h>
int size;
char buf[4];
}test_thread_func_st;
void sbt_thread_detatch( ){
pthread_detach(pthread_self());
}
void sbt_thread_exit( ){
pthread_exit(0);
}
static void *sub_thread_detach(test_thread_func_st* param){
int i;
pthread_t tid = pthread_self();
LOGD("Start(thre... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(800)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(800)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
... | 0 |
#include <pthread.h>
uint8_t ts_buffer[5000];
pthread_mutex_t read_mutex = {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, __LOCK_INITIALIZER};
int bufhead = 0;
int buftail = 0;
bool all_abort = FALSE;
bool pushbyte(uint8_t data);
bool popbyte(uint8_t *data);
void tinystream_cb(int id, uint8_t *data, i... | 1 |
#include <pthread.h>
int ticket=10;
pthread_mutex_t lock;
pthread_cond_t cond;
void* salewinds1(void* args){
while(1){
pthread_mutex_lock(&lock);
if(ticket>0){
sleep(1);
printf("win1 start sale ticket! the ticket is:%d\\n",ticket);
ticket--;
sleep(2);
printf("sale tikcet finis... | 0 |
#include <pthread.h>
int condvar_was_hit = 0;
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_hit_threshold=PTHREAD_COND_INITIALIZER;
void *inc_count(void *null)
{
int i=0;
for (i=0; i<10; i++) {
pthread_mutex_loc... | 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;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0)
err_exit(err, "sigwait fail... | 0 |
#include <pthread.h>
pthread_mutex_t* mutex;
pthread_cond_t* var;
int wait_general;
int wait_empresarial;
} params;
sem_t sem_generales;
sem_t sem_empresariales;
int cajeros_generales[5];
int generales_disponibles[5];
int cajeros_empresariales[3];
int empresariales_disponibles[3];
pthre... | 1 |
#include <pthread.h>
pthread_mutex_t mutex[5];
void* dine(void* arg)
{
int num = (int)arg;
int left, right;
if(num < 4)
{
right = num;
left = num+1;
}
else if(num == 4)
{
right = 0;
left = num;
}
while(1)
{
p... | 0 |
#include <pthread.h>
static void* event_loop_thread(void *arg);
static pthread_t event_thread_id = 0;
static pthread_mutex_t event_mutex_id;
static pthread_mutexattr_t event_mutex_mutexattr;
static pthread_t event_mutex_owner_id = 0;
static uint32_t owner_count = 0;
static sem_t event_start... | 1 |
#include <pthread.h>
struct map *init_map() {
int i ;
struct map *m = malloc(sizeof(struct map)) ;
for(i = 0 ; i <= ID_MAX ; i++) {
m->name_from_id[i] = 0 ;
assert(pthread_mutex_init(&m->map_lock[i], 0)==0);
}
assert(pthread_mutex_init(&m->size_lock, 0)==0);
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.