text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
uint32_t abort_signal;
pthread_mutex_t mutex;
pthread_cond_t cond;
int32_t synchronized_data = 0;
void * test_func1(void * param)
{
FUNC_ENTRY;
int32_t ret;
LOG_LOW("Locking mutex");
ret = pthread_mutex_lock(&mutex);
if (ret != 0)
{
LOG_ERROR("Coul... | 1 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t c;
int x;
static void my_cleanup(void *arg) {
printf("my_cleanup\\n");
pthread_mutex_unlock((pthread_mutex_t*)arg);
}
void *thr1(void *p) {
pthread_mutex_lock(&m);
pthread_cleanup_push(my_cleanup, &m);
barrier_wait(&barrier);
whi... | 0 |
#include <pthread.h>
int g_signaled = 0;
pthread_mutex_t g_lock;
pthread_cond_t g_cond;
void *wait(void *data) {
pthread_mutex_lock(&g_lock);
while (g_signaled == 0) {
printf("%lu wait cond\\n", pthread_self());
pthread_cond_wait(&g_cond, &g_lock);
}
pthread_mutex_unlock(&... | 1 |
#include <pthread.h>
pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER;
void
dcethread__default_log_callback (const char* file, unsigned int line, int level, const char* str, void* data)
{
const char* level_name = 0;
switch (level)
{
case DCETHREAD_DEBUG_ERROR:
level_n... | 0 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
void *compute(void *arg)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock(&mutex);
return 0;
}
void wakeup_thread(... | 1 |
#include <pthread.h>
int data1;
int data2;
pthread_mutex_t A;
pthread_mutex_t B;
void * thread_routine_1(void * arg)
{
int tmp;
pthread_mutex_lock(&A);
printf("thread 1 : lock (A)\\n");
tmp = data1;
data2 = tmp+1;
pthread_mutex_unlock(&A);
printf("thread 1 : unlock (A)\\n");
... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
{
int _data;
struct node_list *_next;
}node, *node_p, **node_pp;
node_p head;
static node_p alloc_node(int data)
{
node_p newNode = (node_p)malloc(sizeof(nod... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
int buffer[2];
int buf_first=0;
int buf_last=0;
int buf_count=0;
void produce(int val)
{
pthread_mutex_lock(&mutex)... | 0 |
#include <pthread.h>
struct node {
struct msg msg;
struct node *next;
};
int N = 0;
struct node *head = 0;
struct node *back = 0;
sem_t sem_got;
sem_t sem_left;
pthread_mutex_t mutex;
pthread_mutexattr_t mutattr;
void myqueue_init(const int max_count)
{
pthread_mutexattr_init(& mutattr)... | 1 |
#include <pthread.h>
struct PKW
{
int PSL;
int PIS;
int PO;
int SLD;
int OTH;
int OKW_PSL[20];
int OKW_PIS[20];
int OKW_PO[20];
int OKW_SLD[20];
int OKW_OTH[20];
pthread_barrier_t barrier;
pthread_mutex_t mutex;
};
struct PKW *shared;
void init_shared()
{
int i;
for(i = 0; i... | 0 |
#include <pthread.h>
enum Error {
NoTarget = 1,
AddrInfo,
SocketInit,
};
pthread_t net_speed;
pthread_mutex_t net_speed_update;
int deltabytes = 0;
void *callback(void *arg)
{
int timeout = (int)arg;
while (1) {
if (deltabytes > 0) {
printf("A... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
void rand_sleep(void);
void* student_programming(void* stu_id);
void* ta_teaching();
int main(int argc, char **argv){
printf("CS149 SleepingTA from Muchuan Gong\\n");
pthread_t stud... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
int block;
int busy;
int inode;
pthread_mutex_t m_inode;
pthread_mutex_t m_busy;
void *allocator(){
pthread_mutex_lock(&m_inode);
if(inode == 0){
pthread_mutex_lock(&m_busy);
busy = 1;
pthread_mutex_unlock(&m_busy);
inode... | 1 |
#include <pthread.h>
struct Request;
struct Msg;
struct Request
{
int pid;
};
struct Msg
{
int pid;
char data[512];
};
char *servername = "server2";
char *famfifo = "server2";
int ffd;
int semid;
int numclients = 0;
int ifd,ofd;
int cfd[10][2];
struct pollfd pfd[10];
pthread_t tid;
pthread_mu... | 0 |
#include <pthread.h>
long long int N;
pthread_mutex_t bastao;
int nThreads;
int ehPrimo (long long int n) {
int i;
if (n<=1) return 0;
if (n==2) return 1;
if (n%2==0) return 0;
for (i=3; i<sqrt(n)+1; i+=2)
if(n%i==0) return 0;
return 1;
}
int contaPrimosSeq () {
int qPrimos ... | 1 |
#include <pthread.h>
int _pid;
int _pv;
unsigned short _cote;
Magicien magiciens[4];
int ig_magiciens;
pthread_mutex_t lock;
} Game;
key_t key = (int) 1205;
int shm;
Game *game;
void creerXmagiciens();
int sommeDigitsPid(int pid);
void initialisation();
int rand_a_b(int a, i... | 0 |
#include <pthread.h>
static pthread_mutex_t lock;
static pthread_barrier_t barrier;
int* counterArray;
int nthreads;
int ncounters;
void* chain(void* arglist)
{
int i, j, summation;
long tid = (long) arglist;
for (i = 0; i < nthreads; i++) {
pthread_mutex_lock(&lock);
... | 1 |
#include <pthread.h>
void async_alarm(void);
void insert(char *);
void delete(void);
pthread_mutex_t mutex;
pthread_cond_t cond1;
pthread_cond_t cond2;
struct alarm **head;
} my_struct_t;
struct alarm {
char message[128];
int seconds;
struct alarm *link;
};
struct alarm *start = 0, *te... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
int count = 0;
int task[3];
void *consumer(void *arg)
{
for (;;)
{
int num;
pthread_mutex_lock(&mutex);
while (count <= 0)
pthread_cond_wait(&cond, &mutex);
count--;
num = task[count];
printf("Consumer processed... | 1 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
int val;
struct element* next;
int isDummy;
} element;
element* head;
element* tail;
} queue;
void init_queue(queue *q) {
element *e = (element*)malloc(sizeof(element));
e->isDummy = 1;
e->next = 0;
e->val=0;
... | 0 |
#include <pthread.h>
double *_vector;
double _final_sum;
int *_ranges;
pthread_mutex_t _mutex;
double sum(double* vector, int a, int b) {
double sum = 0.0;
int i = 0;
for (i=a; i<b; i++)
sum += vector[i];
return sum;
}
void* sum_and_add(void* arg) {
int *range_a = (int*) ar... | 1 |
#include <pthread.h>
int fd;
int flag=0;
pthread_mutex_t lock;
pthread_t even_thd,odd_thd;
pthread_cond_t cond;
void handler(int arg)
{
printf("got sinal unpaused\\n");
}
void attr_func(pthread_attr_t *attr)
{
int ret=pthread_attr_init(attr);
if(ret!=0)
perror("pthread_attr_init");
ret=pthrea... | 0 |
#include <pthread.h>
static void* thread_loop(void* arg)
{
struct thread_state *ts = arg;
struct ds_pcm_data pcm;
pthread_mutex_init(&ts->thread_mutex, 0);
pthread_cond_init(&ts->thread_cond, 0);
bool loop = 1;
while (loop) {
switch (ts->state) {
... | 1 |
#include <pthread.h>
int numberOfSeats = 6;
int timeToReturn = 5;
int atPresent = 0;
int napping = 0;
int seedInteger;
void *createCustomer();
void *haircutStore();
void *sittingArea();
void assessLineup();
pthread_mutex_t lineupMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t sittingMutex = P... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_count = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_condition = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_condition = PTHREAD_COND_INITIALIZER;
void* function_count1(void*);
void* function_count2(void*);
int count = 0;
int main(int... | 1 |
#include <pthread.h>
{
int balance;
} Account;
pthread_mutex_t mutex;
void deposit(Account* account, int amount)
{
pthread_mutex_lock(&mutex);
account->balance += amount;
pthread_mutex_unlock(&mutex);
}
void transfer(Account* accountA, Account* accountB, int amount)
{
pthread_mutex... | 0 |
#include <pthread.h>
pthread_t thread1, thread2;
pthread_attr_t attr;
pthread_mutex_t impresor=PTHREAD_MUTEX_INITIALIZER;
void *imprimir (void *arg)
{
char a[12];
pthread_mutex_lock (&impresor);
strcpy(a, (char*)arg);
printf("%s ",a);
pthread_mutex_unlock (&impresor);
pth... | 1 |
#include <pthread.h>
MESSAGE_TYPE_INFO,
MESSAGE_TYPE_ERROR,
MESSAGE_TYPE_FATAL,
MESSAGE_TYPE_MAX_VALUE,
} message_type_t;
static char* message_prefixes[MESSAGE_TYPE_MAX_VALUE] = {
[MESSAGE_TYPE_INFO] = "MEMKIND_INFO",
[MESSAGE_TYPE_ERROR] = "MEMKIND_ERROR",
[MESSAGE_T... | 0 |
#include <pthread.h>
volatile int val;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* ThreadEntry( ){
int i =0;
while(i<30){
sleep(3);
pthread_mutex_lock( &mutex );
printf("\\x1b[32m" "New customer comes into the barber sho... | 1 |
#include <pthread.h>
pthread_mutex_t forks[5];
pthread_t phils[5];
void *philosopher (void *id);
int food_on_table ();
void get_fork (int, int, char *);
void down_forks (int, int);
pthread_mutex_t foodlock;
pthread_cond_t cond;
pthread_mutex_t forks_all;
int sleep_seconds = 0;
int main (int ... | 0 |
#include <pthread.h>
struct timeval start, end;
long mtime, seconds, useconds;
int id;
double balance;
bool bInUse;
pthread_mutex_t mutex;
pthread_cond_t freeAcc;
} Account;
Account bank[4];
void deposit(Account* acc, double amount) {
pthread_mutex_lock(&acc->mutex);
while(acc-... | 1 |
#include <pthread.h>
int main(int argc, char* argv[]){
pthread_t Les_Threads[2];
int delai[2];
void Une_Tache (void *arg);
if (argc != 3) {
printf("Utilisation : %s delai_1 delai_2 !\\n", argv[0]);
return 1;
}
delai[0] = atoi(argv[1]);
delai[1] = atoi(argv[2]);
pthre... | 0 |
#include <pthread.h>
pthread_t processos[300];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int SALDO = 0;
int procId;
int valor;
int tipo;
} PROC;
PROC procs[300];
void initStruct(){
int i = 0;
while (i < 300) {
procs[i].procId = 0;
procs[i].valor = 0;
procs[i].tipo = 0... | 1 |
#include <pthread.h>
void **generateMat();
void printMat(int **mat);
int way1Sort(int **mat);
void maxAndSwap(int **mat, int col);
void *paraMax(void *arg);
int maxVal = 0;
int maxRow = 0;
int **mat;
int N;
int power;
uint64_t timer = 0;
pthread_t thr_id[8];
pthread_mutex_t maxLock;
pthre... | 0 |
#include <pthread.h>
time_t t;
struct tm tm;
char **ssid;
struct timeval startwtime;
pthread_mutex_t *mut;
pthread_cond_t *notFull, *notEmpty;
} ssid_info;
void delete_ssid_info(ssid_info *wifi_info);
ssid_info * ssid_info_init();
void *wifi_writer(void* arg);
void *wifi_scanner(... | 1 |
#include <pthread.h>
struct thread_info {
pthread_t thread_id;
int thread_num;
int consumer;
int qty_actions;
};
struct magic_account
{
double min_amount;
double max_amount;
double actual_amount;
pthread_mutex_t acc_lock;
} * conta_magica;
int QTD_ACTIONS = 100;
sem_t mutex_cons;
sem_t... | 0 |
#include <pthread.h>
struct _thread_data_t {
int tid;
unsigned long long floor;
unsigned long long ceiling;
unsigned long long thread_sum;
};
unsigned long long sum;
pthread_mutex_t lock_sum;
void error( char * msg )
{
perror( msg );
exit( 1 );
}
void * thr_func( void... | 1 |
#include <pthread.h>
extern void io_output(int * arg);
struct _erl_async* next;
struct _erl_async* prev;
long async_id;
void* async_data;
void (*async_invoke)(void*);
void (*async_free)(void*);
} ErlAsync;
pthread_mutex_t mtx;
pthread_cond_t cv;
pthread_t t... | 0 |
#include <pthread.h>
int g_val = 0;
pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
void do_prime(int s)
{
ull_t i;
int flag = 0;
for (i = 2; i < s + 300000000; i++)
{
if ((s + 300000000) % i == 0)
{
... | 1 |
#include <pthread.h>
void reception_task(int tab[]){
int i;
for(i = 0; i<180;i++){
tab[i]=(rand()%180);
}
}
void computation_task(int *tab1, int *tab2){
int i;
for(i=0; i<180;i++){
if (tab1[i]>7){
tab2[i] = tab1[i];
} else{
tab2[i] = 0;
}
}
}
void print_task(int *tab){
... | 0 |
#include <pthread.h>
static pthread_mutex_t mymutex;
static int th_cnt;
static void *body(void *arg)
{
int j;
fprintf(stderr, "Thread %d: %s\\n", th_cnt++, (char *)arg);
pthread_mutex_lock(&mymutex);
for (j=0; j<20; j++) {
usleep(500000);
fprintf(stderr,(char *)arg);
}
pt... | 1 |
#include <pthread.h>
struct node_t
{
char pcm[4096];
struct node_t * next;
};
struct fifo_t
{
struct node_t * head;
struct node_t * tail;
pthread_mutex_t lock;
};
int __init_fifo(int fifo_size)
{
static struct node_t nodes[16];
int i;
static struct fifo_t fifo;
pthread_mutex_init(&fi... | 0 |
#include <pthread.h>
int aa(int b)
{
if(b < 40)
printf("aaaaaaaaaaaaa00000\\n");
else
printf("aaaaaaaaaaaa111111\\n");
}
void *hi(void *ptr)
{
int a = *(int *)ptr;
int b;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mutex1);
if(b > 100)
i... | 1 |
#include <pthread.h>
static int tc_gc_sleep;
static pthread_mutex_t gc_mutex;
static pthread_cond_t gc_cond;
static pthread_t gc_thread;
int tc_gc_init(int gc_sleep)
{
if ((tc_gc_sleep = gc_sleep) <= 0) {
debug("init_tc_gc: gc_sleep must be above 0 seconds");
return 0;
}
pthread_setca... | 0 |
#include <pthread.h>
int hybrid_lock_init(struct hybrid_lock *lock)
{
lock->g_count = 0;
if(pthread_mutex_init(&lock->mLock, 0)!=0){
printf("init error\\n");
return -1;
}
return 0;
}
int hybrid_lock_destroy(struct hybrid_lock *lock)
{
if(pthread_mutex_destroy(&... | 1 |
#include <pthread.h>
enum Colour
{
blue = 0,
red = 1,
yellow = 2,
Invalid = 3
};
const char* ColourName[] = {"blue", "red", "yellow"};
const int STACK_SIZE = 32*1024;
const BOOL TRUE = 1;
const BOOL FALSE = 0;
int CreatureID = 0;
enum Colour doCompliment(enum Colour c1, enum Colo... | 0 |
#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,thread1,(void *)0);
pthread_create(&t_b,0,thread2,... | 1 |
#include <pthread.h>
pthread_mutex_t* mutex;
int pid;
char birth[25];
char clientString[10];
int elapsed_sec;
double elapsed_msec;
} stats_t;
void exit_handler(int sig) {
pthread_mutex_lock(mutex);
pthread_mutex_unlock(mutex);
exit(0);
}
int main(int argc, ch... | 0 |
#include <pthread.h>
pthread_t ntid;
struct foo {
int f_count;
pthread_mutex_t f_clock;
int m_m;
};
struct foo*
foo_alloc(void)
{
struct foo *fp;
if ((fp=malloc(sizeof(struct foo)))!=0) {
fp->f_count=1;
fp->m_m=5;
if (pthread_mutex_init(&fp->f_clock, 0)!=0) {
free(fp);
return ... | 1 |
#include <pthread.h>
int id;
char *name;
int n_execs;
} thread_info_t;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_hello(void *thread_info) {
thread_info_t *thread_info_p = (thread_info_t *) thread_info;
int i = 0;
pthread_mutex_lock(&mutex);
fo... | 0 |
#include <pthread.h>
static int fb_index = 0;
static struct frame_buf *fbarray[FRAME_BUF_NUM];
static struct frame_buf fbpool[FRAME_BUF_NUM];
static pthread_mutex_t g_fb_mtx = PTHREAD_MUTEX_INITIALIZER;
void
VPU_framebuf_init()
{
int i;
for (i = 0; i < FRAME_BUF_NUM; i++)
{
fbar... | 1 |
#include <pthread.h>
int _mosquitto_packet_handle(struct mosquitto *mosq)
{
assert(mosq);
switch((mosq->in_packet.command)&0xF0){
case PINGREQ:
return _mosquitto_handle_pingreq(mosq);
case PINGRESP:
return _mosquitto_handle_pingresp(mosq);
case PUBACK:
return _mosquitto_handle_p... | 0 |
#include <pthread.h>
volatile char running[MAX_CLIENTS];
volatile int sockets[MAX_CLIENTS];
pthread_t threads[MAX_CLIENTS];
pthread_mutex_t meta_lock = PTHREAD_MUTEX_INITIALIZER;
inline void startup_accounting( )
{
int i;
pthread_mutex_lock( &meta_lock );
for( i=0; i<MAX_CLIENTS; ... | 1 |
#include <pthread.h>
long animals;
long food;
long hunters;
long cooks;
pthread_mutex_t anim_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t food_mutex = PTHREAD_MUTEX_INITIALIZER;
int throw()
{
return (rand() % 6 + 1);
}
int change_food_state(int action)
{
int res = 0;
pthread_mut... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
struct my_semaphore {
pthread_mutex_t m;
int count;
};
struct my_semaphore sema;
void my_semaphore_init(struct my_semaphore *s, int count) {
pthread_mutex_init(&(s->m), 0);
pthread_mutex_lock(&(s->m));
s->count = count;
}
void ... | 1 |
#include <pthread.h>
{
int buf[5];
int in;
int out;
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
} sbuf_t;
sbuf_t shared;
void *Producer(void *arg)
{
int i, item, index;
index = (int)arg;
for (i=0; i < 4; i++)
{
item = i;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
struct node{
int number;
struct node *next;
}*head=0;
void cleanup(void *arg){
printf("Cleanup handler of consumer thread\\n");
free(arg);
pthread_mutex_unlock(&mutex);
}
void *func(void *arg){
struct node *p=0;
pthread_clea... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
short value;
char* stuff;
}SharedInt;
sem_t sem;
SharedInt* sip;
void *functionWithCriticalSection(short v) {
pthread_mutex_lock(&(sip->lock));
printf("Crit %i executed by %u.\\n", 1, getpid());
sip->value = sip->value + v;
... | 0 |
#include <pthread.h>
static void dump_memory(const void * loc, size_t size);
static void dump_transaction(unsigned long buffer, unsigned long offset, unsigned long write_size);
static int initialized = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int (*old_ioctl)(int, unsign... | 1 |
#include <pthread.h>
pthread_mutex_t lck = PTHREAD_MUTEX_INITIALIZER;
void *threadFunc(void *id){
int num = *((int*)id);
pthread_mutex_lock(&lck);
printf("\\nThread %d has acquired the lock\\n",num);
for(int i=1; i<6; i++){
int random = (rand() %100);
printf("[%d]:%d\\n",num,random);
}... | 0 |
#include <pthread.h>
struct protoent_data _protoent_data;
void
setprotoent(int f)
{
pthread_mutex_lock(&_protoent_mutex);
setprotoent_r(f, &_protoent_data);
pthread_mutex_unlock(&_protoent_mutex);
}
void
endprotoent(void)
{
pthread_mutex_lock(&_protoent_mutex);
endprotoent_r(&_protoent... | 1 |
#include <pthread.h>
pthread_t t_sM;
struct sim_time_t rt_time;
int fd;
void* rtsock () {
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,0);
int fd = TCP_Server_init(9000,"127.0.0.1");
while (sim_stat != 0) {
int... | 0 |
#include <pthread.h>
extern int idx, sink;
extern double dsink;
extern void *psink;
void bit_shift_main (void);
void dynamic_buffer_overrun_main (void);
void dynamic_buffer_underrun_main (void);
void cmp_funcadr_main (void);
void conflicting_cond_main (void);
void data_lost_main (void);
void data... | 1 |
#include <pthread.h>
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int num = 0;
static void * thr_func(void *p)
{
int i,j,mark;
while(1)
{
pthread_mutex_lock(&mut_num);
while(num == 0)
pthread_cond_wait(&c... | 0 |
#include <pthread.h>
int pocetVedier = 0;
int vedra[10] = {0};
int stoj = 0;
int ODDYCHOVAT = 1, POSLEDNY_VNUTRI = 0;
int count = 0;
pthread_mutex_t mutexVedra = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexSynchronizacia = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condVsetci = PTHREA... | 1 |
#include <pthread.h>
void *find_words(void*);
int map_reduce(int number_threads, char *string, struct list *list);
int main(void) {
char *string;
int cur_time, i, j;
struct list *list;
struct stat *buf;
buf = (struct stat *) malloc(sizeof(struct stat));
stat("./Don_Quixo... | 0 |
#include <pthread.h>
static struct keyleds_ctl
{
int console_fd;
pthread_t th_num, th_cap, th_scr;
pthread_mutex_t cs_mutex;
volatile int t_keyled[8];
} ledctl;
static void *keyled_pulse(void *arg)
{
unsigned int keyleds, iled = (unsigned int)(arg);
int t = 0;
... | 1 |
#include <pthread.h>
static pthread_once_t paymax_init = PTHREAD_ONCE_INIT;
static pthread_mutex_t paymax_mutex = PTHREAD_MUTEX_INITIALIZER;
static int uart_fd;
void init_global_var(void)
{
pthread_mutex_init(&paymax_mutex, 0);
}
static int close_paymax(struct paymax_device_t *... | 0 |
#include <pthread.h>
struct PAQueue *plib_aqueue_new(void)
{
struct PAQueue *new = malloc(sizeof(struct PAQueue));
new->qlock = malloc(sizeof(pthread_mutex_t));
new->q = plib_queue_new();
pthread_mutex_init(new->qlock, 0);
return new;
}
void plib_aqueue_push(struct PAQueue *aq, void *data)
{... | 1 |
#include <pthread.h>
int w, h;
v2df zero = { 0.0, 0.0 };
v2df four = { 4.0, 4.0 };
v2df nzero;
double inverse_w;
double inverse_h;
char *whole_data;
int y_pick;
pthread_mutex_t y_mutex = PTHREAD_MUTEX_INITIALIZER;
static void * worker(void *_args) {
char *data;
double x, y;
int ... | 0 |
#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(err, "sigwait fai... | 1 |
#include <pthread.h>
static void die_with_error(char *message)
{
perror(message);
exit(1);
}
static void radix_tree_init(struct radix_tree *tree, int bits, int radix)
{
if (radix < 1) {
perror("Invalid radix\\n");
return;
}
if (bits < 1) {
perror("Invalid number of bits\\n");... | 0 |
#include <pthread.h>
think,
hungry,
eat,
} Phil;
int phil_left(int ph_id);
int phil_right(int ph_id);
void *phil_action(void *ph);
int print_table();
Phil *phils;
pthread_mutex_t table;
int main(){
pthread_t *thread;
phils = (Phil *) calloc(5, sizeof(Phil));
if(phils ... | 1 |
#include <pthread.h>
static void to_thinking(int n)
{
mod_status(n, THINKING);
}
static void get_sticks(int n)
{
int one;
int first;
int second;
one = 0;
first = (!(n % 2)) ? ((n + 1) % nb_philos) : (n);
second = (!(n % 2)) ? (n) : ((n + 1) % nb_philos);
while (check_status(fi... | 0 |
#include <pthread.h>
pthread_mutex_t happy_mutex;
void *worker(void *varg)
{
long *counter = (long *)varg;
printf("thread 0x%0lx starting\\n", (long)pthread_self());
int i = 0;
for (; i < 100000; i += 1) {
pthread_mutex_lock(&happy_mutex);
*counter += 1;
pthread_mu... | 1 |
#include <pthread.h>
pthread_mutex_t mutexid;
pthread_mutex_t mutexres;
int idcount = 0;
pthread_mutex_t joinmutex[5];
int join[5];
int result[5];
int target;
int sequence[(5 * 30)];
void *thread (void *arg)
{
int id, i, from, count, l_target;
pthread_mutex_lock (&mutexid);
l_t... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void clean_mutex(void * data) {
pthread_mutex_unlock(&mutex);
printf("Thread %d a libéré le mutex\\n", (int) pthread_self());
}
void clean_buffer(void * data) {
int * buffer = (int*) data;
free(buffer);
printf("Thread %d a libéré ... | 1 |
#include <pthread.h>
int inn,inn_size;
int rl,fl,ry,fy,type;
pthread_mutex_t mutex;
sem_t yorks;
sem_t lancs;
int l,y;
pthread_t tid[20];
pthread_attr_t attr;
void initializeData() {
pthread_mutex_init(&mutex, 0);
pthread_attr_init(&attr);
int i;
inn_size = 1;
inn=0;
rl=fl=ry=fy=0;
... | 0 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
int isGreen1 (int s) {
return s == 0;
}
int isGreen2 (int s) {
return s == 0;
}
void * signal1(void* d) {
int status = 0;
b1:
printf("1 -> GREEN\\n");
s... | 1 |
#include <pthread.h>
int q[5];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
int i = 0;
printf2 ("prod: trying\\n");
while (done == 0)
{
i++;
pthread_mutex_lock (&mq);
... | 0 |
#include <pthread.h>
struct foo
{
int f_count;
int f_addtimes;
pthread_mutex_t f_mutex;
};
struct foo * foo_alloc()
{
struct foo* fp;
fp = (struct foo*)malloc(sizeof(struct foo));
if(fp != 0)
{
fp->f_count = 0;
fp->f_addtimes = 0;
pthread_mutexa... | 1 |
#include <pthread.h>
static pthread_mutex_t s_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_cond = PTHREAD_COND_INITIALIZER;
static pthread_cond_t s_cond_monotonic = PTHREAD_COND_INITIALIZER;
void timespec_diff(struct timespec *start,
struct timespec *end,
... | 0 |
#include <pthread.h>
char fileName[256];
long int fileSize;
int fileMode;
struct fileStruct *next;
} fileStruct;
void switchMemory(int *currentMemory, void **writeMemory, void *memory1,
void *memory2, pthread_mutex_t *m1lockw, pthread_mutex_t *m1lockr, pthread_mutex_t *m2lockw, p... | 1 |
#include <pthread.h>
int log_to_stderr = 1;
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 |
#include <pthread.h>
static char running = 1;
static long long counter = 0;
pthread_mutex_t c_mutex;
void *process (void *arg)
{
while (running) {
pthread_mutex_lock (&c_mutex);
counter++;
pthread_mutex_unlock (&c_mutex);
}
pthread_exit (0);
}
int main (i... | 1 |
#include <pthread.h>
static pthread_mutex_t m_go = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t c_go = PTHREAD_COND_INITIALIZER;
static pthread_cond_t c_running = PTHREAD_COND_INITIALIZER;
static volatile int alive, running;
static int spin;
static int rep_nop;
static void *spinner(void... | 0 |
#include <pthread.h>
struct p_lease_v {
int lease;
int pos;
int value;
};
int array[5];
void put(int value, int pos, int lease) {
int i;
array[pos] = value;
}
int get(int pos) {
return array[pos];
}
void clean() {
int i;
for (i = 0; i < 5; ++i) {
if (array[i] != -101) {
array[i] = ... | 1 |
#include <pthread.h>
pthread_mutex_t escaped = PTHREAD_MUTEX_INITIALIZER;
void initSaucer(struct saucer *ship, int row, int delay) {
strncpy(ship->message, SAUCER, SAUCER_LEN);
ship->length = SAUCER_LEN;
ship->row = row;
ship->col = 0;
ship->delay = delay;
ship->hit = 0;
ship->isAlive = 1... | 0 |
#include <pthread.h>
static pthread_mutex_t free_avc_surface_lock = PTHREAD_MUTEX_INITIALIZER;
void
gen_free_avc_surface(void **data)
{
GenAvcSurface *avc_surface;
pthread_mutex_lock(&free_avc_surface_lock);
avc_surface = *data;
if (!avc_surface) {
pthread_mutex_unlock... | 1 |
#include <pthread.h>
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: ;
goto ERROR;
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(void)
{
ret... | 0 |
#include <pthread.h>
struct prodcons
{
int *buffer;
pthread_mutex_t lock;
int readpos;
int writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
struct prodcons buffer;
void prodcons_init(struct prodcons *buf)
{
pthread_mutex_init(&buf->lock, 0);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t wrt;
int readcount = 0;
int shared_val;
void *pthread_reader(void *thread_num);
void *pthread_writer(void *thread_num);
void init();
void sleeping();
void msg_waiting (int thread_type, int thread_num);
void msg_num_of_readers (int ... | 0 |
#include <pthread.h>
pthread_mutex_t mon = PTHREAD_MUTEX_INITIALIZER;
int *rList;
int *tList;
pthread_cond_t *cond;
char **threads;
char **resources;
int tsize;
int rsize;
void initDetector( char tName[][ NAME_LIMIT + 1 ], int tCount,
char rName[][ NAME_LI... | 1 |
#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)
... | 0 |
#include <pthread.h>
long is_in = 0;
long ipert;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* archer(void* arg)
{
int i;
int j = 0;
double x,y;
unsigned int seed = time(0);
for(i = 0; i < ipert; i++)
{
x = ((double)rand_r(&seed)/(32767));
y = ((double)rand_r(&seed)/ (3... | 1 |
#include <pthread.h>
int arr[1024];
pthread_mutex_t semaphore = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t can_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t can_write = PTHREAD_COND_INITIALIZER;
int n_reading = 0, n_writing = 0;
void *escritor(void *arg){
int i;
int num = *((int *)a... | 0 |
#include <pthread.h>
void threadSignalNew(struct ThreadSignal* threadSignal)
{
pthread_mutex_init(&threadSignal->Mutex, 0);
pthread_cond_init(&threadSignal->Condition, 0);
};
void threadSignalDelete(struct ThreadSignal* threadSignal)
{
pthread_cond_destroy(&threadSignal->Condition);... | 1 |
#include <pthread.h>
struct stresser_priv {
void *fnpriv;
int fnrc;
int wait;
pthread_cond_t *cond;
pthread_mutex_t *mutex;
pthread_t thread;
struct stresser_unit *u;
int *count;
};
static void *_stresser_unit(void *p)
{
struct stresser_priv *priv = p;
int rc;
if (priv->wait) {
pth... | 0 |
#include <pthread.h>
struct Buffer_Circ {
int buffer[BUFSIZE];
int bufIN, bufOUT;
int contador;
};
void initbuffer( struct Buffer_Circ *buff) {
pthread_mutex_lock(&buffer_lock);
int i;
for(i=0; i<BUFSIZE; i++){
(*buff).buffer[i] = -1;
}
(*buff).bufIN = 0;
(*buff).bufOU... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condc, condp = PTHREAD_COND_INITIALIZER;
struct cArray {
unsigned int *array;
int offset;
int size;
};
struct object {
int thread;
int n;
struct cArray *arr;
};
void* produce(void *p){... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.