text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int searchPosition(int i);
void * find(void *pat);
char *pattern;
char text[1000000];
int textLength = 1000000;
int patternLength;
int whichThread = 0;
int offset = 1000000/10;
int result = -1;
pthread_mutex_t lock;
int main(int argc, char *argv[]) {
char* patter... | 1 |
#include <pthread.h>
pthread_mutex_t lockStat;
pthread_cond_t condLock;
int32_t shared=0;
void* startFunction(void * msg)
{
int32_t data;
pthread_attr_t currentAttr;
printf("Child Thread Id:%ld\\n",pthread_self());
pthread_getattr_np(pthread_self(), ¤tAttr);
pr... | 0 |
#include <pthread.h>
int get_cpu_core_num() {
return 4;
}
char input_end = 0;
pthread_mutex_t input_m;
pthread_mutex_t output_m;
int get_stdin_input(char *file_name) {
if (input_end == 1) return 0;
if(fgets(file_name, 1024, stdin) == 0) {
input_end = 1;
r... | 1 |
#include <pthread.h>
int *numbers = 0;
pthread_cond_t queueEmpty ;
pthread_mutex_t queueLock ;
void * Slave_Start(void * s)
{
int id = (*(struct Data *) s).id ; ;
int min = (*(struct Data *) s).min;
int max = (*(struct Data *) s).max;
int k = (*(struct Data *) s).k;
int i;
pthread_co... | 0 |
#include <pthread.h>
pthread_cond_t stable,
workshop,
santaSleeping,
elfWaiting,
santaWaitElf;
pthread_mutex_t elfAndReindeerCount,
elfwWaitingLock;
int minWait, maxWait;
int elfCount;
int reindeerCount;
int elfDoor;
void *santaThread(void *args)
{
while(1)
{
santaHelper();
... | 1 |
#include <pthread.h>
struct cmd_que_item {
struct cmd_que_item *next;
int cmd_id;
};
static struct cmd_que_item *cmd_que_tail = 0;
static struct cmd_que_item *cmd_que_head = 0;
static pthread_mutex_t cmd_que_mutex = PTHREAD_MUTEX_INITIALIZER;
int wait_for_cmd(int cmd_id, double timeout)
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void *threadMain(void *arg)
{
fprintf(stderr, "In second thread: starting\\n");
pthread_mutex_lock(&mtx);
pthread_mutex_lock(&mtx);
assert(0);
}
int main()
{
struct sigaction act;
pthread_t thd;
... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg... | 0 |
#include <pthread.h>
void Deposit(int), BeginRegion(), EndRegion();
pthread_mutex_t mutex;
main()
{
pthread_t idA, idB;
void *MyThread(void *);
if (pthread_mutex_init(&mutex, 0) < 0) {
perror("pthread_mutex_init");
exit(1);
}
if (pthread_create(&idA, 0, MyThread, (void ... | 1 |
#include <pthread.h>
int schedule[10] = {20, 20, 20, 20, 20, 20, 20, 20, 20, 20};
pthread_t threads[2];
pthread_mutex_t mutex;
void printSchedule(){
printf("Schedule: ");
for (int i = 0; i<10; i++){
printf("%d ", schedule[i]);
}
printf("\\n");
}
void* updateFromWeb(){
time_t t;
... | 0 |
#include <pthread.h>
static void *cygfuse_init_slow(int force);
static void *cygfuse_init_winfsp();
static pthread_mutex_t cygfuse_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *cygfuse_handle = 0;
static inline void *cygfuse_init_fast(void)
{
void *handle = cygfuse_handle;
__sync_synch... | 1 |
#include <pthread.h>
int num_of_students;
int dean_status;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait_for_full_room, wait_for_students_to_leave;
void* dean_code(void*);
void* students_code(void*);
int main(void)
{
pthread_t dean, students;
num_of_students = 0... | 0 |
#include <pthread.h>
struct account{
float balance;
char name[32];
pthread_mutex_t mutex;
};
int withdraw (struct account *account, int amount)
{
printf("%u\\t%s\\t%f\\t%d\\n", pthread_self(), account->name, account->balance, amount);
pthread_mutex_lock (&account->mutex);
const int bala... | 1 |
#include <pthread.h>
int task_queue_pointer = -1,complete_flag = 0, complete[28] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, task_queue[28];
int dependency[28][28]={{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0... | 0 |
#include <pthread.h>
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* threadAlarme (void* arg);
void* threadCompteur (void* arg);
int main (void)
{
pthread_t monThreadCompteur;
pthread_t monThreadAlarme;
pthread_create (&monThreadC... | 1 |
#include <pthread.h>
struct job {
struct job* next;
int value;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
void initialize_job_queue ()
{
job_queue = 0;
sem_init (&job_queue_count, 0, 0);
}
void proce... | 0 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void
clock_gettime(int id, struct timespec *tap)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
... | 1 |
#include <pthread.h>
int DEBUG;
int *array;
int left;
int right;
int tid;
} thread_data_t;
int number_of_threads;
pthread_mutex_t lock_number_of_threads;
int my_comp(const void *larg, const void *rarg) {
int l = *(int *)larg;
int r = *(int *)rarg;
if (l < r) {
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int aux = 1;
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
void* threadLockTest(void* arg) {
printf("Child wants to take the mutex\\n");
pthread_mutex_lock(&mutex);
printf("Child took the mutex\\n");
sle... | 1 |
#include <pthread.h>
pthread_t * ids;
int fl;
bool threadFlag = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int iloscRekordow;
int iloscWatkow;
void * threadFunc(void *);
void atexitFunc();
struct rekord{
int id;
char * txt;
};
int main(int argc, char const *argv[])
{
atexit(atex... | 0 |
#include <pthread.h>
static int set_priority(int priority);
static int get_priority(void);
pthread_mutex_t pid_mutex;
pid_t pid;
} pid_data;
int main(int argc, char *argv[]) {
printf("Server started \\n");
int file_descriptor;
file_descriptor = shm_open("/sharedpid", O_RDWR | O_CREAT, S... | 1 |
#include <pthread.h>
static pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
static int count;
void fast_task(void *ptr)
{
int *pval = (int*)ptr;
int i;
for (i = 0; i < 1000; i++) {
(*pval)++;
}
pthread_mutex_lock(&count_mutex);... | 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 *matrica;
int m,n;
int pocetak, kraj, stupac;
} thr_struct;
thr_struct *nova;
pthread_mutex_t lock;
pthread_barrier_t barijera;
void* thr_f( void* arg )
{
int pocetak = ( (thr_struct*) arg )->pocetak;
int kraj = ( (thr_struct*) arg )->kraj;
int stupac = ( (thr_s... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
long long n;
double sum = 0;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double Serial_pi(long long n);
int main(int argc, char* argv[]) {
long t... | 1 |
#include <pthread.h>
int *a, *b;
long sum=0;
pthread_mutex_t mutex;
void *dotprod(void *arg)
{
int i, start, end, offset, len;
long tid = (long)arg;
offset = tid;
len = 100000;
start = offset*len;
end = start + len;
printf("thread: %ld starting. start=%d end=%d\\n",... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int ticket=10;
void* setticket(void* p)
{
pthread_mutex_lock(&mutex);
if(ticket>0)
{
pthread_cond_wait(&cond,&mutex);
}
ticket=10;
printf("set ticket success\\n");
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
void* sal... | 1 |
#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... | 0 |
#include <pthread.h>
int q[4];
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 < 4)
... | 1 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mut;
int number;
int i;
void *thread1()
{
pthread_detach(pthread_self());
printf ("pthread1 : I'm thread 1\\n");
for (i = 0; i < 15; i++)
{
pthread_mutex_lock(&mut);
number++;
printf("pthread1 : number = %d\\n",number... | 0 |
#include <pthread.h>
uint64_t * nombresPremiers(uint64_t n, int * taille);
uint64_t * factorisation(uint64_t n, int * taille);
void * print_prime_factors(void * n);
static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
int main()
{
FILE * f;
if((f=fopen("numbers.txt","r")) != 0)
{
uint64_... | 1 |
#include <pthread.h>
void *thread_function(void *arg);
int run_now = 1;
char message[] = "Hello World";
unsigned int num;
const unsigned int count = 20000000;
pthread_mutex_t work_mutex;
int main() {
int res;
pthread_t a_thread;
void *thread_result;
int print_count1 = 0;
int n... | 0 |
#include <pthread.h>
struct car {
int destination;
int source;
int position;
pthread_mutex_t lock;
};
pthread_mutex_t quadrants[4];
pthread_mutex_t check;
pthread_t car_threads[20];
struct car cars[20];
void *run_car(void *carID) {
int id = (int) carID;
pthread_mutex_lock(&cars[id].lock)... | 1 |
#include <pthread.h>
void *thread_open(void *);
void *thread_even(void *);
void *thread_odd(void *);
pthread_t threadID[5];
pthread_mutex_t mutex1, mutex2;
int fd, ret;
int main()
{
int threadFD, i = 0,k = 2, j = 1;
char *rt;
ret = pthread_mutex_init(&mutex1, 0);
ret = pthread... | 0 |
#include <pthread.h>
int value;
int divisors;
} result_t;
int g_max;
int g_next;
pthread_mutex_t g_next_mtx;
result_t g_best;
int g_processed;
pthread_mutex_t g_best_mtx;
pthread_cond_t g_best_cnd;
int num_divisors(int v) {
int cnt = 0;
for (int i = 1; i <= v; i++)
if (v % i == 0)
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void** buffer;
unsigned int capacity;
unsigned int head;
unsigned int size;
char is_closed;
} channel;
channel* chan_create(unsigned int capacity) {
capacity += 1;
channel* chan = malloc(sizeof(... | 0 |
#include <pthread.h>
pthread_mutex_t mutexS1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexS2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexS3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexA = PTHREAD_MUTEX_INITIALIZER;
char *ingredients[3] = {"tobacco", "paper", "matches"};
i... | 1 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
struct foo *foo_alloc(int id)
{
struct foo *fp;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
fp->f_id = id;
if (pthread_mutex_init(&fp->f_lock, 0) != ... | 0 |
#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;... | 1 |
#include <pthread.h>
int data;
int countR;
}b;
pthread_mutex_t mutex;
pthread_t readtid[1000],writetid;
b buffer[5];
int numC,flag[5][1000],f[1000];
pthread_attr_t attr;
int limit = 100;
void *reader(void *arg);
void *writer(void *arg);
void writeData(int i);
void initialize()
{
int i,j;
... | 0 |
#include <pthread.h>
void *control_pos(void *arg)
{
struct task_par *tp;
tp = (struct task_par *)arg;
float buff_in[5];
float out_pos[5];
float aux_i[5];
float aux_p[5];
float Ki, Kp, Kd, J, L, b, R, Ke, Kt, ref;
struct par_mgt par_mgt_p;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int final_result=0;
void *filter (void *threadarg){
int x;
int checksum =0;
int y = *((int *)threadarg);
for (x = 0; x < 1000; x++){
int sum = 0;
int pixelsAveraged = 1;
if (y-1 >= 0 && x-1 >= 0){
sum... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc,condp;
int buffer=0;
void *producer(void *prt)
{
int i;
for(i=1;i<=10;i++)
{
pthread_mutex_lock(&the_mutex);
while(buffer!=0)
{
sleep(1);
pthread_cond_wait(&condp,&the_mutex);
}
printf("I`m the producer\\n");
... | 1 |
#include <pthread.h>
static struct hash_map *literals;
static pthread_mutex_t literals_mutex = PTHREAD_MUTEX_INITIALIZER;
struct string *alloc_str(void)
{
int err;
struct string *str = malloc(sizeof *str);
if (!str)
return 0;
memset(str, 0, sizeof *str);
err = str_resize(str... | 0 |
#include <pthread.h>
void* func(void* m);
void* funcn();
void* check();
union semun {
int val;
struct semid_ds *buf;
unsigned short int *array;
};
int val;
int game[4][4]={{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}};
int count[5]={0,0,0,0,0};
int sem_id;
pthread_mutex_t lock;
int main()
{
pthr... | 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 *idp)
{
int j,i;
double result=0.0;
int *my_id = idp;
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
... | 0 |
#include <pthread.h>
int DPW_countack, num_ack[NUM_M];
int DPW_infly_high, DPW_infly_low;
int *DPW_table4g;
pthread_t DPW_recv_g_send_m_t[NUM_G], DPW_recv_m_send_g_t[NUM_M], DPW_FT_send_b_t;
pthread_mutex_t ordered_mutex, ack_mutex;
struct DPW_order *DPW_order_list;
struct timespec DPW_DA_begin_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void* thread1(void*arg)
{
pthread_cleanup_push(pthread_mutex_unlock,&mutex);
while(1)
{
printf("thread1 is running\\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond,&mutex);
printf("thread1 applied the cond... | 0 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
static void* _thread1(void *__u )
{
printf("1: obtaining mutex\\n");
pthread_mutex_lock(&lock);
printf("1: waiting on condition variable\\n... | 1 |
#include <pthread.h>
int buffer[1024];
int count=0;
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
int flag=0;
void *threadFun1(void *arg)
{
int i;
while(1)
{
pthread_mutex_lock(&mutex1);
printf("Thread 1\\n");
if(0==flag)
{
count++;
flag=1;
}
pthread_mutex_unlock(&mutex2... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t empty;
int ncust;
void* barber(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
if(ncust == 0)
{
printf("barber Sleeping\\n");
pthread_cond_wait(&empty, &mutex);
}
... | 1 |
#include <pthread.h>
void *thread_func(void *p)
{
pthread_mutex_t *mutex = (pthread_mutex_t *)p;
pthread_mutex_lock(mutex);
pthread_mutex_unlock(mutex);
return 0;
}
int test_main()
{
pthread_t thread;
pthread_mutex_t mutex;
if(pthread_mutex_init(&mutex, 0))
... | 0 |
#include <pthread.h>
char ipaddr[]="192.168.1.57";
int ipactual=1;
pthread_mutex_t p;
int ping(void) {
char *command = 0;
char buffer[1024];
FILE *fp;
int stat = 0;
asprintf (&command, "%s %s", "ping", ipaddr);
printf("%s\\n", command);
fp = popen(command, "r");
if (fp == 0) {
... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void* producer(void* ptr) {
int i;
for(i=0; i<=10000000000; i++) {
while(buffer != 0) {
}
pthread_cond_wait(&condp, &the_mutex);
pthread_mutex_lock(&th... | 0 |
#include <pthread.h>
void *multiplicar_thread(void *arg);
void gerar_matrizes();
void imprimir_matriz(FILE *arquivo, int **matriz);
void imprimir_matrizes();
void liberar_matrizes();
pthread_mutex_t mutex;
int **matriz1;
int **matriz2;
int **resultado;
int tamanho_matriz;
int linha_atual, coluna... | 1 |
#include <pthread.h>
void*handler(void*num);
int isPrime(int64_t n);
pthread_mutex_t count_mutex;
volatile int64_t count = 0;
volatile int64_t numbersfound = 0;
int isPrime(int64_t n)
{
printf("num %ld\\n", n);
if( n <= 1) return 0;
if( n <= 3) return 1;
if( n % 2 == 0 || n % 3 == 0) ret... | 0 |
#include <pthread.h>
FILE* file;
int iter =1;
struct Data
{
int num_th;
char str_find[1024];
int socket_ac;
};
struct {
pthread_mutex_t mutex;
int buff[1000000];
int nput;
int nval;
}
shared =
{
PTHREAD_MUTEX_INITIALIZER
};
void *thread_func(void* arg)
{
data *str_find=(data *)arg;
... | 1 |
#include <pthread.h>
void interrupt1()
{
fprintf(stdout, "Arrival thread exiting\\n");
return;
}
void *handler1()
{
struct sigaction act;
sigset_t sig;
act.sa_handler = interrupt1;
sigaction(SIGUSR1, &act, 0);
sigemptyset(&sig);
sigaddset(&sig, SIGUSR1);
pt... | 0 |
#include <pthread.h>
int *mem;
pthread_mutex_t mtx;
void *Thread1(void *x) {
pthread_mutex_lock(&mtx);
free(mem);
pthread_mutex_unlock(&mtx);
return 0;
}
void *Thread2(void *x) {
sleep(1);
pthread_mutex_lock(&mtx);
mem[0] = 42;
pthread_mutex_unlock(&mtx);
return 0;
}
int m... | 1 |
#include <pthread.h>
static int __rg_quorate = 0;
static int __rg_lock = 0;
static int __rg_threadcnt = 0;
static int __rg_initialized = 0;
static int _rg_statuscnt = 0;
static int _rg_statusmax = 5;
static int _rg_childcnt = 0;
static int _rg_childmax = 0;
static pthread_cond_t unlock_cond = ... | 0 |
#include <pthread.h>
struct send_arg {
struct queue* queue;
char* host;
int port;
};
void multi_send(char* buf, int len, char* host, int port, int num_conn);
void* queue_send(void*);
void fill_queue(char* buf, int len, struct queue* q);
int listen_for_blocks(struct mp_writer_init* arg);
in... | 1 |
#include <pthread.h>
void *thread_scheduler(void *arg)
{
unsigned int schedalg=*((unsigned int*)arg);
int acceptfd,n;
if(schedalg==0)
{
while(1)
{
if(front!=NULL)
{
sem_wait(&sem);
pthread_mutex_lock(&sthread_mutex);
pthread_mutex_lock(&qmutex);
r2=extract_element();
pthread_mutex_u... | 0 |
#include <pthread.h>
int main(int argc, char *argv[]){
pthread_mutex_init(&Tlock_input, 0);
pthread_mutex_init(&Tlock_cubes, 0);
pthread_mutex_init(&Tsync_cubes, 0);
pthread_mutex_lock(&Tlock_cubes);
pthread_create(&Tevent, 0, Tevent_loop, 0);
pthread_create(&Tmap_sync, 0, Tsync_loop, ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_s = PTHREAD_MUTEX_INITIALIZER;
int suma[10000000];
int sumas = 0;
FILE *fp;
void * sumar(void * arg)
{
int tid = (int) arg;
int i = 0;
while (feof(fp) == 0)
{
pthread_mutex_lock(&mutex_s);
fscanf(fp, "%d", &suma[i]... | 0 |
#include <pthread.h>
int hilos_entradaActivo;
int active_work;
void *KEY;
int bufSize = 0;
FILE *file_in;
FILE *file_out;
pthread_mutex_t mutexIN;
pthread_mutex_t mutexWORK;
pthread_mutex_t mutexOUT;
char data;
off_t offset;
char state;
} BufferItem;
BufferItem *result;
void thread_sle... | 1 |
#include <pthread.h>void chanMsg(char *msg,char *channel,int sockfd)
{
char buffer[SIZE+SIZE];
sprintf(buffer,"PRIVMSG %s :%s",channel,msg);
OUT(sockfd,buffer);
}
void OUT(int sockfd,char *message)
{
if(timecheck)
{
send(sockfd,message,strlen(message),0);
timecheck=0;
}
send... | 0 |
#include <pthread.h>
static pthread_mutex_t Mutex = PTHREAD_MUTEX_INITIALIZER;
void print_char(int fh, char *c) {
int t=0;
while (c[t]!=0) t++;
write(fh,c,t);
}
int int2char(char* x,unsigned long i) {
if (i==0) {
return 0;
}
int k=int2char(&x[0],i/10);
x[k]='0'+(i%10);
x[k+1]=... | 1 |
#include <pthread.h>
int beers = 2000000;
pthread_mutex_t a_lock = PTHREAD_MUTEX_INITIALIZER;
void* drink_lots(void *a)
{
int i = 0;
pthread_mutex_lock(&a_lock);
for (i = 0; i < 100000; ++i)
{
beers -= 1;
}
pthread_mutex_unlock(&a_lock);
printf("beers... | 0 |
#include <pthread.h>
int buffer[100];
int count=0;
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t signal_c= PTHREAD_COND_INITIALIZER;
pthread_cond_t signal_p= PTHREAD_COND_INITIALIZER;
void printfunction(void * ptr)
{
if (count==0)
{
printf("All items produced are cons... | 1 |
#include <pthread.h>
COMFOME, PENSANDO, COMENDO,
} Filosofo;
pthread_mutex_t garfos;
Filosofo *filosofos;
int nfilosofo;
void *ffuncao(void *f) {
int fid = (int) f;
while (1) {
pthread_mutex_lock (&garfos);
switch (filosofos[fid]) {
case PENSANDO:... | 0 |
#include <pthread.h>
pthread_mutex_t printerMutex;
void printMessage(const char* message_template, ...) {
lockPrinter();
va_list arguments;
__builtin_va_start((arguments));
char* message = string_from_vformat(message_template, arguments);
puts(message);
printf(" > ");
free(message);... | 1 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
char buf[32];
void *thrfun(void *data)
{
int id = *(int *)data;
while ( 1 ) {
pthread_mutex_lock(&mut);
pthread_cond_wait(&cond,&mut);
int val = atoi(buf);
... | 0 |
#include <pthread.h>
struct foo{
pthread_mutex_t f_lock;
struct foo *f_next;
int f_count;
};
struct foo *hashfoo[29L];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo *foo_alloc()
{
struct foo *pf;
int idx;
if ((pf = (struct foo *)malloc(sizeof(struct foo))) == 0)
r... | 1 |
#include <pthread.h>
pthread_t g_thread[2];
pthread_mutex_t g_mutex;
__uint64_t g_count;
pid_t gettid()
{
return syscall(SYS_gettid);
}
void *run_amuck(void *arg)
{
int i, j;
printf("Thread %lu started.\\n", (unsigned long)gettid());
for (i = 0; i < 10000; i++) {
pthre... | 0 |
#include <pthread.h>
void sign_extend(void *not_used){
pthread_barrier_wait(&threads_creation);
int i;
short int imediato;
int sign_extend_temp;
while(1)
{
pthread_mutex_lock(&control_sign);
if (!cs.isUpdated){
while(pthread_cond_wait(&con... | 1 |
#include <pthread.h>
void *
wizard_func(void *wizard_descr)
{
struct cube* cube;
struct room *newroom;
struct room *oldroom;
struct wizard* self;
struct wizard* other;
self = (struct wizard*)wizard_descr;
assert(self);
cube = self->cube;
assert(cube);
oldroom = cube->rooms[self->x][s... | 0 |
#include <pthread.h>
struct SwarmSession {
struct SessionContext* session_context;
struct SwarmContext* swarm_context;
};
int DEFAULT_NETWORK_TIMEOUT = 5;
int libp2p_swarm_listen_and_handle(struct Stream* stream, struct Libp2pVector* protocol_handlers) {
struct StreamMessage* results = ... | 1 |
#include <pthread.h>
unsigned int TEST_VALUE_RA[2 * 8][3];
int VT_mc34704_RA_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc34704_RA_cleanup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc34704_test_RA(void) {
int rv = TPASS, fd, i = 0, val;... | 0 |
#include <pthread.h>
int main(int argc,char **argv){
pthread_cond_t *cond;
pthread_condattr_t condattr;
pthread_mutex_t m;
int fd;
if(argc==1){
if((fd=shm_open("/cond",O_RDWR|O_CREAT,0777))==-1){
printf("shm_open failed for /cond:%s\\n",strerror(errno));
return 0;
}
... | 1 |
#include <pthread.h>
int shared_counter = 1;
pthread_mutex_t mutex;
pthread_t original_thread;
void *thread_loop(void *arg) {
long int counter_increment = (long int) arg;
while (1) {
pthread_mutex_lock(&mutex);
if (shared_counter >= 25) {
pthread_mutex_unlock(&mutex);
if (pthrea... | 0 |
#include <pthread.h>
pthread_t thread;
pthread_cond_t c1, p1;
pthread_mutex_t mutex;
struct node {
int num;
struct node *next;
struct node *prev;
};
int size = 0;
struct node *head = 0;
struct node *tail = 0;
struct node *current = 0;
struct node* createNode(int x){
int data;
if (x == 0... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t C = PTHREAD_COND_INITIALIZER;
void get_forks(int i)
{
pthread_mutex_lock(&m);
pthread_mutex_unlock(&m);
}
void release_forks(int i)
{
pthread_mutex_lock(&m);
pthread_mutex_unlock(&m);
... | 0 |
#include <pthread.h>
struct data {
int IMAGE[1];
char mot[1*21];
int DernierThreadSurLaZone[1];
pthread_mutex_t *verrou;
pthread_cond_t *condition;
}data;
void* Fonction1(void*);
void* Fonction2(void*);
void* Focntion3(void*);
void* Fonction4(void*);
void* Fonction5(void*);
void * Fonct... | 1 |
#include <pthread.h>
const char g_wldb_file[] = "whitelist.db";
struct sDB * g_whitelist;
static pthread_mutex_t whitelist_mtx;
int WhiteListDatabaseInit()
{
int mtx = 0;
mtx = pthread_mutex_init(&whitelist_mtx,0);
if( 0 != mtx){
print_log(f_sysinit,"ERROR!!!pt... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond_filosofos[5];
int estado_filosofo[5];
void pegar_garfos(int id);
void devolver_garfos(int id);
void tentar_comer(int id);
void verificar_concorrencia();
void* filosofo(void* arg){
int id = *((int*) arg);
while(1){
... | 1 |
#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)
... | 0 |
#include <pthread.h>
sem_t chopstick[5];
pthread_mutex_t mutex;
int food[5];
void pickup_chopsticks(int);
void putdown_chopsticks(int);
void philosopher(int *philosopher_info);
int main(int argc, char *argv[]){
pthread_t philosophers[5];
int philosopher_info[5][1];
pthread_mutex_init(&mutex... | 1 |
#include <pthread.h>
void* (*routine)(void*);
void *arg;
struct tpool_work *next;
}tpool_work_t;
int shutdown;
int max_thr_num;
pthread_t *thr_id;
tpool_work_t *queue_head;
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
}tpool_t;
static tpool_t *tp... | 0 |
#include <pthread.h>
pid_t pid;
int bread_count;
int box_count;
pthread_mutex_t bread_mutex;
sem_t box_sem;
void *thread_maker(void *arg)
{
int usec;
int id = *(int *)arg;
printf("[T%d] thread started\\n", id);
for(;;) {
usec = random()%500000 + 500000;
usleep(usec);
pthread_mutex_... | 1 |
#include <pthread.h>
extern struct net_ops tcp_ops;
static int inet_stream_connect(struct socket *sock, const struct sockaddr *addr,
int addr_len, int flags);
static int INET_OPS = 1;
struct net_family inet = {
.create = inet_create,
};
static struct sock_op... | 0 |
#include <pthread.h>
uint64_t nb;
FILE * file;
char str[60];
pthread_t thread0;
pthread_t thread1;
pthread_mutex_t lock;
void* thread_prime_factors(void * u);
void print_prime_factors(uint64_t n);
void* thread_prime_factors(void * u)
{
pthread_mutex_lock(&lock);
while ( fgets(str, 60... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t self;
int temp;
struct node * next;
}node_t;
void performLL(node_t * node);
node_t *createNode(int myTemp);
void forward(node_t **currentNode);
void insertEnd(node_t **head, node_t *addedNode);
void insertLL(int *id);
void temperature(... | 0 |
#include <pthread.h>
pthread_mutex_t ma, mb;
int data1, data2;
pthread_mutex_t ja, jb;
int join1, join2;
void * thread1(void * arg)
{
pthread_mutex_lock(&ma);
data1++;
pthread_mutex_unlock(&ma);
pthread_mutex_lock(&ma);
data2++;
pthread_mutex_unlock(&ma);
pthread_mutex_loc... | 1 |
#include <pthread.h>
static int ARG;
int turn = 0;
pthread_mutex_t lock;
void *opA(void *arg)
{
int a = ARG;
while(a > 0)
{
if(turn == 0)
{
pthread_mutex_lock(&lock);
printf("Thread A executing opA\\n");
turn = 1;
pthread_mutex_unlock(&lock);
a--;
}... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *thread_function(void *arg);
int run_now = 1;
int main(int argc, char **argv)
{
int print_count... | 1 |
#include <pthread.h>
int ready_threads = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void f(void) {
}
void g(void) {
}
void barrier(void) {
pthread_mutex_lock(&mutex);
ready_threads++;
if (ready_threads == 2) {
pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mutex... | 0 |
#include <pthread.h>
volatile int varCompartilhada=0;
static pthread_mutex_t mutexLock;
void* incrementa_contador (void *arg)
{
for (unsigned int i=0; i < 10000; i++)
{
pthread_mutex_lock(&mutexLock);
varCompartilhada++;
pthread_mutex_unlock(&mutexLock);
}
return 0;
}
void* decrem... | 1 |
#include <pthread.h>
struct UserThread* Iterator_next(struct UserThreadIterator*);
unsigned int Iterator_hasNext(struct UserThreadIterator*);
struct UserThreadIterator* new_UserThreadIterator(struct UserThreadCollection*);
void dest_UserThreadIterator(struct UserThreadIterator*);
static int it... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int pos;
int jointSocket[4];
void signal_callback_handler(int signum)
{
printf("Caught signal %d\\n", signum);
exit(signum);
}
void *writeThread(void*);
void *readThread(void*);
int main(int argc, char *argv[]){
pthread_t rT, wT;
int s... | 1 |
#include <pthread.h>
int q[2];
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 < 2)
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.