text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int64_t target_nanos;
timer_t timerid;
static int current_buffer;
static int writer_current_buffer;
static int bufpos[2];
static char buffers[2][(1024*1024)];
static
int64_t read_nanos(int type)
{
struct timespec ts;
int rv = clock_gettime(type, &ts);
if (rv < 0) {
... | 1 |
#include <pthread.h>
int NUM_LOOPS = 32;
int NUM_THREADS = 2;
struct timespec start_time;
struct timespec end_time;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t mainCV = PTHREAD_COND_INITIALIZER;
pthread_cond_t workerCV = PTHREAD_COND_INITIALIZER;
int counter=0;
volatile stru... | 0 |
#include <pthread.h>
int
pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
{
pthread_mutex_lock(&once_control->mutex);
if (once_control->state == PTHREAD_NEEDS_INIT) {
init_routine();
once_control->state = PTHREAD_DONE_INIT;
}
pthread_mutex_unlock(&once_control->mutex)... | 1 |
#include <pthread.h>
static void *treader(void *_);
static void *twriter(void *_);
int main(void);
static pthread_mutex_t mutex;
static pthread_cond_t cond;
static int counter = 0;
static int quit = 0;
void *
treader(void *_)
{
sleep(6);
while (!quit) {
pthread_mutex_lock(&mutex... | 0 |
#include <pthread.h>
static sigset_t set;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int quitflag = 0;
static void *thread_func(void *arg)
{
int ret = 0;
int signo = 0;
for (;;)
{
ret = sigwa... | 1 |
#include <pthread.h>
const int MAX_KEY = 65536;
const int MAX_THREADS = 1024;
struct node {
int data;
struct node* next;
};
struct node* head = 0;
int n = 1000;
int m = 10000;
float mMember = 0.50;
float mInsert = 0.25;
float mDelete = 0.25;
int thread_count = 1;
double start_time... | 0 |
#include <pthread.h>
static FILE *logfp = 0;
static enum log_level llev = -1;
static pid_t pid;
static pthread_mutex_t logfmutex;
void error_helper_init(const char *logfpath, enum log_level lev)
{
if (logfp) {
fprintf(stderr, "Log file already initialized");
return;
}
if (! (logf... | 1 |
#include <pthread.h>
int thread_count;
int barrier_thread_count = 0;
pthread_mutex_t barrier_mutex;
pthread_cond_t ok_to_proceed;
void Usage(char* prog_name);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
if (argc != 2)
... | 0 |
#include <pthread.h>
int TimeSig[4][6] = {{7, 1, 0, 0, 0, 0},
{7, 1, 1, 0, 0, 0},
{7, 1, 3, 1, 0, 0},
{7, 1, 1, 3, 1, 1}};
pthread_t pthread;
int fd;
volatile void *gpio_addr;
volatile unsigned int *gpio_datain;
volatile unsigned i... | 1 |
#include <pthread.h>
int writers; int locked; int reading;
pthread_mutex_t lock; pthread_cond_t scoreboard_request = PTHREAD_COND_INITIALIZER;
void initialse_scoreboard_locks(){
if (pthread_mutex_init(&lock, 0) !=0){
printf("\\nFailed to initialse mutex lock, closing server\\n");
ex... | 0 |
#include <pthread.h>
enum fb_state {
FB_SLEEP,
FB_AWAKE,
NUM_FB_STATES
};
static enum fb_state fb_state = FB_AWAKE;
static const char *fb_file_names[] = {
[FB_SLEEP] = "/sys/power/wait_for_fb_sleep",
[FB_AWAKE] = "/sys/power/wait_for_fb_wake"
};
static pthread_t fb_monito... | 1 |
#include <pthread.h>
pthread_mutex_t produce_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t consume_mutex = PTHREAD_MUTEX_INITIALIZER;
int b;
unsigned char stack[4001];
int out_max,in_max;
void *consumer();
void *producer();
void cpu_eat(int count){
unsigned long loop;
int ... | 0 |
#include <pthread.h>
int buffer[10];
int pos_consumer = 0;
int pos = 0;
sem_t s;
sem_t t;
pthread_mutex_t lock_posc;
void * producer (void * a)
{
int temp;
while(1)
{
sem_wait(&s);
pthread_mutex_lock(&lock_posc);
buffer[pos]=rand();
temp = buffer[pos];... | 1 |
#include <pthread.h>
int arr_len;
} args_struct;
double g_PI = 0.0;
static pthread_mutex_t mutex;
void* monte_carlo(void* v_as) {
args_struct* as = v_as;
int arr_len = (*as).arr_len;
for (int i = 0; i < arr_len; i++) {
double random_x = rand()/(double)32767;
double ... | 0 |
#include <pthread.h>
static pthread_mutex_t mutexScanf;
void* print_prime_factors(void* fd)
{
int combien_de_nombres_lus ;
uint64_t premier;
uint64_t nombre = 0;
FILE* fichier = (FILE*) fd;
while(1)
{
pthread_mutex_lock(&mutexScanf);
combien_de_nombres_lus = fscanf(fichier, "%lu", &... | 1 |
#include <pthread.h>
pthread_mutex_t *fork_lft, *fork_rgt;
const char *name;
pthread_t thread;
int fail;
} Philosopher;
int running = 1;
void *PhilPhunction(void *p) {
Philosopher *phil = (Philosopher*)p;
int failed;
int tries_left;
pthread_mutex_t *fork_lft, *for... | 0 |
#include <pthread.h>
int r_count = 0, share = 0;
pthread_mutex_t mu_access;
pthread_mutex_t mu_r_count;
void * reader (void * input)
{
pthread_detach(pthread_self());
pthread_mutex_lock(&mu_r_count);
if(r_count==0)
pthread_mutex_lock(&mu_access);
++r_count;
pthread_mu... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void printer(char *str)
{
pthread_mutex_lock(&mutex);
while(*str!='\\0')
{
putchar(*str);
fflush(stdout);
str++;
sleep(1);
}
printf("\\n");
pthread_mutex_unlock(&mutex);
}
void printer2(c... | 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++;
... | 1 |
#include <pthread.h>
{ int sum;
pthread_mutex_t lock;
}ct_sum;
void * add1(void * cnt)
{
pthread_mutex_lock(&(((ct_sum*)cnt)->lock));
int i;
for( i=0;i<50;i++){
(*(ct_sum*)cnt).sum+=i;}
pthread_mutex_unlock(&(((ct_sum*)cnt)->lock));
pthread_exit(0);
return 0;
}
... | 0 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static void*
thread_func( void* arg )
{
pthread_t self = pthread_self();
struct timespec ts;
clockid_t clock;
int e;
pthread_mutex_lock( &lock );
e = pthread_getcpuclockid( self, &clock );
... | 1 |
#include <pthread.h>
extern int dmeventd_debug;
static pthread_mutex_t _register_mutex = PTHREAD_MUTEX_INITIALIZER;
static int _register_count = 0;
static struct dm_pool *_mem_pool = 0;
static void *_lvm_handle = 0;
static pthread_mutex_t _event_mutex = PTHREAD_MUTEX_INITIALIZER;
... | 0 |
#include <pthread.h>
struct threadParameter{
int* nbThreadTotal;
int* nbThreadWaitingForSync;
int doneCreating;
pthread_cond_t doneCreatingCond;
pthread_cond_t controlePoint;
pthread_mutex_t mut;
pthread_mutex_t mutCreation;
};
void initThreadParameter(struct threadParameter* p)... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err, signo;
for(;;)
{
err = sigwait(&mask,&signo);
if(err != 0)
err_exit(e... | 0 |
#include <pthread.h>
int nitems;
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
int buff[1000000];
int nput=0;
int nval=0;
void *produce(void *), *consume(void *);
int
main(int argc, char **argv)
{
int i, nthreads, count[100];
pthread_t tid_produce[100], tid_consume;
nitems = 100000... | 1 |
#include <pthread.h>
buffer_item START_NUMBER;
buffer_item buffer[8];
int MIN_SLEEP_TIME = 1;
int MAX_SLEEP_TIME = 5;
pthread_mutex_t mutex;
sem_t empty, full;
int sleepTime, producerThreads, consumerThreads, insertPointer, removePointer, totalCount;
void getDataFromCommandLine(in... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t conditionalVariable;
int threadCounter = 0;
void* threadFunction( void* rank );
int main( void )
{
pthread_mutex_init( &mutex, ( pthread_mutexattr_t* ) 0 );
pthread_cond_init( &conditionalVariable, ( pthread_condattr_t* ) 0 );
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *forfood(void* arg);
int main(void)
{
const int ppl_n = 1000;
pthread_t ppl[ppl_n];
int i;
int count = 0;
for(i=0; i<ppl_n; i++) {
Pthread_create(&ppl[i], 0... | 0 |
#include <pthread.h>
int a[(10 * 1000 * 1000 + 3)];
int b[(10 * 1000 * 1000 + 3)];
int sum;
pthread_mutex_t mutex[1];
static int
array_sequencial_prod(int *a, int *b, unsigned ini, unsigned end)
{
int sum = 0;
unsigned i;
for (i = ini; i < end; i++) {
sum += a[i] * b[i];
}
ret... | 1 |
#include <pthread.h>
int
pthread_join(pthread_t tid, void **status)
{
pthread_thread_t *joinee, *joiner;
if ((joinee = tidtothread(tid)) == NULL_THREADPTR)
return EINVAL;
joiner = CURPTHREAD();
assert_preemption_enabled();
disable_preemption();
pthread_lock(&(joinee->lock));
if (joine... | 0 |
#include <pthread.h>
void *runner(void *param);
double **A, **inv;
double del;
size_t n;
int i;
int j;
} matIndex;
void initMatrix(double ***a, int m, int n);
void getMatrix(double ***a, int m, int n);
pthread_mutex_t lock;
pthread_attr_t attr;
double determinant(double **a, int n);
void inv... | 1 |
#include <pthread.h>
void log_info(const char* fmt, ...)
{
va_list va;
__builtin_va_start((va));
vprintf(fmt, va);
;
}
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void* producer(void* ptr)
{
int i;
for (i=0; i<=1000; ++i)
{
pthread_mutex_lock(&the_mutex);
... | 0 |
#include <pthread.h>
int global_value = 0;
pthread_mutex_t global_value_mutex;
void *reader(void *arg);
void *writer(void *arg);
int main(int argc, char **argv)
{
pthread_t tid[20];
int rc;
int i;
srand(47);
pthread_mutex_init(&global_value_mutex, 0);
for (i = 0; i < 20; i++)
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int flag =0 ;
void * pthread_a(void *arga){
sleep(100000);
fprintf(stderr,"flag a %ld\\n",flag);
pthread_mutex_lock(&mutex);
flag = 1;
fprintf(stderr,"flag a %ld\\n"... | 0 |
#include <pthread.h>
pthread_mutex_t mtx;
static void * xbee_frame_parser(void * data)
{
pthread_mutex_lock(&mtx);
struct xbee_rawframe * tmp = (struct xbee_rawframe *)data;
switch(tmp->header.api) {
case 0x95: {
struct xbee_idframe * frame = malloc(3 + tmp->header.length +1);
... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc=PTHREAD_COND_INITIALIZER;
void* thr_fn(void* arg)
{
int err,signo;
while(1)
{
err=sigwait(&mask,&signo);
if(err!=0)
err_exit(err,"sig_wait error");
switch(signo)
... | 0 |
#include <pthread.h>
int somme_val=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_rand(void *arg) {
int *pt=(int*)arg;
int random_val;
random_val=(int) (10*((double)rand())/32767);
printf("Argument recu : %d, thread_id : %d\\n", *pt, (int)pthread_self());
printf("rando... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_cond_t go;
int numWorkers;
double read_timer() {
static bool initialized = 0;
static struct timeval start;
struct timeval end;
if( !initialized )
{
gettimeofday( &start, 0 );
initialized = 1;
}
... | 0 |
#include <pthread.h>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;
int init(QType *q)
{
q->head=0;
... | 1 |
#include <pthread.h>
int pthread_barrier_init(pthread_barrier_t* barrier,
const void* barrier_attr,
unsigned count) {
barrier->count = count;
pthread_mutex_init(&barrier->mutex, 0);
pthread_cond_init(&barrier->cond, 0);
return 0;
}
int pth... | 0 |
#include <pthread.h>
static void *save_thread_entrypoint(void *);
void start_autosave(pthread_t *p, struct save_thread_args *args)
{
strcpy(args->filename, DEFAULT_AUTOSAVE_FILENAME);
int status = pthread_create(p, 0, save_thread_entrypoint, (void *)args);
if (status)
{
printf("\\t\\t... | 1 |
#include <pthread.h>
pthread_cond_t condc, condp;
pthread_mutex_t mutex;
int producer_id = 0;
int consumer_id = 0;
int resource = 0;
void *producer()
{
int id = ++producer_id;
while(1)
{
sleep(1);
pthread_mutex_lock(&mutex);
while(resource == 10)
{
printf("Producer %d: waitting\... | 0 |
#include <pthread.h>
pthread_t threads[3];
char buf[20];
int count=0;
pthread_mutex_t mutex,mutex2;
pthread_cond_t rdv;
void rdv_fonc(){
pthread_mutex_lock(&mutex2);
count++;
while(count < 3) pthread_cond_wait(&rdv,&mutex2);
if(count == 3) pthread_cond_broadcast(&rdv)... | 1 |
#include <pthread.h>
volatile int i = 0, j = 0;
void *thr( void *mtx ) {
pthread_mutex_t *mutex1 = ( (pthread_mutex_t **)mtx )[ 0 ];
pthread_mutex_t *mutex2 = ( (pthread_mutex_t **)mtx )[ 1 ];
pthread_mutex_lock( mutex1 );
pthread_mutex_lock( mutex2 );
i = (i + 1) % 3;
pth... | 0 |
#include <pthread.h>
LIST list_init(bool allowdups);
bool list_destroy(LIST *l);
bool list_insert(LIST l, uintptr_t *item);
bool list_remove(LIST l, uintptr_t *item);
bool list_contains(LIST l, uintptr_t *item);
bool list_get(LIST l, uintptr_t *item);
bool list_look(LIST l, uintptr_t *item);
st... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t done;
int id;
}params;
void* printId(void* arg){
int id;
pthread_mutex_lock(&(*(params*)(arg)).mutex);
id = (*(params*)(arg)).id;
printf("Hello from Thread %d\\n", id);
pthread_mutex_unlock(&(*(pa... | 0 |
#include <pthread.h>
pthread_mutex_t tcp_lost_mutex;
static void *process_function(void *);
static void process_function_actual(int job_type);
static int process_judege(struct Job *job);
static void forcecontrol(struct tcp_stream *a_tcp,struct half_stream *snd, struct half_stream *rcv);
static v... | 1 |
#include <pthread.h>
struct list {
int data;
pthread_mutex_t lock;
struct list *next;
};
struct list *shared = 0;
void *run(void *arg) {
struct list *cur;
for (cur = shared; cur; cur = cur->next) {
pthread_mutex_lock(&cur->lock);
cur->data++;
pthread_mutex_unlock(&cur->... | 0 |
#include <pthread.h>
pthread_mutex_t mtx;
sem_t sem;
int S=0, count = 0;
void barrier_point(){
pthread_mutex_lock(&mtx);
count++;
pthread_mutex_unlock(&mtx);
if(count < 45){
sem_wait(&sem);
}
if(count == 45){
sem_post(&sem);
}
}
void* fct_ptr_thr(void *v){
int tid = *(int*)v;
p... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_cond_t go;
int numWorkers;
int numArrived = 0;
void Barrier() {
pthread_mutex_lock(&barrier);
numArrived++;
if (numArrived == numWorkers) {
numArrived = 0;
pthread_cond_broadcast(&go);
} else
pthread_cond_wait(&go, &barrier);
pt... | 0 |
#include <pthread.h>
int nbLignes;
int nbMsg;
} Parametres;
pthread_mutex_t lock;
void demanderAcces(void) {
pthread_mutex_lock(&lock);
};
void libererAcces(void) {
pthread_mutex_unlock(&lock);
};
void thdErreur(int codeErr, char *msgErr, void *codeArret) {
fprintf(stder... | 1 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cond;
char str[100];
bool str_available;
void* producer(void* arg ) {
while (1) {
fgets(str, sizeof str, stdin);
pthread_mutex_lock(&m);
str_available = 1;
pthread_cond_signal(&cond);
pthread_mutex_... | 0 |
#include <pthread.h>
pthread_t odd_thread, even_thread;
pthread_mutex_t lock;
pthread_cond_t cond;
int is_even;
void* even_print(void *data) {
int *max = data;
int i;
for (i = 0; i < *max; i += 2) {
pthread_mutex_lock(&lock);
while (is_even != 1) {
pthread_cond_wait(&cond, &l... | 1 |
#include <pthread.h>
int MAX_ITER = 200;
int num = 5;
double waiting_time_averages [ 5 ];
enum { thinking, hungry, eating } state [ 5 ];
pthread_mutex_t lock;
pthread_cond_t self [ 5 ];
pthread_t philo [ 5 ];
int identity [ 5 ] = { 0, 1, 2, 3, 4 };
int eat_count = 0;
void *phil_run ( void *arg ... | 0 |
#include <pthread.h>
long udelay = 1000000;
float *det_time;
int changed = 0, detected = 0;
int N, NUM_THREADS;
void exitfunc(int sig)
{
int i;
float max = det_time[0], min = det_time[0];
float mean = 0, sdev = 0, range;
printf("\\n%d Threads & %d Signals & Change frequency %f s\\n", NUM_... | 1 |
#include <pthread.h>
pthread_mutex_t lock ;
pthread_cond_t snd ;
pthread_cond_t rcv ;
int number[10] ;
int occupied ;
int start ;
} FilterArguments ;
FilterArguments* newFilter();
void* filter( void* arguments );
void send( int value, FilterArguments *shared );
int receive( FilterArgumen... | 0 |
#include <pthread.h>
{
int buf[5];
int in;
int out;
} sbuf_t;
sbuf_t shared;
sem_t spaces;
sem_t items;
pthread_mutex_t mutex;
void *Producer(void *arg)
{
int i, item, index;
index = (int)arg;
for (i=0; i < 10; i++)
{
item = i;
sem_wait(&spa... | 1 |
#include <pthread.h>
int sock, my_ppid, my_id;
pthread_t tid_send_hey;
pthread_t tid_get_hey;
pthread_mutex_t mutex;
void Clean_Up() {
char msgout[MAX_LINE];
char my_host[MAX_HOST_NAME];
printf("\\nHey Client goes bye bye.");
pthread_kill(tid_get_hey, SIGINT);
pthread_kill(tid_... | 0 |
#include <pthread.h>
struct thread_info {
pthread_t thread;
pthread_mutex_t wakeup_mutex;
pthread_cond_t wakeup_send, wakeup_receive;
unsigned len;
char *data;
};
struct thread_info *newthread(void *(*func)(void *))
{
struct thread_info *ti = malloc(sizeof(struct thread_info));
memse... | 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>
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 ... | 1 |
#include <pthread.h>
void
rdwr_lock_init(struct rdwrlock *rwp)
{
rwp->lock = PTHREAD_MUTEX_INITIALIZER;
rwp->rdsok = PTHREAD_COND_INITIALIZER;
rwp->wrok = PTHREAD_COND_INITIALIZER;
rwp->rwlock = 0;
rwp->nwrs_wait = 0;
rwp->thrid = 0;
}
void
rd_lock(struct rdwrlock *rwp)
{
assert(rwp... | 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) {
fp... | 1 |
#include <pthread.h>
char buffer[20];
int inptr=0, outptr=0, inbuffer=0;
struct timespec delay;
struct timeval tv;
pthread_mutex_t mutex;
sem_t s_produtor, s_consumidor;
bool stop = 0;
void *killBySiginal()
{
char c;
printf("Digite o Sinal:\\n");
scanf(" %c",&c);
if(c == "T"){
print... | 0 |
#include <pthread.h>
volatile int global_counter = 0;
volatile int shared_array_1[5] = {1,2,3,4,5};
volatile int shared_array_2[5] = {0,0,0,0,0};
pthread_mutex_t mutex_global;
void* hello(void* id)
{
int i;
if (*((int*)id) == 0)
{
pthread_mutex_lock(&mutex_global);
for (i=0; i<5; i++)
{... | 1 |
#include <pthread.h>
long max_queue_size = 10000;
long *buffer;
long size;
long max_size;
long index;
long outdex;
pthread_mutex_t *mutex;
pthread_cond_t *full;
pthread_cond_t *empty;
}queue_t;
void queue_enqueue(queue_t *queue, long value){
pthread_mutex_l... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t) {
int i;
long my_id = (long)t;
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
pthread_cond_... | 1 |
#include <pthread.h>
pthread_mutex_t agente;
pthread_mutex_t fumadores[3];
char *necesita[3] = {"TabacoPapel", "TabacoFosforos", "PapelFosforos"};
bool enLaMesa[3] = {0, 0, 0};
pthread_mutex_t pusherM[3];
void *fumador(void *arg) {
int idFumador = *(int *) arg;
int tipo = idFumador % ... | 0 |
#include <pthread.h>
static int var_sonar_prox_data[18];
static pthread_mutex_t Sonar_Prox_Write_Lock = PTHREAD_MUTEX_INITIALIZER;
void Init_Sonar_Prox(void)
{
int ii;
pthread_mutex_unlock(&Sonar_Prox_Write_Lock);
for(ii=0; ii < 16;ii++){
var_sonar_prox_data[ii]=-1;
}
}
dou... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void ThreadClean(void* arg)
{
pthread_mutex_unlock(&mutex);
}
void* child1(void* arg)
{
while(1)
{
printf("thread 1 get running\\n");
printf("thread 1 pthread_mutex_lock return %d\\n",
pthread_mutex_lock(&mutex)
... | 0 |
#include <pthread.h>
static int capulet_count;
static int montague_count;
static pthread_mutex_t lock_access = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t clear = PTHREAD_COND_INITIALIZER;
struct person{
char * family;
char * name;
unsigned int arrival_time;
unsigned int stay_time;
};
... | 1 |
#include <pthread.h>
extern void PaUtil_DevicesChanged(unsigned, void*);
static pthread_t g_thread_id;
static pthread_mutex_t g_mutex;
static volatile sig_atomic_t g_run = 0;
static int device_list_size(void)
{
snd_ctl_t *handle;
int card, err, dev, idx;
int nb = 0;
snd_ctl_card_i... | 0 |
#include <pthread.h>
struct philosopher {
int id;
pthread_t thread;
pthread_mutex_t *left_fork;
pthread_mutex_t *right_fork;
sem_t *semaphore;
};
int rand_range(int min, int max)
{
return rand() % (max - min + 1) + min;
}
void get_forks(struct philosopher *philosopher)
{
pthread_mutex_l... | 1 |
#include <pthread.h>
static pthread_mutex_t screenMutex = PTHREAD_MUTEX_INITIALIZER;
void safe_update_screen() {
pthread_mutex_lock(&screenMutex);
update_screen();
pthread_mutex_unlock(&screenMutex);
}
char safe_get_screen_char(int multipart, int col, int row) {
if (!multipart)
pthread_mut... | 0 |
#include <pthread.h>
struct counter {
pthread_mutex_t lock;
long max;
};
static void * thread_local(void *arg)
{
int i;
struct counter *c = (struct counter *) arg;
pthread_mutex_lock(&c->lock);
for (i = 0; i < c->max; i++){
pthread_mutex_unlock(&c->lock);
pthread_mutex_lock(&c->lock... | 1 |
#include <pthread.h>
static void initDestroyer(struct destroyer *, int, int);
static void animateDestroyer(pthread_t, struct destroyer *);
void *sendDestroyer(void *arg) {
struct destroyer *ship = arg;
pthread_t destRocketThread;
srand(getpid());
while(1) {
if (!ship->isAlive) {
... | 0 |
#include <pthread.h>
pthread_t thread;
pthread_mutex_t mutex;
int clientNumber = 0;
int allClientSocket[100];
void *broadcastAllClient(void *arg);
int main() {
if(pthread_mutex_init(&mutex,0) != 0) {
printf("뮤텍스 생성에 실패했습니다.\\n");
return 0;
}
int serverSocket = socket(PF_INET... | 1 |
#include <pthread.h>
uint64_t nb;
FILE * file;
char str[60];
pthread_t thread0;
pthread_t thread1;
pthread_mutex_t lock;
pthread_mutex_t lockScreen;
const int MAX_FACTORS=64;
void print_prime_factors(uint64_t n);
int get_prime_factors(uint64_t n,uint64_t* dest);
void* thread_prime_facto... | 0 |
#include <pthread.h>
int total = 17;
int ate[5];
pthread_mutex_t turn;
pthread_t philosophers[5];
int ismax(int id)
{
int i;
int max;
int cnt =0;
max = ate[0];
for(i = 0; i < 5; i++)
{
if(ate[i] > max)
max = ate[i];
}
for(i = 0; i < 5; i++)
if(ate[i] == ate[id])
cnt++... | 1 |
#include <pthread.h>
struct tinfo {
pthread_t id;
int num;
};
int resources = 0;
int upper_bound_blocked = 0;
int lower_bound_blocked = 0;
pthread_mutex_t mx_res;
pthread_cond_t free_slot, item_ready;
void random_wait(int min, int max) {
struct timespec sleep_time;
sleep_time.tv_sec = 0;
... | 0 |
#include <pthread.h>
void *f1();
void *f2();
int n;
int m;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &f1, 0);
... | 1 |
#include <pthread.h>
pthread_mutex_t r_mutex;
pthread_mutex_t mutex;
pthread_mutex_t writer_mutex;
int writer_count=0;
int shared_data=1;
pthread_t tid;
pthread_attr_t attr;
void *writer(void *param);
void *reader(void *param);
void *writer(void *param) {
while(1) {
pthread_m... | 0 |
#include <pthread.h>
struct testdata
{
pthread_mutex_t mutex;
pthread_cond_t cond;
} td;
pthread_t thread1;
int t1_start = 0;
int signaled = 0;
void alarm_handler(int signo)
{
printf("Error: failed to wakeup thread\\n");
pthread_cancel(thread1);
exit(PTS_UNRESOLVED);
}
void *t1_func(void... | 1 |
#include <pthread.h>
pthread_mutex_t spoon[5];
void phil_init(int a, int* b, int* c)
{
*b=(a>0) ? a-1 : 5;
*c=a;
printf("Philosopher %d started\\n", a+1);
return;
}
int check_If_Spoons_Are_Available(int a, int b, int c)
{
int sum=0;
if(a&1) {
sum = pthread_mutex_trylock(&spoon[c])==0 ?... | 0 |
#include <pthread.h>
buffer_t buffer[10];
int buffer_index;
pthread_mutex_t buffer_mutex;
sem_t full_sem;
sem_t empty_sem;
void insertbuffer(buffer_t value) {
if (buffer_index < 10) {
buffer[buffer_index++] = value;
} else {
printf("Buffer overflow\\n");
}
}
buff... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int counter;
void* work_thread(void* tParam){
struct thread_data *myData;
myData=(struct thread_data *) tParam;
long me;
int radius, NUM_THREADS, xsize, ysize, part_start, part_length;
pixel* src;
pixel* halfway;
double w[... | 0 |
#include <pthread.h>
static int iter = 1000;
static int num_threads = 16;
void *thread_create(void *arg) {
return 0;
}
static inline void pthreads_bench_create() {
pthread_t tids[num_threads];
for (int i = 0; i < num_threads; i++) {
pthread_create(&tids[i], 0, thread_create, 0);
}
... | 1 |
#include <pthread.h>
int n_cats = 0;
int n_dogs = 0;
int n_birds = 0;
volatile int playingRecord[3] = {0};
clock_t start;
time_t gstart_t, gend_t;
double gdiff_t;
int gtimeProvided = 0;
volatile int catsinground = 0;
volatile int dogsinground = 0;
volatile int birdsinground = 0 ;
pthread_... | 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 pthread_mutex_t mtx3 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx4 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx5 ... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t turno;
int leyendo, escribiendo, escritores;
void inicializar_le()
{
pthread_mutex_init(&lock, 0);
pthread_cond_init(&turno, 0);
leyendo = 0;
escribiendo = 0;
escritores = 0;
}
void entrada_lectores()
{
pthread_mutex_lock(&lock);
... | 0 |
#include <pthread.h>
static bool baro_swing_available;
static int32_t baro_swing_raw;
static pthread_mutex_t baro_swing_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *baro_read(void *data )
{
struct input_event ev;
ssize_t n;
int fd_sonar = open("/dev/input/baro_event", O_RDONLY);
i... | 1 |
#include <pthread.h>
char describe[20];
int size;
} Task_t, *Task_p;
static Task_p ptask = 0;
static pthread_mutex_t hasTaskLock;
static pthread_mutex_t noTaskLock;
static pthread_cond_t hasTaskCond;
static pthread_cond_t noTaskCond;
static void init() {
ptask = 0;
pthread_mutex_init(&ha... | 0 |
#include <pthread.h>
key_t key;
int shmid;
int *cnt;
enum {STATE1, STATE2, STATE3, STATE4} state = STATE1;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond4 = PTHREAD_COND_INIT... | 1 |
#include <pthread.h>
struct foo{
int f_count;
pthread_mutex_t f_lock;
};
struct foo*
foo_alloc(void)
{
struct foo* fp;
if((fp = malloc(sizeof(struct foo))) != 0){
fp->f_count = 1;
if(pthread_mutex_init(&fp->f_lock, 0) != 0){
free(fp);
re... | 0 |
#include <pthread.h>
const int start_size = 2048;
unsigned long long FILE_SIZE;
char *buf;
int num_threads;
int fd;
int read;
char *data;
volatile char *data1;
volatile int waiting_threads;
volatile int finished_threads;
volatile int size;
pthread_cond_t ready = PTHREAD_COND_INITIALIZER;
pthr... | 1 |
#include <pthread.h>
static void ping(void);
void
thread_ping(void *arg)
{
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
struct timespec timeout;
while (1) {
ping();
timeout.tv_sec = time(0) + get_conf... | 0 |
#include <pthread.h>
int mediafirefs_unlink(const char *path)
{
printf("FUNCTION: unlink. path: %s\\n", path);
const char *key;
int retval;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pthread_mutex_lock(&(ctx->mutex))... | 1 |
#include <pthread.h>
struct cyclic {
int type;
char *prefix;
unsigned nbackups;
unsigned maxsize;
unsigned period;
time_t period_start;
FILE *file;
pthread_mutex_t lock;
pthread_mutex_t mutex;
int flock;
};
static int cyc_check_open_file(struct cyclic *cyc);
static int cyc_open_periodic... | 0 |
#include <pthread.h>
pthread_mutex_t number_mutex;
int globalnumber=0;
void * write_globalnumber()
{
globalnumber += 1;
globalnumber += 1;
globalnumber += 1;
sleep(1);
globalnumber += 1;
globalnumber += 1;
globalnumber += 1;
printf("%da\\n",globalnumber);
printf("b\\n");
pthrea... | 1 |
#include <pthread.h>
int thread_count;
long current_thread = 0;
pthread_mutex_t sequence_mutex;
pthread_cond_t ok_to_proceed;
void Usage(char* prog_name);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
if (argc != 2) Usage(ar... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.