text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
{
int f_count;
pthread_mutex_t f_lock;
int f_id;
}foo;
foo *foo_alloc(int id)
{
foo *fp = 0;
if ((fp = (foo *)malloc(sizeof(foo))) != 0)
{
fp->f_count = 1;
fp->f_id = id;
if (pthread_mutex_init(&fp->f_lock, 0) != 0)
... | 1 |
#include <pthread.h>
enum val_ty {
INT,
UINT,
FLOAT,
BOOL
};
int buf[256];
long size;
long n;
pthread_mutex_t m;
pthread_cond_t c;
} stream_t;
stream_t* in;
stream_t* out;
kernel_t c;
} arg_t;
int pop(stream_t* s) {
pthread_mutex_lock(&(s->m));
while (s->n == -1) {... | 0 |
#include <pthread.h>
int estado [(5)];
pthread_mutex_t mutex;
pthread_mutex_t mux_filo [(5)];
pthread_t jantar[(5)];
void * filosofo ( void * param );
void pegar_hashi ( int id_filosofo );
void devolver_hashi ( int id_filosofo );
void intencao ( int id_filosofo );
void comer ( int id_filosofo );
v... | 1 |
#include <pthread.h>
struct pending_events {
struct trace_event **pending;
int nr_pending;
int nr_alloc;
pthread_mutex_t mutex;
pthread_cond_t cond;
};
struct pending_events pending;
static int finished = 0;
static pthread_t sort_thread;
static int max_pending_events = 1024;
static int comp... | 0 |
#include <pthread.h>
const int run_times = 50000;
int testsize[7]={8,8,64,512,1024,2048,4096};
int test_MB_size;
int write_mode = 0;
int thread_node;
int thread_send_num=1;
int thread_recv_num=1;
pthread_mutex_t count_mutex;
int count = 0;
int go = 0;
pthread_mutex_t end_count_mutex;
int end_c... | 1 |
#include <pthread.h>
struct Task;
int integer;
void* ptr;
} TaskData;
TaskData data;
time_t addedTime;
time_t deadline;
int isRunning;
void (*runnable) (TaskData);
struct Task* next;
struct Task* prev;
} Task;
int workerCount;
pthread_t workers[... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full, empty;
buffer_item buffer[5];
int counter;
pthread_t tid;
pthread_attr_t attr;
void *producer(void *param);
void *consumer(void *param);
void initializeData() {
pthread_mutex_init(&mutex, 0);
sem_init(&full, 0, ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condizione =PTHREAD_COND_INITIALIZER;
int **m1=0;
int **m2=0;
int **m3=0;
int riga;
int riga2;
int colonna;
int colonna2;
int numThread =0;
void stampa(int**m,int riga,int colonna){
for (int i = 0; i < riga; ++i... | 0 |
#include <pthread.h>
int i = 0;
pthread_mutex_t mutex;
void* someThreadFunction1(){
int j;
for (j = 0;j<1000000;j++)
{
pthread_mutex_lock(&mutex);
i += 1;
pthread_mutex_unlock(&mutex);
}
return 0;
}
void* someThreadFunction2(){
int k;
for (k =... | 1 |
#include <pthread.h>
WAITTING,
IDLE,
ASSIGNED,
BUSY
} Thread_Status;
{
pthread_t tid;
pthread_mutex_t mutex;
pthread_cond_t cond;
Thread_Status status;
task_t task;
void * arg;
int cnt;
}Thread_pool_t;
void task(void * arg)
{
printf("I am 线程 %lu, t... | 0 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
int buffer[1];
void * cons(void * arg)
{
int i = 3 * 10;
while(i != 0)
{
pthread_mutex_lock(&mut);
printf("buffer[0] = %d\\n", buffer[0]);
pthread_mutex_unlock(&mut);
i--;
}
pthread_exit(0);
}
void * prod(void * ... | 1 |
#include <pthread.h>
int hasPassed[4];
enum direction{
west,
south,
east,
north
} ;
char * dirstr[4] = { "West", "South", "East", "North"};
struct thread_data{
int dir;
int id;
int order;
};
struct thread_data * dataArray;
pthread_cond_t queueConds[4];
pthread_cond... | 0 |
#include <pthread.h>
int completed=0;
pthread_mutex_t completed_mutex;
pthread_cond_t cv;
void * wait_thread (void *data)
{
pthread_mutex_lock (&completed_mutex);
while(completed==0)
{
printf("Conditional variable not set\\n");
pthread_cond_wait(&cv, &completed_mutex);
}
pthrea... | 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_FI... | 0 |
#include <pthread.h>
static pthread_key_t strerror_buf_key;
static pthread_once_t strerror_buf_key_once = PTHREAD_ONCE_INIT;
static void create_strerror_buf_key()
{
pthread_key_create(&strerror_buf_key, free);
}
static inline char *get_strerror_buf()
{
char *buf;
pthread_once(&stre... | 1 |
#include <pthread.h>
pthread_mutex_t g_mutex;
int g_nflag1, g_nflag2;
static pthread_cond_t g_cond1 = PTHREAD_COND_INITIALIZER;
static pthread_cond_t g_cond2 = PTHREAD_COND_INITIALIZER;
void suspend(int n)
{
pthread_mutex_lock(&g_mutex);
switch (n)
{
case 1:
g_nflag... | 0 |
#include <pthread.h>
struct fumador {
int id;
pthread_mutex_t fumando;
};
pthread_mutex_t tabaco;
pthread_mutex_t papel;
pthread_mutex_t fosforos;
fumador_t * f;
void* fumar(void*);
void* agente(void*);
int main ( int argc, char *argv[] ){
f = (fumador_t*) malloc (3 * sizeof(fumador_... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_threshold_cv = PTHREAD_COND_INITIALIZER;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i < 10; i++) {
pthread_mutex_lock(&count_mutex);
count+... | 0 |
#include <pthread.h>
static void ThrObjExec(void *pArg)
{
struct ThrObj *pObj = pArg;
while(1){
pthread_mutex_lock(&pObj->thr_mutex);
pObj->thr_status = THR_STATE_FREE;
printf("%s | Take a snap waiting for condtion !\\n", __func__);
pthread_cond_wait(&pO... | 1 |
#include <pthread.h>
{
int data;
struct node* next;
}node_t,*node_p,**node_pp;
node_p head=0;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
node_p AllocNode(int d,node_p node)
{
node_p n=(node_p)malloc(sizeof(node_t));
if(!n)
{
perr... | 0 |
#include <pthread.h>
pthread_mutex_t buf_lock;
int start;
int num_full;
pthread_cond_t notfull;
pthread_cond_t notempty;
void *data[10];
} circ_buf_t;
pthread_mutex_t lock_enq = PTHREAD_MUTEX_INITIALIZER;
int data[60];
int count = 0;
void circ_buf_init(circ_buf_t *cbp) ... | 1 |
#include <pthread.h>
int count = 0;
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 < 8; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
printf("inc_count(): ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutexattr_t attr;
int dataItem1;
int dataItem2;
} DataObject;
DataObject dobj = { 50, 50 };
void keepBusy( double howLongInMillisec );
void itemSwap( DataObject* dptr );
void test( DataObject* dptr );
void repeatedSwaps( DataObject* dptr )... | 1 |
#include <pthread.h>
{
char tag;
int buf_len;
char buf[512];
struct _Log_Msg *next;
}log_msg;
{
int log_msg_num;
struct _Log_Msg *next;
}log_msg_list;
{
int log_msg_num;
pthread_mutex_t lock_list_index;
struct _Log_Msg *next;
}log_msg_list_index;
{
struct _Log_Msg_List *log_list_hea... | 0 |
#include <pthread.h>
int count=1;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *counter(void *t)
{
long my_id=(long)t;
int slp;
pthread_mutex_lock(&count_mutex);
count++;
slp=count;
while (slp=sleep(slp));
if (count == 1+3)
{
pthread_cond_broadcast(&count_... | 1 |
#include <pthread.h>
struct parm {
int id;
int ready;
};
pthread_mutex_t msg_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *syscall_setreuid(void *arg)
{
long int rc;
uid_t ru;
(void) arg;
for (ru = 0; ru < 2048; ++ru) {
uid_t ruid, euid, suid;
rc = syscall(SYS_setreuid, -1, ru)... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
pthread_mutexattr_t attr;
pthread_cond_t cond_lock;
struct timeval now;
struct timespec outtime;
int cond_counter = 0;
void down(char*);
void up(char *);
void fork_prepare(void);
void fork_parent(void);
void fork_child(void);
void fork_prepare(voi... | 1 |
#include <pthread.h>
int sum = 0 ;
pthread_mutex_t mutex ;
void *threadBody(void *id)
{
int i ;
for (i=0; i< 100000; i++)
{
pthread_mutex_lock (&mutex) ;
sum += 1 ;
pthread_mutex_unlock (&mutex) ;
}
pthread_exit (0) ;
}
int main (int argc, char *argv[])
{
... | 0 |
#include <pthread.h>
pthread_mutex_t read_mutex;
pthread_mutex_t write_mutex;
void * writeTest(void *temp) {
char *ret;
FILE *file1;
char *str;
pthread_mutex_lock(&write_mutex);
sleep(5);
pthread_mutex_lock(&read_mutex);
printf("\\nFile locked, please enter the message \\n");
str=... | 1 |
#include <pthread.h>
static inline uint32_t getchecksum(void* data, size_t datalen) {
unsigned char* d = data;
uint32_t sum = 0;
size_t i = 0;
for(i = 0; i < datalen; i++) {
sum += d[i];
}
return sum;
}
int packet_encoder_init(char* arg, void** state) {
if(arg == 0 || state == 0) {
... | 0 |
#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_NP);
... | 1 |
#include <pthread.h>
static int ITEMS_SENT[1];
static int ITEMS_RECIEVED[1];
{
int m_input;
int m_output;
int m_numberOfItems;
int m_items[10];
pthread_mutex_t m_lock;
} Buffer;
static Buffer buffer[1];
void InitializeBuffers(void)
{
if (1)
{
printf("\\n(!) Initializing buffers... | 0 |
#include <pthread.h>
static FILE *logfd;
static pthread_mutex_t syslog_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct timeval start_time;
static char *month[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
void rtstepper_close_log(void)
{
if (log... | 1 |
#include <pthread.h>
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int buff[10];
int nitems;
} shared = {
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_COND_INITIALIZER
};
void* produce(void* arg) {
for (;;) {
pthread_mutex_lock(&shared.mutex);
if (shar... | 0 |
#include <pthread.h>
unsigned long long calls = 0, ticks = 0;
double sum = 0;
pthread_mutex_t calls_lock = PTHREAD_MUTEX_INITIALIZER;
static void timer_tick(union sigval _arg)
{
(void)_arg;
unsigned long long res;
pthread_mutex_lock(&calls_lock);
res = calls;
calls = 0;
pthread_mutex_u... | 1 |
#include <pthread.h>
int value;
pthread_mutex_t mutex;
} atomic_integer;
void atomic_init(atomic_integer* item) {
item->value = 0;
pthread_mutex_init(&item->mutex, 0);
}
void atomic_init_and_set(atomic_integer* item, int value) {
item->value = value;
pthread_mutex_init(&it... | 0 |
#include <pthread.h>
char** split_line(char* s){
char* p=malloc(sizeof(char)*1024);
static char** ret;
ret = malloc(sizeof(char*)*2);
ret[0]=malloc(sizeof(char)*16);
ret[1]=malloc(sizeof(char)*1024);
strcpy(p,s);
int i =0;
p = strtok(s, " ");
printf("[INPUT_POSTO] %s\\n", p);
w... | 1 |
#include <pthread.h>
struct JSPropertyCache {
int table;
int empty;
};
pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
struct JSPropertyCache g_cache;
void do_some_work()
{
int i;
for(i = 0; i < 0x2000; i++)
i = i * 10.0 /5 / 2;
return;
}
void * js_FlushPropertyCache(void * p... | 0 |
#include <pthread.h>
int total_cookies_baked = 0;
int cookie_jar[5];
int number_of_cookies_in_jar = 0;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *baker();
void *eater();
int pass = 0;
int main(int argc, char *a... | 1 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
static struct foo *
foo_alloc(int id)
{
struct foo *fp = 0;
int ret = 0;
fp =(struct foo *) malloc(sizeof(struct foo));
if (0 == fp) {
return 0;
}
fp->f_id = id;
... | 0 |
#include <pthread.h>
static unsigned long MemoryPoolSize1=1024*1024*1;
static unsigned long MemoryPoolSize2=1024*1024*32;
static struct rb_root*g_table=0;
static pthread_mutex_t g_ipv6status_lock;
unsigned long get_ipv6_status(unsigned char*ip)
{
unsigned long status=0;
struct my_rbnode*myn... | 1 |
#include <pthread.h>
pthread_mutex_t countAccess = PTHREAD_MUTEX_INITIALIZER;
sem_t block;
int count = 0;
int waiting = 0;
bool mustwait = 0;
unsigned long rdnumber()
{
unsigned long number;
number = genrand_int32();
return number;
}
void *process(int pid)
{
while(1) {
pthread_... | 0 |
#include <pthread.h>
long timeval_diff(struct timeval *t2, struct timeval *t1)
{
long diff = (t2->tv_usec + 1000000 * t2->tv_sec) - (t1->tv_usec + 1000000 * t1->tv_sec);
return (diff);
}
void error(int err, char *msg) {
fprintf(stderr,"%s a retourné %d, message d'erreur : %s\\n",msg,err,st... | 1 |
#include <pthread.h>
pthread_mutex_t m;
int seed = 1;
void* thr1(void* arg){
int nex, nexts, casret, nex_return, nC_return;
casret = 0;
while(casret == 0) {
pthread_mutex_lock (&m);
nex = seed;
pthread_mutex_unlock (&m);
nC_return = __VERIFIER_nondet_int (0,... | 0 |
#include <pthread.h>
pthread_mutex_t rlock;
pthread_mutex_t wlock;
pthread_mutex_t slock;
pthread_t tid;
int readcount;
void intialize(){
pthread_mutex_init(&rlock,0);
pthread_mutex_init(&wlock,0);
readcount=0;
}
void * reader (void * a){
int waittime;
waittime = ... | 1 |
#include <pthread.h>
int type;
int amount;
} transaction;
int num;
transaction *t_array;
} transactions;
int balance;
pthread_mutex_t *balance_lock;
transactions *new_transactions(int num){
int i;
transactions * trs = (transactions*)malloc(sizeof(transactions));
trs->num = num;
... | 0 |
#include <pthread.h>
unsigned int gSharedValue = 0;
pthread_mutex_t gSharedMemoryLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t gReadPhase = PTHREAD_COND_INITIALIZER;
pthread_cond_t gWritePhase = PTHREAD_COND_INITIALIZER;
int gWaitingReaders = 0, gReaders = 0;
int main(int argc, char **argv) {
... | 1 |
#include <pthread.h>
int philosopher_number[5];
int philosopher_state[5];
int chopstick_state[5];
pthread_mutex_t chopsticks[5];
int randomWait(int bound) {
int wait = rand() % bound;
sleep(wait);
return wait;
}
void useChopstick (int chopstick) {
pthread_mutex_lock(... | 0 |
#include <pthread.h>
pthread_mutex_t tlock;
pthread_cond_t qempty;
pthread_cond_t qfull;
int queue[1000];
int head, tail;
int n;
int insertions, extractions;
int calculate_queue_size(void) {
int current_size = 0;
if (head==tail && head !=-1) {
current_size = 1;
} else if (head==tail && ... | 1 |
#include <pthread.h>
int account;
pthread_mutex_t a_lock;
} account;
account *Accounts;
pthread_mutex_t b_lock;
} theBranch;
static theBranch *Bank;
static int nBranches, nAccounts;
void makeBank(int num_branches, int num_accounts) {
nBranches = num_branches;
nAc... | 0 |
#include <pthread.h>
int NumPhilosophers;
char* philosopherState;
pthread_cond_t* eatTurn;
pthread_mutex_t chopsticksDispute;
pthread_t* philosophersThreads;
int* seats;
void philosophize(void* ptr);
void philosophersStateInit();
void printPhilosophersState(char c, int seat);
void i... | 1 |
#include <pthread.h>
int main(int argc, char *argv[])
{
pthread_mutex_t mutex;
if(argc < 2)
{
printf("-usage: %s [error|normal|recursive]\\n",argv[1]);
exit(1);
}
pthread_mutexattr_t mutexattr;
pthread_mutexattr_init(&mutexattr);
if(strcmp(argv[... | 0 |
#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)
{
top--;
}
int get_top(vo... | 1 |
#include <pthread.h>
struct finalize_info final;
sem_t final_sem;
int finalize_init();
int finalize_destroy();
int finalize_init(){
if(final.node == 0){
final.count = 0;
final.node = tableCreate(MAX_NODE_NUM, sizeof(struct finalize_node));
sem_init(&final_sem, 0, 0);
}
return 1;
}
int... | 0 |
#include <pthread.h>
int do_debug = 0;
int do_thread = 0;
int do_stdin = 0;
int do_sleep = 0;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t rand_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t dice_mutexes[7] = {
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIAL... | 1 |
#include <pthread.h>
int cnt;
pthread_mutex_t mutex;
} barrier;
void* thread_func(void* i);
barrier b;
float *v, *v1, *v2, *mat;
int k;
int main(int argc, char** argv) {
if (argc != 2) {
printf("Syntax : %s k\\n", argv[0]);
return 0;
}
k = atoi(argv[1]);
v1 = (float*) malloc(k * siz... | 0 |
#include <pthread.h>
struct list {
int data;
struct list *next;
};
pthread_mutex_t global_lock;
pthread_mutex_t local_lock;
struct list *shared = 0;
void *run(void *arg) {
struct list *cur;
pthread_mutex_lock(&global_lock);
for (cur = shared; cur; cur = cur->next) {
int *data ... | 1 |
#include <pthread.h>
int number = 0;
pthread_t id[2];
pthread_mutex_t mut;
void thread1(void) {
int i;
printf("Hello, I am pthread1!\\n");
for (i = 0; i < 3; i++)
{
pthread_mutex_lock(&mut);
number++;
printf("THread1: number = %d\\n", number);
... | 0 |
#include <pthread.h>
char SPLIT_CHAR[] = {' ', '\\n', '<'};
int STRING_LENGTH = 41;
FILE *fp;
int sharedByteRead = 0;
int sharedTotalCount = 0;
pthread_mutex_t lock;
void *countByte(void *param){
char *buf = param;
int TARGET_SIZE = strlen(buf);
int DIFF_LENGTH = TARGET_SIZE ... | 1 |
#include <pthread.h>
int fd;
pthread_mutex_t mutex;
uint8_t ucRev;
uint8_t ucOptAv;
} xChipIo;
xChipIo *
xChipIoOpen (const char * sI2cBus, int iSlaveAddr) {
xChipIo * chip = malloc (sizeof (xChipIo) );
if (chip) {
int iReg;
memset (chip, 0, sizeof (xChipIo) );
chip-... | 0 |
#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_to... | 1 |
#include <pthread.h>
int sem_wait(sem_t *sem)
{
int result = 0;
if (!sem)
{
result = EINVAL;
}
else if (!pthread_mutex_lock(&sem->mutex))
{
if (--(sem->value) < 0)
{
pthread_cond... | 0 |
#include <pthread.h>
{
double a[12000000/3];
double globalsum[50];
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[3];
pthread_mutex_t mutexsum;
double x[12000000];
double moments[50];
void generate_data(double *destination, int n, double xmin, double xlimit, int seed)... | 1 |
#include <pthread.h>
void* thread1(void*);
void* thread2(void*);
void* thread3(void*);
pthread_mutex_t m;
void main(){
printf("Main start..!");
pthread_t tid1,tid2,tid3;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_mutex_init(&m,0);
pthread_create(&tid1,&attr,thread1,0);
pthread... | 0 |
#include <pthread.h>
sem_t empty_pot,full_pot;
static pthread_mutex_t servings_mutex;
static pthread_mutex_t print_mutex;
static int servings=15;
void *Savage(void *id)
{
int savage_id=*(int *)id;
while(1)
{
pthread_mutex_lock(&servings_mutex);
if(servings==0)
{
sem_post(&empty_pot)... | 1 |
#include <pthread.h>
int sem1;
int cleanup_flag;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void a_cleanup_func()
{
cleanup_flag=1;
return;
}
void *a_thread_func()
{
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
pth... | 0 |
#include <pthread.h>
void mux_3_pcsource(void *not_used){
pthread_barrier_wait(&threads_creation);
while(1){
pthread_mutex_lock(&control_sign);
if(!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait,&control_sign) != 0);
}
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex[5];
void* philosopher(void* arg)
{
int *number;
number=(int*) arg;
while(1)
{
printf("philosopher %d is thinking\\n",*number );
sleep(2);
pthread_mutex_lock(&mutex[*number]);
printf("philosopher %d is waiting for eating(handle a chops... | 0 |
#include <pthread.h>
int numCookies =10;
int tid;
} thread_param;
pthread_mutex_t mutex;
void* thread_consumer_func(void* pthread_arg)
{
thread_param* myParam = (thread_param*) pthread_arg;
int cookiesRetrieved =0;
while(cookiesRetrieved<15)
{
pthread_mutex_lock(&mutex);
if(numCoo... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
struct node {
int n_number;
struct node *n_next;
} *head=0;
static void cleanup_handler(void*arg) {
printf("Clean up handler of second thread.\\n");
fr... | 0 |
#include <pthread.h>
static char envbuf[1000];
extern char **environ;
char *getenv(const char *name){
int i,len;
len = strlen(name);
for ( i=0;environ[i] != 0; i++ ){
if ((strncmp(name,environ[i],len) == 0) && (environ[i] == '=') ){
strcpy(envbuf,&environ[i][len+... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void thread_init(void)
{
pthread_key_create(&key, free);
}
char *getenv(const char *name)
{
int i,... | 0 |
#include <pthread.h>
long mtype;
char mtext[128];
} message_buf;
char file[][10]={"a.txt","b.txt","c.txt","d.txt","e.txt"};
pthread_mutex_t lock;
int msqid;
void *send(void *name)
{
if ((msqid = msgget(123,IPC_CREAT|0666)) < 0)
{ printf("exit\\n... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
struct shared
{
int counter;
char msg[10];
};
uint64_t gettid() {
pthread_t ptid = pthread_self();
return (uint64_t) ptid;
}
void* mythread_entry(void *args)
{
struct shared *SharedCounter = (struct shared*)args;
for(int i=0; i<1000; i+... | 0 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
struct arg{
int i;
};
void cal(int i, void* p);
static void* func(void *p);
int main(int argc, const char *argv[])
{
int err, i;
pthread_t tid[4];
for (i = 0; i < 4; i++) {
err = pthrea... | 1 |
#include <pthread.h>
int global;
pthread_mutex_t glock;
int local[4];
pthread_mutex_t llock[4];
int threshold;
} counter_t;
void init(counter_t *c, int threshold) {
c->threshold = threshold;
c->global = 0;
pthread_mutex_init(&(c->glock), 0);
int i;
fo... | 0 |
#include <pthread.h>
int nbPB;
pthread_t thBus;
pthread_t thPassagers [45];
pthread_mutex_t mutex_places;
pthread_cond_t cond_busVide;
pthread_cond_t cond_busPlein;
pthread_cond_t cond_finVisite;
pthread_cond_t cond_busPret;
} bus_t;
static bus_t bus = {
.nbPB = 0,... | 1 |
#include <pthread.h>
static struct packet_buffer pktbuf;
static struct packet_buffer_t *full_packet = 0;
static int packet_buffer_count = 0;
static int front = 0, rear = 0;
static int bufuse = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int pktbuf_num_of_buffers (voi... | 0 |
#include <pthread.h>
pthread_mutex_t bookKeeping = PTHREAD_MUTEX_INITIALIZER;
pthread_t jobs[4];
float savings = 0;
int numberOfJobs = 0;
void LostJob() {
int index;
for (int i = 0; i < numberOfJobs; i++) {
if (jobs[i] == pthread_self()) {
index = i;
}
}
for (int i = index + 1; i < ... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
};
struct foo * foo_alloc(){
struct foo * fp;
if((fp = malloc(sizeof(struct foo))) !=0 ){
fp->f_count = 1;
if(pthread_mutex_init(&fp->f_lock , 0) != 0)... | 0 |
#include <pthread.h>
void *philosopher(void *id);
pthread_t philo[5];
void grab_fork(int, int, char *);
void putdown_fork(int, int);
pthread_mutex_t fork_lock[5];
int start = 0;
int main()
{
int i;
for (i = 0; i < 5; i++)
{
pthread_mutex_init (&fork_lock[i], 0);
if (pthread_mute... | 1 |
#include <pthread.h>
int source[30];
int minBound[3];
int maxBound[3];
int channel[3];
int th_id = 0;
pthread_mutex_t mid;
pthread_mutex_t ms[3];
void sort (int x, int y)
{
int aux = 0;
for (int i = x; i < y; i++)
{
for (int j = i; j < y; j++)
{
if (source[i] > source[... | 0 |
#include <pthread.h>
sem_t PID_sem, signal_sem;
bool stop = 0;
double y = 0;
struct udp_conn connection;
pthread_mutex_t mutex;
volatile int period_us = 5000;
int udp_init_client(struct udp_conn *udp, int port, char *ip)
{
struct hostent *host;
if ((host = gethostbyname(ip)) == 0) return -... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thread_func1(void *p)
{
long int i=0;
while(i<10)
{
i++;
pthread_mutex_lock(&mutex);
printf("the 1 thread %ld lock\\n",i);
printf("the 1 thread %ld lock\\n",i+1);
pthread_mutex_trylock(&mutex);
(*(long int*)p)++;
printf("p now is ... | 0 |
#include <pthread.h>
struct epoll_event g_eventstack[1024];
struct epoll_event *g_eventend = g_eventstack;
pthread_mutex_t g_eventstacklock;
static void push_events(struct epoll_event *e, int num)
{
assert(num >= 0);
assert(g_eventend + num < g_eventstack + 1024);
pthread_mutex_lock(&g_e... | 1 |
#include <pthread.h>
struct rtpp_ttl_priv {
struct rtpp_ttl pub;
int max_ttl;
int ttl;
pthread_mutex_t lock;
};
static void rtpp_ttl_dtor(struct rtpp_ttl_priv *);
static void rtpp_ttl_reset(struct rtpp_ttl *);
static void rtpp_ttl_reset_with(struct rtpp_ttl *, int);
static int rt... | 0 |
#include <pthread.h>
void barreira_init(int n) {
B.arrive = calloc(n, sizeof(int));
B.continua = calloc(n, sizeof(int));
B.final = calloc(n, sizeof(int));
B.arrive_mutex = calloc(n, sizeof(pthread_mutex_t));
B.continua_mutex = calloc(n, sizeof(pthread_mutex_t));
B.arrive_c... | 1 |
#include <pthread.h>
void my_handler(int s)
{
fprintf(stderr, "exit");
exit(1);
}
pthread_mutex_t PrintMutex;
void* print_xs (void* unused)
{
while (1)
{
usleep(3 * 1000);
pthread_mutex_lock(&PrintMutex);
fprintf (stderr, "123");
fprintf (stderr, "456");
fprintf... | 0 |
#include <pthread.h>
int data;
struct _node *next;
}node_t, *node_p, **node_pp;
node_p head = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static node_p alloc_node(int _d)
{
node_p tmp = (node_p)malloc(sizeof(node_t));
if(tm... | 1 |
#include <pthread.h>
volatile int buffer[5];
volatile int cont_buffer = 0;
volatile int out = 1;
pthread_mutex_t mutex;
pthread_cond_t cond_prod;
pthread_cond_t cond_cons;
int fibo (int n) {
int t0 = 0, t1 = 1;
for ( ; n > 0; --n) {
t0 += t1;
t1 ^= t0 ^= t1 ^= t0;
}
retur... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_variable = PTHREAD_COND_INITIALIZER;
int sum = 0;
int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int i = 0;
struct Task {
int first;
int last;
};
void create_thread(pthread_t* thread,
... | 1 |
#include <pthread.h>
pthread_mutex_t alarm_mutex;
volatile int spawnflag;
void uplink_alarm_handle(int sig) {
pthread_mutex_lock(&alarm_mutex);
spawnflag++;
pthread_mutex_unlock(&alarm_mutex);
}
void uplink_alarm_init(unsigned long delta) {
spawnflag = 0;
pthread_mutex_init(&alarm_mut... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
double maximum=0;
double minimum=0;
double total=0;
double average=0;
int k=0;
int count=0;
int flag=0;
void *Add1(void *dummy)
{
while(1)
{
double num=0;
if(k==1)
{
pthread_exit(0);
return 0;
... | 1 |
#include <pthread.h>
static int iTThreads = 2;
static int iRThreads = 1;
static int data1Value = 0;
static int data2Value = 0;
pthread_mutex_t data1Lock;
pthread_mutex_t data2Lock;
void lock(pthread_mutex_t *);
void unlock(pthread_mutex_t *);
void *funcA(void *param) {
pthread_mutex_lock(... | 0 |
#include <pthread.h>
int food=100;
pthread_mutex_t chopstick[5];
pthread_mutex_t foodlock;
void get_chopstick(int phil,int c,char hand)
{
pthread_mutex_lock(&chopstick[c]);
printf("Philosopher %d: got %c chopstick %d\\n", phil, hand, c);
}
void leave_chopsticks(int phil ,int c ,char ... | 1 |
#include <pthread.h>
uint32_t inode[16];
uint32_t pos[16];
uint32_t time[16];
uint64_t chunkid[16];
uint32_t chunkversion[16];
uint8_t csdatasize[16];
uint8_t *csdata[16];
} hashbucket;
static hashbucket *chunklochash = 0;
static pthread_mutex_t clcachelock = PTHREAD_MUTEX_INITIALIZER;
... | 0 |
#include <pthread.h>
struct sockaddr;
int rootwrap_bind (int, int, int, const struct sockaddr *, size_t);
static int recv_fd (int p)
{
struct msghdr hdr;
struct iovec iov;
struct cmsghdr *cmsg;
int val, fd;
char buf[CMSG_SPACE (sizeof (fd))];
hdr.msg_name = 0;
... | 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>
unsigned short IA = 0;
unsigned int int_queueing = 0;
unsigned short int_queue[256];
unsigned char iq_back = 0;
unsigned char iq_front = 0;
void recv_int(unsigned short int_val)
{
static pthread_mutex_t iq_front_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&... | 1 |
#include <pthread.h>
int capacity, num_found;
int *data;
pthread_mutex_t lock;
} PrimeList ;
PrimeList * work_list;
int start;
int end;
} ThreadWork;
PrimeList *primelist_alloc(int capacity)
{
PrimeList *list = malloc(sizeof(PrimeList));
list->capacity = capacity;
list->num_found = 0;... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.