text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_cond_t* cond;
pthread_cond_t* ready;
pthread_mutex_t* mutex;
char ExistUserDB(char * user){
cond = (pthread_cond_t*) (shmPointer + COND_OFFSET);
ready = (pthread_cond_t*) (shmPointer + COND2_OFFSET);
mutex = (pthread_mutex_t*)(shmPointer + MUTEX_OFFSET);
pthr... | 1 |
#include <pthread.h>
int myglobal=0;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_function(void *arg) {
int i,j;
for ( i=0; i<20; i++ ) {
pthread_mutex_lock(&mymutex);
j=myglobal;
j=j+1;
printf(".");
fflush(stdout);
sleep(1);
myglobal=j;
pthr... | 0 |
#include <pthread.h>
pthread_mutex_t m;
int s;
void* thr1(void* arg)
{
int l = __VERIFIER_nondet_int(0, 1000);
l = 4;
pthread_mutex_lock (&m);
s = l;
__VERIFIER_assert (s == l);
pthread_mutex_unlock (&m);
return 0;
}
int main()
{
s = __VERIFIER_nondet_int(0, 1000);
... | 1 |
#include <pthread.h>
void *functionA();
void *functionB();
int var_A, var_B = 0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
int main(){
pthread_t thread1, thread2;
int rc1, rc2;
printf("\\033[2J");
printf("Deadlock experi... | 0 |
#include <pthread.h>
pthread_mutex_t coarse_mutex;
void* value;
int key;
volatile struct _setos_node* next;
pthread_mutex_t mutex;
} setos_node;
setos_node* head;
int setos_init(void)
{
if (pthread_mutex_init(&coarse_mutex, 0) != 0) {
printf("mutex init failed\\n");
}
... | 1 |
#include <pthread.h>
int wait_reply_server_greeter(struct ssh_session_s *session, struct timespec *expire, unsigned int *error)
{
struct ssh_receive_s *receive=&session->receive;
struct rawdata_queue_s *queue=&receive->rawdata_queue;
int result=0;
pthread_mutex_lock(&queue->... | 0 |
#include <pthread.h>
const long long infinity = 1e8;
long long *primes;
long long *notPrime;
long long N, K, n, last, last1;
pthread_mutex_t mutex;
long long min(long long a, long long b) {
return a <= b ? a : b;
}
struct Segment {
long long start, finish;
};
void* findPrimeNumbers... | 1 |
#include <pthread.h>
const int RMAX = 100;
int offsetValue[20];
pthread_t thread[20];
int iThread[20];
int numLockThread[20];
int changeThread[20];
int tempThread[20];
pthread_mutex_t locks[20 +1];
void Usage(char* prog_name);
void Get_args(int argc, char* argv[], int* n_p, char* g_i_p);
void G... | 0 |
#include <pthread.h>
double start_time, end_time;
pthread_mutex_t palindromicsMutex;
pthread_mutex_t wordsMutex;
long amountWords;
long position;
struct thread_data {
long noPalindromes;
char** words;
FILE* palindromicsfd;
};
double read_timer()
{
static bool initialized = 0;
... | 1 |
#include <pthread.h>
struct sockaddr_in addr;
int fd;
int uid;
char name[64];
} client_t;
pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER;
volatile int thread_count = 0;
static int connfd;
void *handle_input(void *arg) {
char input[1024];
memset(input, 0, sizeof(input));
while... | 0 |
#include <pthread.h>
void *philosopher(void *arg);
int food_left();
void pick_chop(int p, int c);
void drop_chop(int c1, int c2);
int get_ticket();
void return_ticket();
pthread_mutex_t food_lock;
pthread_mutex_t chopstick[5];
pthread_t philos[5];
sem_t phil_sem;
int main(int argn, char* arg... | 1 |
#include <pthread.h>
int sumTotal;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_function(void *arg) {
unsigned int index;
unsigned int sum = 0;
index = *((unsigned int *) (arg));
for ( unsigned int i = index * 25; i < ((index+1)*25); i++ )
sum += i;
pt... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void* funcCount1();
void* funcCount2();
int count = 0;
int main(){
pthread_t thread1, thread2;
pthread_create(&thread1, 0, &funcCount1, 0);
pthread_creat... | 1 |
#include <pthread.h>
void pthread_barrier ();
void create_threads ();
void join_threads ();
void read_x ();
void read_a ();
void print_y ();
void * Pth_mat_vect (void * rank);
void get_offset (int rank, int threads, long rows, long * start, long * end);
int thread_count;
pthread_t * t_ids;
sem_t ... | 0 |
#include <pthread.h>
int n = 100;
pthread_cond_t sig1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t sig2 = PTHREAD_COND_INITIALIZER;
int flag1 = 0, flag2 = 0;
pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut2 = PTHREAD_MUTEX_INITIALIZER;
void* thread_function1(void*... | 1 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (c... | 0 |
#include <pthread.h>
int test_phil(struct dining_room *room, int phil)
{
if(room->phil_state[phil] == HUNGRY && room->phil_state[right_neighbor(room, phil)] != EATING && room->phil_state[left_neighbor(room,phil)] != EATING){
room->phil_state[phil] = EATING;
display_states(room);
... | 1 |
#include <pthread.h>
void *process1(void * arge);
void *process2(void * arge);
void *process3(void * arge);
pthread_mutex_t mux;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;
int main()
{
pt... | 0 |
#include <pthread.h>
sem_t producer_sem;
sem_t consumer_sem;
pthread_mutex_t mutex;
int buffer[10];
int duration = 20;
int length = 0;
void *producer(void *arg)
{
int str;
str=(int)arg;
for(int i = 0; i < duration; i++) {
sem_wait(&producer_sem);
pthread... | 1 |
#include <pthread.h>
int valoare = 5;
int contor = 0;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void * func(void * val) {
int v;
v = *(int*)val;
for(;;) {
pthread_mutex_lock(&mtx);
if (contor == 20) exit(1);
if(v == valoare){
printf("%d \\n",valoare);
printf("%d... | 0 |
#include <pthread.h>
char** theArray;
pthread_mutex_t mutex;
int aSize = 100;
int usr_port;
void* ServerEcho(void *args);
int main(int argc, char * argv []){
int n = atoi(argv[2]);
usr_port = atoi(argv[1]);
if( (n==10)||(n==100)||(n==1000)||(n==10000) ){
aSize=n;
}
struct sockaddr... | 1 |
#include <pthread.h>
void mwmr_read( struct mwmr_s *fifo, void *mem, size_t len )
{
struct mwmr_status_s *state = fifo->status;
size_t got = 0;
uint8_t *ptr = (uint8_t *)mem;
assert ( len % fifo->width == 0 );
pthread_mutex_lock( &(state->lock) );
while ( got < len... | 0 |
#include <pthread.h>
int N;
int ID;
} thread_args;
pthread_mutex_t trava;
int n_workers = 0;
pthread_t workers[4];
int worker_status[4];
int fibo(int N) {
if (N<=2) return 1;
else return (fibo(N-1) + fibo(N-2));
}
void* worker(void *arg) {
thread_args *info = (thread_args *)arg;
... | 1 |
#include <pthread.h>
pthread_mutex_t *lock_cs;
long *lock_count;
pthread_mutex_t locker = PTHREAD_MUTEX_INITIALIZER;
int mtctr;
unsigned long id_function(void)
{
return ((unsigned long) pthread_self());
}
void locking_function(int mode, int type, const char *file, int line)
{
if (mode & CRYP... | 0 |
#include <pthread.h>
struct work_q
{
int job;
struct work_q *next;
};
struct work_q_args
{
struct work_q **curr, **tail;
int *work;
int *waiting;
int num_threads;
pthread_mutex_t *work_mutex;
pthread_cond_t *cond_mutex;
};
void *do_work(void *ptr)
{
struct wor... | 1 |
#include <pthread.h>
int width;
int height;
unsigned * board;
} universe;
universe * universe1;
universe * universe2;
int * count;
pthread_mutex_t * mutex;
pthread_cond_t * cond;
int start;
int rows;
int num_threads;
} threadinfo;
void show(universe * univ) {
int h = uni... | 0 |
#include <pthread.h>
struct queue_type
{
int buff[9];
int front;
int rear;
}Q={{0},0,0};
sem_t empty;
sem_t full;
pthread_mutex_t mutex;
int producer_id = 0;
int consumer_id = 0;
void print()
{
int i;
for(i = 0; i < 9; i++)
printf("%d ", Q.buff[i]);
printf(... | 1 |
#include <pthread.h>
pthread_mutex_t ca_log_lock=PTHREAD_MUTEX_INITIALIZER;
int dumpmsg_to_file(char *module_name, char *proc_name, const char *filename,
int line, const char *funcname, char *fmt, ...)
{
char mesg[4096]={0};
char buf[4096]={0};
char ... | 0 |
#include <pthread.h>
sem_t mayProduce, mayConsume;
pthread_t prod[10], cons[10];
pthread_mutex_t mutex;
int counter;
int buffer[10];
void initialize();
void *producer();
void *consumer();
int main()
{
int np, nc, i;
initialize();
printf("\\nEnter No. of Producers : ");
scanf("%d", &np);
p... | 1 |
#include <pthread.h>
int* vet;
pthread_mutex_t mutex;
} Data;
int threshold;
Data data;
void
merge(int *vet, int left, int middle, int right) {
int i, j, k;
int n1 = middle - left + 1;
int n2 = right - middle;
int L[n1], R[n2];
for (i = 0; i <= n1; i++)
L[i] = vet[l... | 0 |
#include <pthread.h>
int value;
pthread_mutex_t mutex;
pthread_cond_t cond;
} sema_t;
void sema_init(sema_t *sema, int value)
{
sema->value = value;
pthread_mutex_init(&sema->mutex, 0);
pthread_cond_init(&sema->cond, 0);
}
void sema_wait(sema_t *sema)
{
pthread_mutex_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int thread_num;
int* counter;
pthread_t* thread;
int* a[1000];
int pSum[1000];
int sum = 0;
void* parallel_calculate(void* arg) {
int i = 0, j = 0;
int n = *((int*)arg);
for (j = n; j < 1000; j += thread_num) {
for (i = 0; i < ... | 0 |
#include <pthread.h>
pthread_mutex_t bucket_mutex[15];
int buckets[15];
pthread_t equalizer;
pthread_t randomizer;
void transfer_value(int from, int to, int howmuch)
{
bool swapped = 0;
if ( (from == to) || ( howmuch < 0 ) ||
(from < 0 ) || (to < 0) || (from >= 15) || (to >= 15) ) ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thread_1(void *arg)
{
pthread_mutex_lock(&mutex);
DPRINTF(stdout,"Thread 1 locked the mutex\\n");
pthread_exit(0);
return 0;
}
void *thread_2(void *arg)
{
int state;
int rc;
pthread_t self = pthread_self();
int policy = SCHED_FIF... | 0 |
#include <pthread.h>
int sum=0;
int numArray[6];
pthread_mutex_t sum_mutex;
void *thread_sum(void *tid)
{
int start;
int *mytid;
int end;
int mysum=0;
mytid = (int *) tid;
start = (*mytid * 6 / 2);
end = start + 6 / 2;
int i;
for (i=start; i < end ; i++) {
mysum = mysu... | 1 |
#include <pthread.h>
unsigned char *src = 0, *dest = 0;
int pthread_count;
int rate = 0, rate1 = 0;
struct stat buf;
pthread_mutex_t rate_mutex = PTHREAD_MUTEX_INITIALIZER;
void *mycp_pthread(void *arg)
{
int i, a = 0, b = 0;
int count = *(int *)arg;
a = ((int)buf.st_size/pthread_c... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int i, n, last = -1;
int *ids;
int token;
void *Number( void * );
int main( int argc, char **argv ) {
if ( argc != 2 ) {
printf( "Wrong numbers of parameters. Add n.\\n" );
return -1;
}
n = ato... | 1 |
#include <pthread.h>
static char *time_fmt = "%04d%02d%02d-%02d:%02d:%02d-%06dus";
static char *file_str = FILE_STR;
static pthread_mutex_t lock;
void get_time_str(char time_str[])
{
time_t t;
time(&t);
struct tm *tp = localtime(&t);
struct timeval tv;
gettimeofday(&tv, 0);... | 0 |
#include <pthread.h>
{
void *(*process) (void *arg);
void *arg;
struct worker *next;
} CThread_worker;
{
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker *queue_head;
int shutdown;
pthread_t *threadid;
int max_thr... | 1 |
#include <pthread.h>
int val;
struct node * next;
} node_t;
int debug = 0;
int count;
int buffer = 0;
pthread_mutex_t mutex;
pthread_cond_t condc, condp;
node_t * head = 0;
void push(int val) {
node_t * new_node;
new_node = malloc(sizeof(node_t));
new_node->val = ... | 0 |
#include <pthread.h>
sem_t semaphore;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int queue[200];
int queueLength;
void * producer(void * param)
{
int i;
for( i = 0; i < 250; i++)
{
pthread_mutex_lock(&mutex);
queue[queueLength++] = i;
pthread_mutex_unlock(&mutex);
printf("P... | 1 |
#include <pthread.h>
struct thread_data{
int thread_id;
int *balance;
};
pthread_mutex_t myMutex;
void *PrintHello(void *threadarg)
{
long int taskid;
struct thread_data *my_data;
int *balance, save;
my_data = (struct thread_data *) threadarg;
taskid = my_data->thread_id;
ba... | 0 |
#include <pthread.h>
pthread_mutex_t g_GpioMutex;
int g_StartupInitGpioMutex = 1;
void Gpio_InitMutex(void )
{
StdThread_InitMutex(&g_GpioMutex);
}
void Gpio_UnlockMutex_Accident(void)
{
int ret;
ret = pthread_mutex_unlock(&g_GpioMutex);
}
int Gpio_SetValue(int gpi... | 1 |
#include <pthread.h>
int g_itemnum;
int g_buff[(100000)];
struct
{
pthread_mutex_t mutex;
int nindex;
int nvalue;
} shared = { PTHREAD_MUTEX_INITIALIZER };
struct
{
pthread_mutex_t mutex;
pthread_cond_t cond;
int ready;
} ready = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_C... | 0 |
#include <pthread.h>
struct data {
long counter[65536];
};
const int SIZE = sizeof(struct data);
static pthread_mutex_t mutex_arr[65536];
static pthread_mutex_t output_mutex;
static struct data data;
void handle_error(long return_code, const char *msg, int in_thread) {
if (return_co... | 1 |
#include <pthread.h>
pthread_mutex_t candado;
pthread_cond_t producido;
pthread_cond_t consumido;
char buffer[3];
int contador;
int entrada;
int salida;
int posFrase;
int posLlave;
int producidos;
int consumidos;
FILE *file;
FILE *cesar;
char *llave;
char dato;
static char *archivo;
void get... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int count;
int next_index;
void * chunk(void * thread_id){
int id=*(int *) thread_id;
int counter=0;
int i, start=0;
while(1){
pthread_mutex_lock(&lock);
start=next_index;
next_index+=5000;
pthread_mutex_unlock(&lock)... | 1 |
#include <pthread.h>
void *myfunc1(void *ptr);
void *myfunc2(void *ptr);
int A[100];
pthread_mutex_t lock;
int main() {
printf("Starting program!\\n\\n\\n");
pthread_t thread1, thread2;
void **retval;
char *msg1 = "First thread";
char* msg2 = "Second thread";
pthread_... | 0 |
#include <pthread.h>
struct entry {
int key;
int value;
struct entry *next;
};
struct entry *table[5];
int keys[100000];
int nthread = 1;
volatile int done;
pthread_mutex_t mutex;
double
now()
{
struct timeval tv;
gettimeofday(&tv, 0);
return tv.tv_sec + tv.tv_usec / 1000000.0;
}
st... | 1 |
#include <pthread.h>
pthread_rwlock_t progress_rwlock = PTHREAD_RWLOCK_INITIALIZER;
static pthread_mutex_t stdout_mutex = PTHREAD_MUTEX_INITIALIZER;
void generateRequestHead(const struct DownloadInfo *info, char *head) {
sprintf(head, "GET %s HTTP/1.1\\r\\n", info->uri);
sprintf(head, "%s... | 0 |
#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)
printf("sigwait failed");
switch(signo)
... | 1 |
#include <pthread.h>
struct {
int max_steps;
int nb_steps_done;
int position;
pthread_mutex_t lock;
} _global_data;
void
progress_init(int max_steps)
{
int i;
int err;
if (max_steps == -1) {
_global_data.max_steps = -1;
return;
}
err = pthr... | 0 |
#include <pthread.h>
int row1;
int col1;
int row2, col2, currentRow, **InMat1, **InMat2, **ResMat;
int numberOfThreads;
pthread_t * threads;
pthread_mutex_t mutex_Row = PTHREAD_MUTEX_INITIALIZER;
void * doMyWork(int thread_id)
{
int i, j, myRow;
while(1) {
printf("\\n %d: Lock... | 1 |
#include <pthread.h>
pthread_mutex_t Mutex;
pthread_cond_t Condition;
int Value;
} semaphore_type;
void Wait(semaphore_type *Semaphore) {
pthread_mutex_lock(&(Semaphore->Mutex));
Semaphore->Value--;
if (Semaphore->Value < 0) {
pthread_cond_wait(&(Semaphore->Co... | 0 |
#include <pthread.h>
FILE *ctx_msg_out = 0;
pthread_mutex_t ctx_biglock;
char ctx_cmdcode[4] = "000";
static void err_msg(const char *type, const char *path, const char *func,
int line, const char *fmt, va_list argptr)
{
(void)func;
char *filename = strdup(path);
fflu... | 1 |
#include <pthread.h>
pthread_mutex_t mutexExit = PTHREAD_MUTEX_INITIALIZER;
static int exitThread=0;
pthread_mutex_t mutexBrake = PTHREAD_MUTEX_INITIALIZER;
static int isBreaking = 0;
void setBrake()
{
pthread_mutex_lock(&mutexBrake);
isBreaking = 1;
pthread_mutex_unlock(&mutexBrake);... | 0 |
#include <pthread.h>
int count = 10;
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
void *print_a(void)
{
int i;
for(i = 0; i< 10; i++)
{
printf("A!\\n");
pthread_mutex_lock(&mutex1);
sleep(1);
}
}
void *print_b(void)
{
int i;
for(i = 0; i< 10; i+... | 1 |
#include <pthread.h>
int buffer1[4];
int buffer2[4];
int in1, out1;
int in2, out2;
int buffer1_is_empty()
{
return in1 == out1;
}
int buffer1_is_full()
{
return (in1 + 1) % 4 == out1;
}
int buffer2_is_empty()
{
return in2 == out2;
}
int buffer2_is_full()
{
return (in2 + 1) % 4... | 0 |
#include <pthread.h>
pthread_mutex_t mtx;
pthread_cond_t cond;
int how_many = 10;
int pool = 0;
void * producer(void * ptr);
void * consumer(void * ptr);
int main(int argc, char ** argv) {
pthread_t prod, cons;
pthread_mutex_init(&mtx, 0);
pthread_cond_init(&cond, 0);
pthread_creat... | 1 |
#include <pthread.h>
pthread_mutex_t mesa = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t papel_sem = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t cerillos_sem = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t tabaco_sem = PTHREAD_MUTEX_INITIALIZER;
void fumar(){
printf("Estoy fumando\\n");
sleep(5);
pr... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int parking_spots = 0;
int get_parking_spots() {
pthread_mutex_lock(&mutex);
int result = parking_spots;
pthread_mutex_unlock(&mutex);
return result;
}
void inc_parking_spots() {
pthread_mutex_lock(&mutex);
parking_spots++;
... | 1 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main() {
int res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if (res != 0) {
perror("Mutex initialization failed");
... | 0 |
#include <pthread.h>
int i, j;
int tenedor[5]={1,1,1,1,1};
pthread_mutex_t m[5];
int p[5]={0,1,2,3,4};
int numComidas[5]={0,0,0,0,0};
int comidaCont = 0;
void *filosofos(void *);
int main(){
pthread_t tid[5];
srand((long)time(0));
for(i=0; i<5; i++){
if(pthread_create( tid+i, 0,filoso... | 1 |
#include <pthread.h>
int NUM_THREADS;
long int chunk_end;
long int chunk_init;
pthread_mutex_t lock_x;
void swapM(long int* a, long int* b)
{
long int aux;
aux = *a;
*a = *b;
*b = aux;
}
long int divideM(long int *vec, int left, int right)
{
int i, j;
i = left;
for (... | 0 |
#include <pthread.h>
void write(int number, FILE* file){
switch(number){
case A:
printf("A");
fputc('A', file);
break;
case C:
printf("C");
fputc('C', file);
break;
case G:
print... | 1 |
#include <pthread.h>
{
float arrivalTime ;
float transTime ;
int priority ;
int id ;
} flow;
flow flowList[50];
flow *queueList[50];
pthread_t thrList[50];
pthread_mutex_t trans_mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t trans_cvar = PTHREAD_COND_INITIALIZER;
int queu... | 0 |
#include <pthread.h>
int num_iterations;
pthread_mutex_t* mutex;
} ctx;
void* worker_thread(void* ptr) {
ctx* c = (ctx*)ptr;
int num_iterations = c->num_iterations;
while(num_iterations-->0) {
pthread_mutex_lock(c->mutex);
pthread_mutex_unlock(c->mutex);
}
}
void perform_mutex_tes... | 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_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex... | 0 |
#include <pthread.h>
const char *names[5] = { "Aristoteles", "Kant", "Platon", "Marx", "Aquin" };
pthread_mutex_t forks[5];
const char *topic[5] = { "Spaghetti!", "Life", "Universe", "Everything", "Bathroom" };
void print(int y, int x, const char *fmt, ...)
{
static pthread_mutex_t ... | 1 |
#include <pthread.h>
char *NODES_POOL = "1000";
char *key = "node_res";
const int LOOKUP_SIZE = 1024 * 2;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int lookup_nodes() {
size_t ln;
char *result = (char*) calloc(LOOKUP_SIZE, sizeof(char));
if (result != 0) {
int lret = c_zht_... | 0 |
#include <pthread.h>
pthread_mutex_t mut;
pthread_mutex_t *cb_lock = &mut;
void *pneum_handle = 0;
int (*orig_pneum_connect)(char *name, char *chroot_prefix) = 0;
int (*orig_pneum_connect_sync)(char *name, char *chroot_prefix) = 0;
int (*orig_pneum_disconnect)(void) = 0;
int (*orig_pneum_read)(... | 1 |
#include <pthread.h>
void EnterCar(char *CarDir);
void ExitCar (char *CarDir);
void * Car(void* carDir);
char currDir;
pthread_mutex_t leftDir, rightDir, mtxCheck, mtxExit, mtxend;
int countl, countr, flag;
int carsPassed, carsleft, flag,waiting,startflag;
int main (int argc, char *argv[]){... | 0 |
#include <pthread.h>
int _N_BUFFER = 0;
struct node {
size_t node_size;
node* next;
};
node* head;
node* tail;
char init;
} llist;
char* buff;
pthread_mutex_t mutex;
size_t b_size;
int m_size;
int n_msg;
llist list;
} mtb_struct;
int mtb_num_msg(int buf_index);
int mt_... | 1 |
#include <pthread.h>
int threadsNum;
char *fileName;
int recordsNum;
char *searched;
int file;
int signr;
pthread_t *threads;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *threadFunction(void *);
void signalHandler(int signal) {
printf("PID: %d TID: %ld received signal no %d\\n",... | 0 |
#include <pthread.h>
void manual_conflict_resolution(struct FileSector *obj1, char contents[], int conflict_choice);
void all_or_nothing_get(char file_to_read[])
{
char read_cmd[MAX];
struct FileSector obj1;
int ret = 1;
int conflict_choice=0;
char temp[MAX];
char contents_s1[MAX];
char co... | 1 |
#include <pthread.h>
int philoNum[] = {0,1,2,3,4};
int semID;
pthread_mutex_t chopsticks[5];
int randomGaussian_r(int mean, int stddev, unsigned int* state) {
double mu = 0.5 + (double) mean;
double sigma = fabs((double) stddev);
double f1 = sqrt(-2.0 * log((double) rand_r(sta... | 0 |
#include <pthread.h>
void *pooling(void* argp) {
int i, queue_size;
char *path;
struct Return_values *rvalues;
struct Thread_args *args_pool = (struct Thread_args*) argp;
queue_size = args_pool->queue_size;
while (1) {
pthread_mutex_lock(&mtx);
while(count(queue_size) == -1) {
pt... | 1 |
#include <pthread.h>
int num_threads;
pthread_t p_threads[65536];
pthread_attr_t attr;
pthread_mutex_t lock_barrier;
int list[200000000];
int list_size;
int prefix_sum_list[200000000];
int mylist_sum[65536];
int wait_list[65536];
void *prefix_sum (void *s) {
int j, sum, offset;
int ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_bano = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_hom = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_fem = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_hom = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_fem = PTHREAD_COND_INITIALIZER;
in... | 1 |
#include <pthread.h>
double pe_final;
double *a;
double *b;
pthread_mutex_t gate;
pthread_mutex_t S;
int count = 8;
void *semgeral(void *threadarg)
{
pthread_mutex_lock(&gate);
pthread_mutex_lock(&S);
count -= 1;
if(count>0)
{
pthread_mutex_unlock(&gate);
}
pthread_mutex_unlock(&S);
... | 0 |
#include <pthread.h>
void
lvm_pool_init(struct lvm_pool *pool) {
pool->head = pool->tail = 0;
pool->sleep = 0;
pthread_mutex_init(&pool->mutex, 0);
pthread_cond_init(&pool->cond, 0);
}
void
lvm_pool_destroy(struct lvm_pool *pool) {
pthread_cond_broadcast(&pool->cond);
if (... | 1 |
#include <pthread.h>
void createTask(struct Writer *w){
int sleepTime = 100;
int prio = (int) ((double)rand() * (long)w->queue->NumPriorities / ((double) 32767 +1));
struct Task *t;
t = malloc(sizeof(struct Task));
t->id = w->task_id;
w->task_id = w->task_id +1;
t->nextTask = 0;
t->... | 0 |
#include <pthread.h>
struct foo
{
int a,b,c,d;
pthread_mutex_t lock;
};
struct foo foo = {1,2,3,4};
int i =0;
void printfoo(const char *s,const struct foo *fp)
{
printf("%s\\n",s );
printf("struct at 0x%lx\\n",(unsigned long)fp );
printf("foo.a=%d\\n", fp->a);
printf("fo... | 1 |
#include <pthread.h>
sem_t full,empty;
int * applicants;
int peps=0;
int noOfLine;
int regDur;
int regs=0;
pthread_mutex_t mutex[3];
void* registerP() {
while(1) {
sem_wait(&empty);
printf("Applicant %d applied to receptionist.\\n", regs+1);
sleep(regDur);... | 0 |
#include <pthread.h>
pthread_mutex_t mtx_lock;
int main(int argc, char **argv) {
host *thisHost;
host *nextHost;
dataContainer *dataTransfer;
struct addrinfo *res;
char* sendBuffer = (char*) calloc(100, sizeof(char));
int election = 1;
int *mode = &election;
in... | 1 |
#include <pthread.h> static char rcsId[]="$Id: csda.c,v 0.1 1999/10/27 10:31:28 lanzm Exp $";
extern pthread_mutex_t cs_thread_exit;
extern int cs_threads_should_exit;
void csda_best_node_server_thread(void)
{
int should_exit;
int server_id, client_id;
struct bn_request req;
struct b... | 0 |
#include <pthread.h>
static const struct dot_matrix_data empty_dot_data = { .data = { { 0, } } };
struct mode_draw_board_status
{
int output_pipe_fd;
pthread_mutex_t mutex;
bool cur_show;
int cur_pos_x, cur_pos_y;
char cur_val;
struct dot_matrix_data dot_data;
int input_coun... | 1 |
#include <pthread.h>
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->to_fn)(tip->to_arg);
return 0;
... | 0 |
#include <pthread.h>
pthread_mutex_t m;
void* thr1(void* arg)
{
int x;
int y;
int z;
x = __VERIFIER_nondet_int(0, 1000);
y = __VERIFIER_nondet_int(0, 1000);
pthread_mutex_lock (&m);
if(x == y)
{
z = 0;
} else {
z = 1;
}
printf ("thr1: x=%d, y=%d, z=%d\\n",... | 1 |
#include <pthread.h>
const char *shm_name = "/my_shm";
{
pthread_cond_t cond;
pthread_mutex_t mutex;
} cond_var;
cond_var fill_cond;
cond_var empty_cond;
pthread_mutex_t sync_mutex;
pthread_t *tid;
volatile int *ptr;
int work;
int shm_fd;
size_t workersNumber;
size_t storageSize;
void* prod... | 0 |
#include <pthread.h>
int prod = 0;
int cons = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char caracteres[10];
pthread_t hilos[2];
int v = 1;
char caracAleatorio(void){
return ((rand() % 57) + 65);
}
pthread_t hilos[2];
void *consumidor(void *arreglo){
while(1){
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condition;
int counter;
} barrier_t;
barrier_t barrier = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};
void *my_thread(void *);
void barrier_sync(barrier_t *);
int main(int argc, char **argv)
{
pthread_t t... | 0 |
#include <pthread.h>
int qtd = 0;
pthread_cond_t empty, full;
pthread_mutex_t mutex;
void *producer()
{
printf("Produtor!\\n");
while(1)
{
pthread_mutex_lock(&mutex);
if(qtd == 20)
{
printf("Maximo atingido!\\n");
pthread_cond_wait(&full, &mutex);
}
qtd++;
printf("Pr... | 1 |
#include <pthread.h>
int keepgoing = 1;
void signal_handler(int sig);
void *ThreadFunction(void *param);
void SendI2C(int chipAddress, int bellNumber, int deg);
void InitI2C(void);
void InitAIN(void);
pthread_t tid;
int id;
pthread_mutex_t mutex;
} Thread;
void signal_handler(int sig){... | 0 |
#include <pthread.h>
pthread_mutex_t IO_mutex;
pthread_mutex_t QUEUE_mutex;
pthread_mutex_t NETWORK_mutex;
pthread_cond_t NETWORK_cond;
static pthread_t ClientThread, ServerThread;
static struct Server_arg ServerArg = { .listen = 1025 };
static struct Client_arg ClientArg = {
.peerIP =... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
int main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0 )... | 0 |
#include <pthread.h>
int waarde;
char uitspraak[10];
} cijfer_t;
cijfer_t buf[1];
cijfer_t in;
cijfer_t out;
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
} package_t;
cijfer_t ctarray[] = {{0, "Zero"}, {1, "One"}, {2, "Two"}, {3, "Three"},
{4, "Four"}, {5... | 1 |
#include <pthread.h>
pthread_t *tid;
int target;
char *text;
int thread_number;
int record_number;
pthread_mutex_t mutex;
int forks[5];
unsigned int microseconds = 1000;
pthread_cond_t conditions[5];
void getForkLeft(int idno){
pthread_mutex_lock(&mutex);
if(idno == 0) idno = 5;
whil... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int condition = 0;
int count = 0;
int put = 0;
int get = 0;
int BUFFER[8];
int consume( void )
{
while( 1 )
{
pthread_mutex_lock( &mutex );
while( conditio... | 1 |
#include <pthread.h>
static inline unsigned int gfifo_unused(struct gfifo *fifo)
{
return (fifo->mask + 1) - (fifo->in - fifo->out);
}
static inline unsigned int min(unsigned int a, unsigned int b)
{
return (a < b) ? a : b;
}
int gfifo_alloc(struct gfifo *fifo, unsigned int size,
size_t es... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.