text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct v {
int row;
int column;
};
void *worker(void* coord);
void *show_matrix();
pthread_t my_thread[(3*3)+1];
int A[3][2] = { {1,4}, {2,5}, {3,6} };
int B[2][3] = { {8,7,6}, {5,4,3} };
int C[3][3];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void print_... | 1 |
#include <pthread.h>
static unsigned int gSharedValue = 0;
static int gReaderCount = 0, gWaitingReaderCount = 0;
pthread_mutex_t gSharedMemLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t gReadPhase = PTHREAD_COND_INITIALIZER;
pthread_cond_t gWritePhase = PTHREAD_COND_INITIALIZER;
void *rea... | 0 |
#include <pthread.h>
int q[3];
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 < 3)
... | 1 |
#include <pthread.h>
int p;
int n;
int t;
double* A;
double* x;
double* c;
double* y;
int counter = 0;
pthread_mutex_t mutex;
pthread_cond_t cond_var;
pthread_barrier_t barrier;
void Gen_matrix(double A[], int n);
void Gen_vectorXC(double x[], double c[], int n);
void *Pth_mat_vect(void* ran... | 0 |
#include <pthread.h>
static char *page;
static int page_nr = 10;
static int page_len;
static pthread_mutex_t _syscall_mtx;
void usage(const char *argv0)
{
exit(1);
}
static void recover(void)
{
printf("hello: recovered from pagefault\\n");
exit(0);
}
static void pgflt_... | 1 |
#include <pthread.h>
void *thread_fmain(void *);
void *thread_mmain(void *);
void man_leave();
void man_enter();
void woman_leave();
void woman_enter();
void use_rr();
void do_other_stuff();
int get_simple_tid(pthread_t);
int maleCount = 0;
int femaleCount=0;
pthread_t threadIDs[2 +2];
sem_t... | 0 |
#include <pthread.h>
int availableRooms = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* agentA(void* arg){
pthread_mutex_lock(&mutex);
if(availableRooms > 0){
availableRooms -= 1;
printf("Available rooms = A %d\\n", availableRooms);
}
pthread_mut... | 1 |
#include <pthread.h>
struct gsm_buf_t gsm;
void *thread_gsm(void *arg)
{
char cmd[512] = {0};
while(1)
{
gsm_recv(gsm_fd, "0", "1");
memset(cmd, 0, sizeof(cmd));
pthread_rwlock_rdlock(&gsmcmd_mutex);
memcpy(cmd,gsm_cmd,strlen(gsm_cmd));
pthread_rwlock_unlock(&gsm_mutex);
if(strnc... | 0 |
#include <pthread.h>
long long biggest = 100;
int m;
int n;
pthread_t* thread_handles;
int* array;
} arg_struct;
pthread_mutex_t mutex;
void* Find_greatest(void* args) {
int local_big = 100;
arg_struct* t = (arg_struct*)args;
int* array = t->array;
for (int i = 0; i < n; i++) {
if (l... | 1 |
#include <pthread.h>
pthread_mutex_t pal1, pal2, pal3, pal4, pal5;
void * codigoFilos1(){
printf("Hola soy el filosofo 1 y estoy pensando\\n");
pthread_mutex_lock(&pal1);
printf("Yo filos 1 voy a comer un poco\\n");
pthread_mutex_unlock(&pal1);
pthread_... | 0 |
#include <pthread.h>
extern pthread_mutex_t message_mutex;
extern pthread_cond_t message_consume_cond;
static pthread_t lc_threads[10];
static void* thread_message_consume(void* arg);
void threadpool_message_consume_init()
{
int i = 0;
for(i=0; i<10; i++)
{
Pthread_create(&lc_threads[i]... | 1 |
#include <pthread.h>
void read_from_click_thread(void *p) {
struct device_data* dev = (struct device_data*)p;
unsigned int ret = 0, j;
unsigned char buff[4] = {0, 0, 0, 0};
unsigned long rfc_sleep_time = THREAD_SLEEP_TIME;
while(1) {
if(pCMDValue.exit_time>0 && pCMDValue.exit_time<time(0... | 0 |
#include <pthread.h>
void *cmd_serail(void * arg) {
char readbuffer[256];
int readsize, itmp;
int batteryNumber = 0;
int serialfd = (int) arg;
int i;
readsize = 0;
while (1) {
memset(readbuffer, 0, sizeof(char) * 100);
for (i = 0; i < 3; i++) {
itmp = read(serialfd, readbuffer[... | 1 |
#include <pthread.h>
int * enteroCompartido;
pthread_mutex_t * semaforo;
void * procedimiento(void * in)
{
int tid = (int) in, i;
for(i = 0; i < 10000; i++)
{
pthread_mutex_lock(semaforo);
enteroCompartido[0]++;
if(!(i+1 < 10000))
printf("Hola soy la hebra %d y el ultimo numero que de... | 0 |
#include <pthread.h>
static uint8_t sys_irq_disable_counter;
static pthread_mutexattr_t critical_mutexattr;
static pthread_mutex_t critical_mutex_id;
void platform_critical_init(void)
{
int err = pthread_mutexattr_init(&critical_mutexattr);
assert(err == 0);
err = pthread_mutexatt... | 1 |
#include <pthread.h>
static void
to_worker_thread (struct job_details *job)
{
struct job_details *ljob;
my_printf("%s: giving job %d to workers sched: %s \\n", __FUNCTION__, job->seqno,
((sched_policy == SCHED_FCFS) ? "fcfs" : "sjf"));
pthread_mutex_lock(&work... | 0 |
#include <pthread.h>
int main()
{
int fd = shm_open("shm1", O_CREAT | O_RDWR, 0644);
if (fd < 0)
{
printf("shm_open error\\n");
exit(-1);
}
printf("fd=%d\\n", fd);
int len = sizeof(struct Test);
ftruncate(fd, len);
printf("ftruncate\\n");
printf("len=%d\\n", len);
struct Test* p = (... | 1 |
#include <pthread.h>
pthread_mutex_t kuaizi[5];
void *zhexuejia( void *arg ) {
int i = (int) arg;
int left, right;
if ( i == 0 ) {
left = 0;
right = 5 - 1;
} else {
left = i;
right = i - 1;
}
while ( 1 ) {
if ( i < 5 - 1 ) {
... | 0 |
#include <pthread.h>
int value;
pthread_mutex_t mutex;
pthread_cond_t cond;
}sema_t;
int N=3;
double sleepTime;
int mailBox[2];
sema_t read_sema;
sema_t write_sema;
int readCount=0;
int circleCount;
void sema_init(sema_t *sema, int value)
{
sema->value = value;
pthread_mutex_ini... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t mutex_count;
pthread_cond_t cond_limit;
pthread_cond_t cond_count;
void *counter(void *t) {
long id = (long) t;
while (1) {
pthread_mutex_lock(&mutex_count);
if (count == 12) {
printf("Thread %ld chego... | 0 |
#include <pthread.h>
int num_threads;
int count;
pthread_mutex_t *mutexes;
none,
one,
two
} utensil;
int phil_num;
int course;
utensil forks;
}phil_data;
int *numList;
phil_data *philosophers;
void *eat_meal(void *ptr){
phil_data *phil_ptr = ptr;
int num = phil_ptr->ph... | 1 |
#include <pthread.h>
int spuf = -1;
pthread_mutex_t pmut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t answ = PTHREAD_COND_INITIALIZER;
const char *signa = SIGNATUR;
int
main(int argc, char **argv)
{
char *ptr;
int sfd, n, fda;
const int on = 1;
sigset_t set;
pthread_t tid;
... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[5];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
t... | 1 |
#include <pthread.h>
struct foo {
int id;
int refs;
struct foo* next;
pthread_mutex_t mutex;
};
int hash(int id) {
return id % 10;
}
struct foo* map[10];
pthread_mutex_t hash_lock;
struct foo* alloc(int id) {
struct foo* p;
if ((p = (struct foo*)malloc(sizeof(struct foo))) != 0) ... | 0 |
#include <pthread.h>
pthread_mutex_t * mutex_current_weight;
pthread_cond_t * allow_robot;
void * start_shopping(void *);
int * current_weight;
int * max_weight;
int main(){
srand(time(0));
current_weight = (int *) malloc(10 * sizeof(int));
max_weight = (int *) malloc(10 * sizeof(int));
... | 1 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing1(void *arg)
{
int j = 0;
printf("%s entering...", __func__);
fflush(stdout);
while(j < 10)
{
pthread_mutex_lock(&lock);
printf("%s done\\n", __func__);
if(j == ... | 0 |
#include <pthread.h>
pthread_mutex_t lock_a = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_b = PTHREAD_MUTEX_INITIALIZER;
int notify_a = 0;
int notify_b = 0;
void *func(void *arg)
{
pthread_mutex_lock(&lock_b);
printf("func thread get lock_b, wanna get lock_a! \\n");
notify_b = 1;
while (... | 1 |
#include <pthread.h>
struct prodcons {
int buffer[16];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct prodcons * b)
{
pthread_mutex_init(&b->lock, 0);
pthread_cond_init(&b->notempty, 0);
pthread_cond_ini... | 0 |
#include <pthread.h>
void *Productor(void *arg);
void *Consumidor(void *arg);
int n_elementos;
int pos_p = 0;
int pos_c = 0;
int buffer[3096];
void main(int argc, char *argv[]){
pthread_t th1, th2, th3, th4, th5, th6;
pthread_create(&th1, 0, Consumidor, 0);
pthread_create(&th2, 0, P... | 1 |
#include <pthread.h>
const int MAX_THREADS = 1024;
const int MSG_MAX = 100;
void* send_msg(void* rank);
void get_args(int argc, char* argv[]);
void usage(char* prog_name);
long thread_count;
int* message_available;
char** messages;
pthread_mutex_t mutex;
int main(int argc, char* argv[] ) {
lo... | 0 |
#include <pthread.h>
int id;
int track;
int station;
int stationsN;
}arg_t;
pthread_mutex_t *connection_mutex,
*internal_mutex[2];
int *stations, not_assigned;
void select_station_and_track(int *station, int *track){
int my_station, my_track, i;
my_track = rand()%2;
i = rand()%n... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread1(void*);
void *thread2(void*);
int i = 1;
int main(void){
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a,0,thread2,(void*)0);
pthread_create(&... | 0 |
#include <pthread.h>
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
sem_t blanks;
sem_t datas;
int ringBuf[100] = {0};
void* productRun(void* arg)
{
int i = 0;
while(1)
{
usleep(100000);
sem_wait(&blanks);
pthread_mutex_lock(&mylock);
int data = rand()%100+1;
while(rin... | 1 |
#include <pthread.h>
int ismaster_guess() {
if (((long)ismaster_guess) & 0x4000)
return 1;
return 0;
}
pthread_mutex_t mutex;
void* receive_bit(void* unused) {
if (pthread_mutex_trylock(&mutex) == 0) {
pthread_mutex_unlock(&mutex);
return (void*) 0;
}
return (void*) 1;
}
vol... | 0 |
#include <pthread.h>
int NUM_FILES;
int SIZE;
int NUM_THREADS;
char *DESTINATION_DIR;
int BUF_SIZE;
int COUNTER;
pthread_mutex_t LOCK;
void *perform_writes(void *args);
void perform_write(char *path);
int main(int argc, char *argv[]) {
NUM_FILES = strtol(argv[1], 0, 0);
SIZE = strtol(ar... | 1 |
#include <pthread.h>
struct lectred {
pthread_mutex_t m;
pthread_cond_t cl, ce;
int ecriture;
int nb_lecteurs, nb_lect_att, nb_ecri_att;
};
struct linked_list {
int nb;
struct linked_list *next;
};
struct linked_list_head {
struct lectred sync;
struct linked_list *head;
};
struct l... | 0 |
#include <pthread.h>
struct thr_arg
{
int x;
int *sh_mem;
};
pthread_mutex_t lock;
void *thr_func(void *arg)
{
int i;
pthread_mutex_lock(&lock);
i = ((struct thr_arg *)arg)->x;
((struct thr_arg *)arg)->sh_mem[i-1] = i;
pthread_mutex_unlock(&lock);
return ;
}
int main()
{
pthread_t ... | 1 |
#include <pthread.h>
int nbBonbons;
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
void sigint_handler(int s)
{
pthread_mutex_destroy(&mut);
exit(0);
}
void* producteur(void* arg)
{
struct timespec tps;
while(1)
{
tps.tv_sec=rand()%2;
tps.tv_nsec=rand()%1000000000;
nanosleep(&tps... | 0 |
#include <pthread.h>
int value;
struct __node_t *next;
} node_t;
node_t *head;
node_t *tail;
pthread_mutex_t headLock;
pthread_mutex_t tailLock;
} queue_t;
void Queue_Init(queue_t *q) {
node_t *tmp = (node_t*)malloc(sizeof(node_t));
tmp->next = 0;
q->head = q-... | 1 |
#include <pthread.h>
void *thread_shuttle(void *args);
void *thread_rocket(void *args);
void *thread_nasa(void *args)
{
pthread_detach(pthread_self());
pthread_t tid_shuttle;
pthread_t tid_rocket;
if (0 != pthread_create(&tid_rocket, 0, thread_rocket, 0))
{
pr... | 0 |
#include <pthread.h>
double** matResult;
double** mat1;
double** mat2;
int matSize1x;
int matSize1y;
int matSize2x;
int matSize2y;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *runner(void *args) {
int index = *((int *) args);
double partialSum = 0;
for (int j = 0; j < ma... | 1 |
#include <pthread.h>
void *hello(void *arg){
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int p;
int *id=(int*)arg;
int somme[5];
p=1000000*(*id);
pthread_mutex_lock(& mutex);
printf("%d:hello world et mon numero est %d\\n",*id,p);
pthread_mutex_unlock(& mutex);
somm... | 0 |
#include <pthread.h>
int max = 10 * 1000 * 1000;
pthread_mutex_t mutex;
pthread_cond_t cond_inc;
pthread_cond_t cond_dec;
int val;
void * thr(void * arg)
{
int i;
for (i = 0; i < max; i++) {
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
}
}
void * thr_inc(void * arg)
{
i... | 1 |
#include <pthread.h>
pthread_mutex_t gm;
struct foo{
int id;
int arr[15];
struct foo *head;
};
struct thread_data {
int tid;
struct foo *local_data;
};
void *t(void *args){
struct thread_data *data = (struct thread_data*)args;
int tid = data->tid;
struct fo... | 0 |
#include <pthread.h>
void *thread_function(void *);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int main()
{
pthread_t thread_id[10];
int i, j;
for(i=0; i < 10; i++)
{
pthread_create( &thread_id[i], 0, thread_function, 0 );
}
for(j=0; j < 10... | 1 |
#include <pthread.h>
int waiting_students;
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
void* student_thread(void* param){
int order = (int)param;
int seed = (int)param*1000;
int sleeptime = (rand_r(&seed)%3)+1;
int helptime = 2;
printf(" Student %d is programming for %... | 0 |
#include <pthread.h>
pthread_mutex_t calculating = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t done = PTHREAD_COND_INITIALIZER;
void *expensive_call(void *data)
{
int oldtype;
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);
for ( ; ; )
{
}
pthread_cond... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[800];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
... | 0 |
#include <pthread.h>
struct dot_data {
double *a;
double *b;
double sum;
int veclen;
};
pthread_mutex_t mutex_sum;
long int sum;
pthread_t threads[4];
struct dot_data dot_str;
void * dot_prod(void *);
int main()
{
int status;
long int i;
double * a;
double * b;
long int t_no;
pthrea... | 1 |
#include <pthread.h>
int glob = 0;
pthread_mutex_t glob_mutex;
void *odd(void *unused)
{
int i;
int local = glob;
for(i=0;i<100;i++)
{
if(local % 2 == 1){
printf("%d....\\n", glob);
pthread_mutex_lock(&glob_mutex);
glob++;
pthread_mutex_unlock(&glob_mutex);
sleep(1);
}
... | 0 |
#include <pthread.h>
int args_index_in;
int args_index_out;
int factors_index_in;
int factors_index_out;
int* args_buffer;
int** factors_buffer;
int g_argc;
int count_down;
int wait;
int* factoring_func(int n)
{
int* factors = malloc(sizeof(int) * (16));
int i = 2;
int k = 0;
... | 1 |
#include <pthread.h>
pthread_mutex_t *fourchettes;
pthread_t *philosophes;
int nombre_philosophes;
void* activite_philo(void* arg)
{
int right=0;
int left=0;
int philoPos = (int)(long int)arg;
int gauche = philoPos;
int droite = philoPos - 1;
if(droite == -1)
{
droite = nombre_phi... | 0 |
#include <pthread.h>
char buffer [10];
int nextin = 0, nextout = 0;
int count = 0;
pthread_cond_t notfull= PTHREAD_COND_INITIALIZER;
pthread_cond_t notempty= PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex =PTHREAD_MUTEX_INITIALIZER;
void produce_char( void * args ){
int i;
char x= 65... | 1 |
#include <pthread.h>
struct queue_root {
struct queue_head *in_queue;
struct queue_head *out_queue;
pthread_mutex_t lock;
};
struct queue_root *ALLOC_QUEUE_ROOT(void)
{
struct queue_root *root =
malloc(sizeof(struct queue_root));
pthread_mutex_init(&root->lock, 0);
root->in_q... | 0 |
#include <pthread.h>
long balance = 1000000;
long withdraw1 = 600000;
long deposit = 500000;
pthread_mutex_t lock;
void *withdraw_func(void *val)
{
pthread_mutex_lock(&lock);
long wd = (long)val;
printf("balance before withdrawing %ld is %ld\\n",wd,balance);
sleep(1)... | 1 |
#include <pthread.h>
const static unsigned int NUM_THREADS = 4;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
volatile int available = 1;
unsigned spinLocked;
unsigned spinUnlocked;
volatile unsigned iterations;
volatile unsigned spurious;
vo... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t mysignal;
int waiting=0;
volatile int state=0;
void barrier(){
int mystate;
pthread_mutex_lock (&lock);
mystate=state;
waiting++;
if (waiting==8){
waiting=0; state=-1;
}
pthread_mutex_unlock (&lock);
while (mystat... | 1 |
#include <pthread.h>
void *server_process_requests(void *arg) {
struct server_request *req = arg;
struct server_connection *conn = req->conn;
struct Message *msg = req->msg;
int rc;
free(req);
if (msg->Type == TypeRead) {
rc = conn... | 0 |
#include <pthread.h>
int q[3];
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 < 3)
... | 1 |
#include <pthread.h>
sem_t emptyPot;
sem_t fullPot;
void *savage (void*);
void *cook (void*);
static pthread_mutex_t servings_mutex;
static pthread_mutex_t print_mutex;
static int servings = 15;
int getServingsFromPot(void)
{
int retVal;
if (servings <= 0)
{
sem_post (&em... | 0 |
#include <pthread.h>
void *sum(void *p);
{
int id;
int * myMem;
} msg;
unsigned long int psum[8];
unsigned long int sumtotal = 0;
unsigned long int n;
int numthreads;
pthread_mutex_t mutex;
int main(int argc, char **argv) {
pthread_t tid[8];
int i, myid[8];
struct timeval... | 1 |
#include <pthread.h>
struct protoent *getprotobynumber(int proto)
{
char *buf = _proto_buf();
if (!buf)
return 0;
return getprotobynumber_r(proto, (struct protoent *) buf,
buf + sizeof(struct protoent), PROTO_BUFSIZE);
}
struct protoent *getprotobynumber_r(int proto, struct protoen... | 0 |
#include <pthread.h>
int cine[7][20];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t kuz = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t consume_t = PTHREAD_COND_INITIALIZER;
pthread_cond_t sits = PTHREAD_COND_INITIALIZER;
pthread_cond_t produce_t = PTHREAD_COND_INITIALIZER;
void c... | 1 |
#include <pthread.h>
int quitflag = 0;
sigset_t mask;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* thr_fn(void* arg)
{
int err,signo;
while(1)
{
err = sigwait(&mask,&signo);
if(err != 0)
exit(-1);
switch(signo)
{
ca... | 0 |
#include <pthread.h>
pthread_mutex_t running_mutex;
int running_threads = 0;
int isprime(int num) {
int start_check = (num/2)+1;
static int prime = 1;
static int notprime = 0;
while( start_check > 1 ) {
if( (num % start_check) == 0 )
return notprime;
... | 1 |
#include <pthread.h>
int start=0;
pthread_t* thread;
struct buffer_struct
{
char buffer[100];
pthread_mutex_t lock;
int rear;
int front;
};
struct buffer_struct* PC;
struct arg_struct
{
pthread_t tid;
struct buffer_struct* Producer;
struct buffer_struct* Consumer;
};
s... | 0 |
#include <pthread.h>
int x = 0;
pthread_mutex_t mutex_x;
pthread_t threads[5];
void *client(void *threadid)
{
int tid;
tid = (int)threadid;
pthread_mutex_lock(&mutex_x);
fprintf(stdout, "TID %d: mutex_lock \\n", tid);
x++;
fprintf(stdout, "TID %d:mutex modifying x value: %d \\n", tid, x... | 1 |
#include <pthread.h>
int
pthread_rwlock_rdlock (pthread_rwlock_t * rwlock)
{
int result;
pthread_rwlock_t rwl;
if (rwlock == 0 || *rwlock == 0)
{
return EINVAL;
}
if (*rwlock == PTHREAD_RWLOCK_INITIALIZER)
{
result = pte_rwlock_check_need_init (rwlock);
... | 0 |
#include <pthread.h>
double timeval_diff(struct timeval *a, struct timeval *b)
{
return (double)(a->tv_sec + (double)a->tv_usec/1000000) - (double)(b->tv_sec + (double)b->tv_usec/1000000);
}
struct list_node_s
{
int data;
struct list_node_s* next;
pthread_mutex_t mutex;
};
int thread_count;
... | 1 |
#include <pthread.h>
double cur_time() {
struct timespec ts[1];
clock_gettime(CLOCK_REALTIME, ts);
return ts->tv_sec + ts->tv_nsec * 1.0E-9;
}
void think(double s) {
double t0 = cur_time();
while (cur_time() - t0 < s) { }
}
double enter_lock_time;
double return_from_lock_tim... | 0 |
#include <pthread.h>
void* thread_nvadata(void* arg)
{
while(1)
{
sleep(2);
printf("thread_nvadata activé => tchuiiiiiiiiii pouf\\n");
}
}
float GetPitch()
{
pthread_mutex_lock(&mutex_regulation);
float x_local = 0;
pthread_mutex_unlock(&mutex_regulation);
return x_local;
}
fl... | 1 |
#include <pthread.h>
volatile unsigned char PRESSED1=0;
volatile unsigned char PRESSED2=0;
volatile int CLOSE[8][5];
int idx1=0;
int idx2=0;
extern pthread_mutex_t mIdx1;
extern pthread_mutex_t mIdx2;
void *serial_BUTTON(void * parm)
{
int fd,c,... | 0 |
#include <pthread.h>
struct bench{
int count;
pthread_mutex_t lock,barber;
}*fp;
void bench_init(){
if((fp=malloc(sizeof(struct bench)))!=0){
fp->count=0;
if(pthread_mutex_init(&fp->lock,0)!=0){
free(fp);
}
}
}
void haircut(){
pthread_mutex_lock(&fp->barber);
pth... | 1 |
#include <pthread.h>
struct shared_data_node {
struct shared_data_t *shared_data;
struct shared_data_node *next;
};
struct shared_data_node *shared_data_arr;
struct shared_data_node *head;
int stack_size;
pthread_mutex_t headlock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t stack_not_e... | 0 |
#include <pthread.h>
pthread_t *threads;
pthread_mutex_t mutex;
int threads_count, records_count, fd;
char* word;
void* thread_func(void *data){
pthread_t self;
int read_count,i,j,record_id,actual_read_count,word_len;
char *buf,*ptr;
buf=malloc(1024*records_count);
word_len=strlen(word)... | 1 |
#include <pthread.h>
pthread_mutex_t mutex ;
void display(int n, char letter)
{
int i, j;
for (j = 1; j < n; j++) {
pthread_mutex_lock(&mutex) ;
for (i = 1; i < 100000; i++);
printf("%c", letter);
fflush(stdout);
pthread_mutex_unlock(&mutex) ;
}
}
void *threadA(void *unused)
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t prod_cv = PTHREAD_COND_INITIALIZER;
pthread_cond_t cons_cv = PTHREAD_COND_INITIALIZER;
int buf[50];
int current_size;
int tail, head;
} Q_t;
Q_t g_Q;
int g_counter;
void enqueue(Q_t *Q, int n)
{
wh... | 1 |
#include <pthread.h>
static pthread_mutex_t locka = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t lockb = PTHREAD_MUTEX_INITIALIZER;
extern int errno;
static void *thread_func1(void *arg)
{
int retcode = 0;
for (;;)
{
pthread_mutex_lock(&lockb);
printf("thread_func1 lock b get... | 0 |
#include <pthread.h>
int global_int;
int *dint;
int *heap_int[1];
int block_write;
pthread_mutex_t mlock;
void *fn(void *args){
int *t = (int*)args;
fprintf(stderr, "smv %d read global_int: %d\\n", *t, global_int);
pthread_mutex_lock(&mlock);
global_int++;
printf("smv ... | 1 |
#include <pthread.h>
uint32_t inode;
uint32_t indx;
uint8_t writing;
uint32_t active_readers_cnt;
uint32_t waiting_readers_cnt;
uint32_t waiting_writers_cnt;
pthread_cond_t rcond,wcond;
struct chunkrec *next,**prev;
} chunkrec;
static pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;
st... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond0 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
unsigned thread = 0;
void fail(char *msg) {
fprintf(stderr, "Error: %s\\n"... | 1 |
#include <pthread.h>
void *thread_fmain(void *);
void *thread_mmain(void *);
void man_leave();
void man_enter();
void woman_leave();
void woman_enter();
void use_rr();
void do_other_stuff();
int get_simple_tid(pthread_t);
int maleCount = 0;
int femaleCount =0;
pthread_t threadIDs[2 +2];
sem_... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond_leitor;
pthread_cond_t cond_escritor;
int escritores = 0;
int leitores = 0;
int querEscrever = 0;
{
int contador;
int idThread;
}Arquivo;
Arquivo arquivo;
void inicializa_leitor(){
pthread_mutex_lock(&mutex);
while(escritor... | 1 |
#include <pthread.h>
pthread_mutex_t bd = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t cl = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t turno = PTHREAD_MUTEX_INITIALIZER;
int l = 0;
void* leitores(void* arg){
time_t t;
int id = *((int *) arg);
srand((unsigned) time(&t));
printf("Leitor ... | 0 |
#include <pthread.h>
int balance;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int rnd = 100000;
void *p1(void *ptr)
{
for(int i=0; i<rnd; i++){
pthread_mutex_lock(&mutex);
++balance;
pthread_mutex_unlock(&mutex);
}
return 0;
}
void *p2(void *ptr)
{
... | 1 |
#include <pthread.h>
struct msg
{
int num;
struct msg *next;
};
struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_cond_t has_consume = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZ... | 0 |
#include <pthread.h>
{
int thread_n;
}TParam,*PParam;
int global_counter=1;
int threads_waiting=0;
pthread_mutex_t mtx1=PTHREAD_MUTEX_INITIALIZER,
mtx2=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond;
void* worker_thread(void *param)
{
PParam pp=(PParam)param;
printf("thread %d st... | 1 |
#include <pthread.h>
int piao = 100;
pthread_mutex_t mut;
void* tprocess1(void* args){
int a = 0;
while(1){
pthread_mutex_lock(&mut);
if(piao>0){
sleep(1);
piao--;
printf("xiancheng 1----------------»¹Ê£%dÕÅƱ\\n",piao);
... | 0 |
#include <pthread.h>
int
oskit_sem_unlink(const char *name)
{
int i;
sem_t *sem;
pthread_mutex_lock(&semn_space.semn_lock);
for (i = 0 ; i < semn_space.semn_arraylen ; i++) {
if (semn_space.semn_array[i]
&& (strcmp(semn_space.semn_array[i]->sem_name, name)
== 0)) {
sem = ... | 1 |
#include <pthread.h>
static unsigned long rnd = 11;
int buffer[10];
int out = 0;
int in = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *producer(void *param);
void *consumer(void *param);
int genrnd(unsigned int n);
void printbuf();
int main(int argc, const char *argv[])
{
pth... | 0 |
#include <pthread.h>
struct mq_info {
char *msg_ptr;
size_t msg_size;
volatile int was_written;
pthread_mutex_t msg_snd_mutex;
pthread_cond_t msg_snd_cv;
pthread_mutex_t msg_rcv_mutex;
pthread_cond_t msg_rcv_cv;
};
static struct mq_info msg_table[MQ_MAXCOUNT]... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void *prod_func();
void *cons_func();
int ret,fd;
int main()
{
int ret1,ret2;
pthread_t producer,consumer;
ret1=pthread_create(&producer,0,&cons_func,0);
ret2=pthread_create(&consumer,0,&prod_func,0);
if(ret1... | 0 |
#include <pthread.h>
int counter;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void print_message() {
pthread_mutex_lock(&mutex1);
printf("thread id =%ld\\n", pthread_self());
counter++;
printf("counter value is %d\\n", counter);
pthread_mutex_unlock(&mutex1);
}
int main()
{
pthread... | 1 |
#include <pthread.h>
struct play_t
{
char fname[256];
off_t flen;
off_t ldlen;
int pos;
int fi;
int fo;
};
static pthread_t tid_play;
static pthread_t tid_load;
static volatile int playing = 0;
static volatile int loading = 0;
static volatile int _pause = 0;
static struct play_t play;
... | 0 |
#include <pthread.h>
pthread_mutex_t bag_mutex, sum_mutex, min_mutex, max_mutex;
int numWorkers;
int next_row = 0;
double read_timer() {
static bool initialized = 0;
static struct timeval start;
struct timeval end;
if( !initialized )
{
gettimeofday( &start, 0 );
... | 1 |
#include <pthread.h>
struct var_m
{
pthread_mutex_t var_mutex;
};
int var;
struct var_m pvar_m[1];
void var_inc(void* i);
int main()
{
pthread_t ptchild[2];
int num[2];
num[0] = 0;
num[1] = 1;
int timer = 0;
pthread_mutex_init(&pvar_m->var_mutex, 0);
printf("timer: %d\... | 0 |
#include <pthread.h>
int buf = 0;
pthread_mutex_t mutex;
void thread_func1()
{
while(buf < 30) {
pthread_mutex_lock(&mutex);
buf++;
printf("thread1:%d\\n", buf);
sleep(5);
pthread_mutex_unlock(&mutex);
sleep(2);
}
}
void thread_func2()
{... | 1 |
#include <pthread.h>
struct bhfs_open_file *bhfs_f_list;
pthread_mutex_t bhfs_f_list_mutex;
struct bhfs_open_file *bhfs_new_open_file() {
struct bhfs_open_file *new_file;
new_file = malloc(sizeof(struct bhfs_open_file));
new_file->fh = 0;
new_file->size = 0;
new_file->pid = ... | 0 |
#include <pthread.h>
struct suspender {
int s_sock;
suspender *s_next;
};
static pthread_mutex_t sus_lock = PTHREAD_MUTEX_INITIALIZER;
static suspender *suspenders;
void *susp_thread_main(void *closure)
{
while (1) {
pthread_mutex_lock(&sus_lock);
suspender *sp... | 1 |
#include <pthread.h>
struct jc_type_file_seq_abort {
struct jc_type_file_comm_hash *comm_hash;
};
static struct jc_type_file_seq_abort global_abort;
static int jc_type_file_seq_abort_init( struct jc_comm *jcc
)
{
return global_abort.comm_hash->init(global_abort.comm_hash, jcc);
}
static int... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.