text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_t thread_table[8];
pthread_mutex_t mutexsum;
int sum=0;
int id;
char *string;
}threads_param;
threads_param parameters[8];
void *function_cars (void *aux) {
threads_param *p = (threads_param*)aux;
int random;
printf("Start %s %d\\n", p->string, p->id);
... | 1 |
#include <pthread.h>
int N=100;
int T=2;
pthread_mutex_t mutex;
int *v;
int x;
int ocurrencias=0;
double dwalltime(){
double sec;
struct timeval tv;
gettimeofday(&tv,0);
sec = tv.tv_sec + tv.tv_usec/1000000.0;
return sec;
}
void *buscar(void *s)... | 0 |
#include <pthread.h>
void *fun1(void *);
void *fun2(void *);
struct tag {
int shared_data;
pthread_mutex_t mutex;
pthread_cond_t cond1;
} abc = {0,PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER};
int main (void)
{
pthread_t thread1;
pthread_t thread2;
int status;
status = pthread_cr... | 1 |
#include <pthread.h>
const int MAX_KEY = 65536;
const int MAX_THREADS = 1024;
struct node {
int val;
struct node* next;
};
struct node* head = 0;
int n = 1000;
int m = 10000;
float mMember = 0.50;
float mInsert = 0.25;
float mDelete = 0.25;
int thread_count = 1;
double start_time,... | 0 |
#include <pthread.h>
enum {
ARGV_ADDRESS = 1,
ARGV_PORT = 2,
ARGV_THREADS = 3,
ARGV_REQUESTS = 4
};
long requests;
pthread_mutex_t requests_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *thread_worker(void *arg)
{
struct addrinfo *r_ptr = 0;
while (1) {
pthread_m... | 1 |
#include <pthread.h>
pthread_mutex_t mx1=PTHREAD_MUTEX_INITIALIZER;
int st;
int vec;
int vec2[10000];
void *f1(void *arg)
{
int i,j;
while(st)
{
pthread_mutex_lock(&mx1);
j=0;
for(i=0;i<10000;i++)
if (vec2[i]==1)j++;
printf("Vec %d \\n",j);
pthread_mute... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int number;
char name[20];
struct node *next;
struct node *previous;
}Node;
Node *head = 0;
Node *tail = 0;
void add(){
Node *p;
if ((p = (Node*)malloc (sizeof (Node))) == (Node*)0){
printf ("Node could not be allocated\... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t init = PTHREAD_COND_INITIALIZER;
int initialized = 0;
void func1(){
pthread_mutex_lock(&lock);
printf("In func1\\n");
initialized = 1;
pthread_cond_signal(&init);
pthread_mutex_unlock(&lock);
pthread_exit(... | 0 |
#include <pthread.h>
char *kvp_extract_value(char *pair)
{
char *part2, *value;
if (!(part2 = strchr(pair, '=')))
{
fprintf(stderr, "kvp_extract_value: not a key=value pair: %s\\n", pair);
return strdup("");
}
*part2++ = '\\0';
*strchr(part2, '... | 1 |
#include <pthread.h>
pthread_t tid;
int idx;
long n_inc;
long c[1];
long *p;
} * thread_arg_t;
pthread_mutex_t mutex;
long g = 0;
void * thread_func(void * _arg) {
thread_arg_t arg = _arg;
long i;
long n_inc = arg->n_inc;
static long s = 0;
long l = 0;
pthread_mutex_... | 0 |
#include <pthread.h>
pthread_mutex_t locki[26];
pthread_mutex_t lockb[26];
int busy[26];
int inode[32];
pthread_t tids[26];
void *thread_routine(void * arg)
{
int i,b,j;
int tid;
tid = *((int *)arg);
i = tid % 32;
assert(i >=0 && i < 26);
pthread_mutex_lock( &locki[i] );
i... | 1 |
#include <pthread.h>
pthread_mutex_t serialLock;
static int serial = -1;
static long long int startTime = 0;
static int errorLog = 1;
int initAXcomm(int baudrate) {
if(pthread_mutex_init(&serialLock, 0)) {
printf("ERROR : cannot create mutex\\n");
return -2;
}
serial = serialOpen("/dev/... | 0 |
#include <pthread.h>
pthread_mutex_t udp_thread_status_mutex;
int udp_thread_status = 0;
struct udp_thread_args
{
char *ip;
int port;
int msg_len;
};
void print_hex(const char *s)
{
while(*s)
printf("%02x ", *s++);
printf("\\n");
}
float ntohf(uint32_t p)
{
float f ... | 1 |
#include <pthread.h>
pthread_mutex_t my_mutex;
int ticket=10;
void* thread_function1(void* arg);
void* thread_function2(void* arg);
int main(int argc,char* argv[])
{
pthread_t thid1;
pthread_t thid2;
pthread_mutex_init(&my_mutex,0);
pthread_create(&thid1,0,thread_function1,0);
pthread... | 0 |
#include <pthread.h>
static pthread_key_t g_data_key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void free_key(void *arg)
{
fprintf(stderr, "%s %d %s pthread_key_delete\\n", "env_key.c", 15, __func... | 1 |
#include <pthread.h>
{
int buf[3];
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;
struct timeval currenttime;
int sec;
index = (int)arg;
for (i = 0; i ... | 0 |
#include <pthread.h>
void RainGet(void) {
static struct timeval tPreviousReading = { 0, 0 };
struct timeval tNow,
tInterval;
char *pRain = malloc(GP_LOGBUFFERSIZE);
gettimeofday(&tNow, 0);
timersub(&tNow, &tPreviousReading, &tInterval);
writeLog(GP_LOGLEVELHIGH, "Rain: Processin... | 1 |
#include <pthread.h>
int fire_area;
static void *trigger_run(void *arg)
{
int buttons_fd;
int flags=0, flags2=0;
struct st_caller *caller;
buttons_fd = open("/dev/buttons", 0);
if (buttons_fd < 0) {
perror("open device buttons");
exit(1);
}
for (;;) {
char current_... | 0 |
#include <pthread.h>
{
pthread_mutex_t mutex;
int n_data;
pthread_cond_t cond;
int max_queue;
int max_send;
int n_sent;
} queue_t;
{
queue_t *queue;
int id;
pthread_t pid;
} args_t;
void *sender(void *arg)
{
args_t *args = (args_t *)arg;
queue_t *q = args->queue;
int n_sen... | 1 |
#include <pthread.h>
pthread_mutex_t global_lock;
char buffer[(8)][(4096)];
int bp[(8)];
pthread_mutex_t lock[(8)];
int running = 0;
void* producer(void* arg)
{
static struct timeval time_r_start;
static struct timeval time_r_end;
int p = (int)(0xff & (long)(arg));
unsigned long ... | 0 |
#include <pthread.h>
pthread_mutex_t forks[(5 -1)];
pthread_mutex_t waiter;
void summon_the_boy(int philosopher)
{
pthread_mutex_lock(&waiter);
printf("Philosopher %i snapped his fingers! \\n", philosopher);
}
void insult_waiter(int philosopher)
{
printf("Philosopher %i was super con... | 1 |
#include <pthread.h>
extern char NullAddr[21];
void Talk_Call_Task(int uFlag, const char *call_addr, const char *call_ip);
void Talk_Call_End_Task(void);
void Talk_Call_TimeOut_Task(void);
void Talk_Call_Task(int uFlag, const char * call_addr, const char * call_ip)
{
int i;
int j;
uint32_... | 0 |
#include <pthread.h>
int room_number;
long expiry_time;
struct node *next;
} Node;
Node *head;
int pending;
pthread_mutex_t mutex;
pthread_cond_t cond;
} shared_data_t;
Node *insert(Node *head, int room_number, long expiry_time) {
Node *newNode = (Node*) mall... | 1 |
#include <pthread.h>
struct object_slab {
struct linked_list slabs_list;
void * ready_list;
unsigned int used_objects;
unsigned long object_memory[];
};
static void corrupted_canary(const void * object) ;
static void corrupted_canary(const void * object)
{
printf("memory overrun on object ... | 0 |
#include <pthread.h>
pthread_t thread_id;
pthread_mutex_t mutex_count;
pthread_cond_t thr_con,pro_con;
int thread_count =0;
int ticket =100;
sem_t *semaphore,*empty,*full;
void hand(int sig)
{
printf("clearing\\n");
sem_close(semaphore);
sem_close(empty);
sem_close(full);
sem_unlink("/empt... | 1 |
#include <pthread.h>
int run_op(const char* command) {
FILE *fp;
char path[1035];
fp = popen(command, "r");
if (fp == 0) {
fprintf(stderr, "Failed to run command %s\\n", command );
return(1);
}
while (fgets(path, sizeof(path), fp) != 0) {
fprintf(stdout, "%s", pat... | 0 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
struct foo *f_next;
};
struct foo *foo_alloc(int id) {
struct foo *fp;
int idx;
if((fp = (struct foo *)malloc... | 1 |
#include <pthread.h>
pthread_mutex_t mutexid;
pthread_mutex_t mutexres;
int idcount = 0;
pthread_mutex_t joinmutex[2];
int join[2];
int result[2];
int target;
int sequence[(2 * 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_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
char locks_and_semaphores_init();
void destroy_locks_and_semaphores();
void create_student_threads
(pthread_t t_ids[], unsigned int t_indexes[]);
void join_student_threads
(pthread_t t_ids... | 1 |
#include <pthread.h>
volatile int a2lFD = -1;
volatile int l2aFD = -1;
pthread_mutex_t * mutex;
void bailout();
static void startup() {
printf("initializing audit library\\n");
l2aFD = open(PIPE_L2A, O_WRONLY);
if (l2aFD == -1) {
perror("could not open pipe from library to auditor"... | 0 |
#include <pthread.h>
struct philosopher {
pthread_t tid ;
pthread_cond_t cond ;
int status ;
} phi_buf[5] ;
pthread_mutex_t phi_lock ;
void print_status () {
int i ;
for (i = 0 ; i < 5 ; ++i ) {
if (phi_buf[i].status == 0 )
printf ("哲学家 %d 正在思考\\n" , i) ;
else if (phi_buf[i].status =... | 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;
int sleep_seconds = 0;
int
main (int argn,
char **argv)
{
int i;
if (argn ... | 0 |
#include <pthread.h>
pthread_t tid[4];
pthread_mutex_t lock;
unsigned int length, TOTAL_BYTES, READED_BYTES, sub_length, total_found = 0;
int counter = 0;
long long pos = 0;
char target[256];
FILE* file;
char* data;
int finished = 0;
unsigned int string_search(char* data,int length) {
uns... | 1 |
#include <pthread.h>
int j = 0;
pthread_mutex_t mutex;
pthread_cond_t * cases;
pthread_cond_t cercle;
pthread_cond_t attente_robots;
int * cases_reader;
int nb_attente;
pthread_t cercle_tid;
void init_circle() {
int i;
nb_attente = 0;
pthread_mutex_init(&mutex, 0);
pthread_c... | 0 |
#include <pthread.h>
struct data {
long counter[256];
};
const int SIZE = sizeof(struct data);
static pthread_mutex_t output_mutex;
static struct data data;
void *run(void *raw_name) {
time_t thread_start = time(0);
char *name = (char *) raw_name;
int fd = -1;
time_t o... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void *taxi_arrive( void *p )
{
char *name = (char *)p;
printf( "taxi %s has arrived and waitting\\n",name );
pthread_mutex_lock( &mutex );
pthread_cond_wait( &cond,&mutex );
pthread_mutex_unlock( &mutex ... | 0 |
#include <pthread.h>
int fd = -1;
char *network_interface;
char *serial_device;
char *log_file;
char *netaddr;
char *netmask;
FILE *fplog;
pthread_mutex_t mutex1,mutex2, mutexlog;
pthread_cond_t cond2,condlog;
pthread_t tid1,tid2,tid3, tid4;
struct frame_queue *sendque_head;
struct frame_... | 1 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int valeur_commune = 0;
void* incr_routine(void * thread_number){
int i = *(int*) thread_number;
i += 1;
while (1) {
struct timespec tim;
tim.tv_sec = 0;
... | 0 |
#include <pthread.h>
void print_account_requests(int size);
void print_account_ids(int *list, int n);
pthread_mutex_t mutex;
int value;
int request;
}account;
int size, *request_priority;
account **account_list;
pthread_cond_t account_cv;
account *create_account(){
account *a = mallo... | 1 |
#include <pthread.h>
static void set_timer();
static void timer_handler(int sig);
static void set_timer(){
struct itimerval itv,oldtv;
itv.it_interval.tv_sec = configuration.time_wait_unit;
itv.it_interval.tv_usec = 0;
itv.it_value.tv_sec = configuration.time_wait_unit;
itv.it... | 0 |
#include <pthread.h>
int g = 0;
pthread_mutex_t l;
void bar1() {
g = 5;
RC_ACCESS(3, RC_ALIAS | RC_MHP | RC_RACE);
RC_ACCESS(3, RC_ALIAS | RC_MHP | RC_RACE);
RC_ACCESS(4, RC_ALIAS | RC_MHP | RC_RACE);
}
void bar2() {
g = 5;
RC_ACCESS(1, RC_ALIAS | RC_MHP | RC_PROT... | 1 |
#include <pthread.h>
int pthread_barrier_timedwait(
pthread_barrier_t *barrier,
const struct timespec *restrict abstime,
const char *desc)
{
int retval = 0;
pthread_mutex_lock(&barrier->mutex);
++(barrier->count);
if (barrier->count > barrier->... | 0 |
#include <pthread.h>
int recordSize = 1024;
int threadsNr;
char *fileName;
int fd;
int numOfRecords;
int creatingFinished = 0;
char *word;
int rc;
int someonefound = 0;
int detachedNr = 0;
pthread_key_t key;
pthread_t *threads;
int *wasJoin;
pthread_mutex_t mutexForRecords = PTHREAD_MUTEX_INI... | 1 |
#include <pthread.h>
double resultado;
int valor;
} razao;
int contador = 0, limite_inferior, limite_superior, num_threads, tam_array;
razao* razoes;
pthread_mutex_t count;
pthread_barrier_t barrier;
void encontrar_amigos_mutuos(int index){
razao primeira = razoes[index];
int j;
int ... | 0 |
#include <pthread.h>
pthread_mutex_t readlock;
pthread_mutex_t writelock;
pthread_mutex_t priority;
int read_cnt=0;
char buf[100];
void reader(void* arg)
{
pthread_mutex_lock(&priority);
pthread_mutex_lock(&readlock);
if(++read_cnt==1)
pthread_mutex_lock(&writelock);
pthread_mutex_unlock(&rea... | 1 |
#include <pthread.h>
const double REAL_PI = 3.141592653589793238462643383279502884197169399;
int threadid;;
int num_threads;
int num_steps;
pthread_mutex_t *mtx;
double *sump;
} thr_data_t;
double get_wtime()
{
double t;
static int sec = -1;
struct timeval tv;
ge... | 0 |
#include <pthread.h>
struct queue_s {
int *ringbuf;
size_t nslots;
int idx_enq;
int idx_deq;
pthread_mutex_t mutex;
pthread_cond_t cond_not_full;
pthread_cond_t cond_not_empty;
};
queue_t *
queue_create(size_t n)
{
queue_t *q;
int *buf;
if(0 == n)
... | 1 |
#include <pthread.h>
struct rtpp_queue
{
struct rtpp_wi *head;
struct rtpp_wi *tail;
pthread_cond_t cond;
pthread_mutex_t mutex;
int length;
char *name;
int qlen;
};
struct rtpp_queue *
rtpp_queue_init(int qlen, const char *fmt, ...)
{
struct rtpp_queue *queue;
... | 0 |
#include <pthread.h>
int buffer;
int bufferindicator = 0;
pthread_mutex_t cmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condvar = PTHREAD_COND_INITIALIZER;
void* writer_thread(void *arg)
{
int lindex = 0;
while(lindex < 20)
{
pthread_mutex_lock(&cmutex);
while (bufferind... | 1 |
#include <pthread.h>
void * handle_clnt(void * arg);
void send_msg(char * msg, int len);
void error_handling(char * msg);
int clnt_cnt=0;
int clnt_socks[256];
int clnt_num[256];
int clnt_sock;
pthread_mutex_t mutx;
void *handle_test(void *arg){
printf("00000");
}
int main(int argc, char *... | 0 |
#include <pthread.h>
static pthread_mutex_t oliMutexes [4] ;
int oliThreadCreate(void *(*fn)(void *))
{
pthread_t myThread;
return pthread_create(&myThread, 0, fn, 0);
}
void oliLock(int key)
{
pthread_mutex_lock(&oliMutexes[key]);
}
void oliUnlock(int key)
{
pthread_mutex_unlock(&oliMut... | 1 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t sumLock;
int compute(int i) {
return i*i;
}
void worker(long tid) {
int i, low, high, psum;
low = (100/10) * tid;
high = low + (100/10);
psum = 0;
printf("Thread id: %ld. Thread range: LOW %d HIGH %d\\n",tid, low, h... | 0 |
#include <pthread.h>
int GetBit(long data, long bit);
void *SSSthread(void* arg);
{
long index1;
long index2;
int targetNum;
int* intset;
int length;
int* numofsolutions;
pthread_mutex_t *mutex;
}Subset;
int subsetSum(int * intset, int length, int N, int numThread)
{
int last... | 1 |
#include <pthread.h>
bool
fstrm__get_best_monotonic_clock_pthread(clockid_t *c)
{
bool res = 0;
int rc;
struct timespec ts;
pthread_condattr_t ca;
rc = pthread_condattr_init(&ca);
assert(rc == 0);
out:
rc = pthread_condattr_destroy(&ca);
assert(rc == 0);
return res;
}
bool
fstrm__get_be... | 0 |
#include <pthread.h>
extern struct DEV_reg *DEVreg;
extern int IRQ;
extern int tc_count;
extern int intid;
extern int configured;
extern int locked;
extern struct sigevent interruptevent;
extern struct GPSStatus displaystat;
extern struct timespec timecompare,event;
extern int RateSynthInterrupt... | 1 |
#include <pthread.h>
double gStep = 0.0;
double gPi = 0.0;
pthread_mutex_t gLock;
void *threadFunction(void *pArg)
{
int myNum = *((int *)pArg);
double partialSum = 0.0, x;
for ( int i=myNum; i<1000000; i+=4 )
{
x = (i + 0.5f) / 1000000;
partialSum += 4.0f / (1.0f + x*... | 0 |
#include <pthread.h>
int c[10];
int use[2][2];
pthread_mutex_t use_mutex;
bool overlap(i,j,k,l) {
return (((i<=k) && (j <= l)) || ((k<=i) && (l <= j)))? 1 : 0;
}
void enter_critical(int i, int j, int tid){
bool acquired = 0;
while (!acquired){
pthread_mutex_lock(&use_mutex... | 1 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
struct foo *f_next;
};
struct foo *
foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(st... | 0 |
#include <pthread.h>
{
pthread_mutex_t lock;
pthread_cond_t cond;
}cl,*pcl;
void* thread(void *p)
{
pcl cl_t = (pcl)p;
int ret;
printf("Child:start,LOCK!\\n");
pthread_mutex_lock(&cl_t->lock);
printf("Child:I will sleep.\\n");
ret = pthread_cond_wait(&cl_t->cond,&cl_t->lock);
if(ret != 0)... | 1 |
#include <pthread.h>
struct clbuf {
pthread_mutex_t lock;
unsigned allocated_size;
unsigned read_index;
unsigned write_index;
void **buffer;
};
struct clbuf *clbuf_create(unsigned size)
{
struct clbuf *cb = (struct clbuf *) xmalloc(sizeof(st... | 0 |
#include <pthread.h>
int beers = 2000000;
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void * drink_lots(void *a){
int i;
pthread_mutex_lock(&beers_lock);
for (i = 0; i < 100000; i++){
beers = beers - 1;
}
pthread_mutex_unlock(&beers_lock);
printf("beers = %i\\n", bee... | 1 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread1() ;
void *thread2() ;
void *thread3() ;
void *thread4() ;
void *thread5() ;
void error_message(int error);
void critical_section(int thread);
void main()
{
pthread_t thread_id[5];
int i=0;
... | 0 |
#include <pthread.h>
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=0;
q->amount=0;
}
int empty(QType * q)
{
... | 1 |
#include <pthread.h>
const int DEF_THREAD_COUNT = 4;
const int DEF_FIB_MAX = 40;
{
int n;
int result;
pthread_mutex_t *access_input;
pthread_mutex_t *access_output;
pthread_cond_t *cond_output;
pthread_cond_t *cond_input;
int work;
} fib_params_t;
int fib(int n)
{
if (n <= 0)
return ... | 0 |
#include <pthread.h>
char buffer[9][18];
int done = 0;
char* infile_name;
char* outfile_name;
FILE *infile, *outfile;
pthread_cond_t empty_slot=PTHREAD_COND_INITIALIZER;
pthread_cond_t avail_item=PTHREAD_COND_INITIALIZER;
pthread_mutex_t buf_lock=PTHREAD_MUTEX_INITIALIZER;
void *producer()... | 1 |
#include <pthread.h>
pthread_mutex_t mut1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut2=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut3=PTHREAD_MUTEX_INITIALIZER;
void sigint_handler(int s)
{
pthread_mutex_destroy(&mut1);
pthread_mutex_destroy(&mut2);
pthread_mutex_destroy(&mut3);
exit(0);
... | 0 |
#include <pthread.h>
extern int makethread(void *(*fn)(void *), void *);
struct to_info {
void (*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)(t... | 1 |
#include <pthread.h>
{
char name[20];
char file[1024];
}MSG;
MSG msg;
pthread_mutex_t mutx;
void * control_clnt(void *arg);
void send_msg(MSG msg,int len);
int sum_clnt=0;
int clnt_socks[1000];
int main(int argc,char *argv[])
{
int serv_sock,clnt_sock=0;
struct sockaddr_in se... | 0 |
#include <pthread.h>
pthread_t phil[3];
pthread_mutex_t baguette[3];
void mange(int id) {
printf("Philosophe [%d] mange\\n",id);
for(int i=0;i< rand(); i++) {
}
}
void* philosophe ( void* arg )
{
int *id=(int *) arg;
int left = *id;
int right = (left + 1) % 3;
while(1) {
pri... | 1 |
#include <pthread.h>
int first_pack = 0;
struct timeval dateInicio, dateFin;
pthread_mutex_t lock;
int mostrarInfo = 0;
int MAX_PACKS = 1;
int NTHREADS = 1;
double segundos;
llamadaHilo(int dev_fd){
char buf[10];
int lectura;
int paquetesParaAtender = MAX_PACKS/NTHREADS;
int i;
for(i =... | 0 |
#include <pthread.h>
pthread_t tidArr[4];
pthread_cond_t condArr[4];
int flag = 1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * threadFunc1(void * arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
while( 1 != flag)
{
pthread_cond_wait(condArr,&mutex);
}
fprintf(stdo... | 1 |
#include <pthread.h>
int IsPrime = 1;
int Golba_N = 0;
int Global_P = 0;
int SubSetLen = 0;
int RemainedThread = 0;
pthread_mutex_t mutexsum;
void *CheckPrime(void *threadid)
{
int taskId, i=0;
taskId = (int)threadid;
int startIndex = (SubSetLen * taskId);
if(taskId == 0) i=2;
for(;... | 0 |
#include <pthread.h>
pthread_mutex_t entry_mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_func(void *data) {
struct parking_details *pdata = (struct parking_details *)data;
pthread_mutex_lock(&entry_mutex);
printf("\\n enter the car details thread : %d",pdata->thread_instance... | 1 |
#include <pthread.h>
pthread_mutex_t exclusionMutex5;
pthread_mutex_t exclusionMutex7;
int nrOf5 = 0, nrOf7 = 0;
void* computeThread(void *arg) {
int nr = *(int *)arg;
int initialNr = nr;
int increment5 = 0, increment7 = 0;
while(nr) {
if(nr % 10 == 5)
i... | 0 |
#include <pthread.h>
static int nmea_checksum(char *line)
{
uint8_t checksum = 0;
while (*line){
if (*line == '$'){
line++;
continue;
}
if (*line == '*')
break;
checksum ^= *line++;
}
return (strtoul(line+1, 0, 16) == checksum);
}
void *readSerial()
{
int STOP=FALSE;
int fd,... | 1 |
#include <pthread.h>
int timer_init(struct util_timer_list *list)
{
list->head = 0;
list->tail = 0;
pthread_mutex_init(&(list->mutex), 0);
return MQTT_ERR_SUCCESS;
}
int add_timer(struct util_timer_list *list, struct util_timer *timer)
{
int ret;
LOG_PRINT("Add the timer... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t db;
pthread_mutex_t writerLock;
pthread_cond_t conditionRead;
pthread_cond_t conditionWrite;
int rc = 0;
int writerState = 0;
int waitLimit = 3;
void writeData(int v);
void readDB(int v);
void * writer(void * v);
void * reader(voi... | 1 |
#include <pthread.h>
void do_one_thing(int *);
void do_another_thing(int *);
void do_wrap_up(int,int);
int r1=0,r2=0,r3=0;
pthread_mutex_t r3_mutex=PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char **argv){
pthread_t thread1, thread2;
r3 = atoi(argv[1]);
pthread_create(&thread1,
0, (v... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER;
struct {
char data[1024];
int filled;
int closed;
}buff = {.filled = 0, .closed = 0};
void *consumer(voi... | 1 |
#include <pthread.h>
struct ticket {
int ticket_type;
int seat_number;
char sold_by;
bool availability;
};
struct customer {
char priority;
char name;
char thread;
};
struct seller {
int min_responseTime;
int max_responseTime;
int avg_reponseTime;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *start_routine(void *arg) {
static int g_i = 0;
pthread_mutex_lock(&mutex);
pid_t pid = getpid();
pthread_t ptid = pthread_self();
printf("process_id = %d (0x%lx), thread_id = %lu (0x%lx), [%s], [g_i=%x]\\n", pid, pid, ptid, ptid, (char*)a... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct daos_lru_cache*
vos_get_obj_cache(void)
{
return vos_tls_get()->vtl_imems_inst.vis_ocache;
}
static inline void
vos_imem_strts_destroy(struct vos_imem_strts *imem_inst)
{
if (imem_inst->vis_ocache)
vos... | 0 |
#include <pthread.h>
pthread_t sort[4096];
pthread_mutex_t mutex;
pthread_cond_t cond;
int barrier = 0;
int data[4096];
int num = 0;
int nummerge;
int left;
}NODE;
void read_data()
{
FILE *fp = fopen("indata.txt", "r");
int i = 0;
if(fp == 0)
{
printf("cannot ... | 1 |
#include <pthread.h>
int nthreads, delaylength, innerreps;
double times[20 +1] ;
volatile int global_barrier_flag;
volatile int global_barrier_count;
volatile boolean champion_sense = ((boolean) 0);
volatile boolean *opponent;
role_enum role;
volatile boolean flag;
}round_t;
ro... | 0 |
#include <pthread.h>
int thread_count;
long current_thread = 0;
pthread_mutex_t sequence_mutex;
pthread_cond_t ok_to_proceed;
void Usage(char* prog_name);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
if (argc != 2) Usage(ar... | 1 |
#include <pthread.h>
static void *hados_thread(void * parm) {
int rc;
srand48(time(0));
struct hados_context context;
hados_context_init(&context);
for (;;) {
static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&accept_mutex);
rc = FCGX_Accept... | 0 |
#include <pthread.h>
static char envbuf[4096];
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
char *getenv_unsafe(const char *name)
{
int i, len;
len = strlen(name);
for (i = 0; environ[i] != 0; i++) {
if ((str... | 1 |
#include <pthread.h>
static uint8_t rand_buf[1024 * 8];
static uint rand_buf_off = 0;
static int seeded = 0;
static pthread_mutex_t rand_buf_lock = PTHREAD_MUTEX_INITIALIZER;
int cf_rand_reload() {
if (seeded == 0) {
int rfd = open("/dev/urandom", O_RDONLY);
int rsz = (int)re... | 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;
pthread_t *threadid;
int shutdown;
int max_thread_num;
int cur_que... | 1 |
#include <pthread.h>
void * thread_incoming_reader (void * arg)
{
int socket_fd = *((int*)arg);
tslog(0, "ACCEPTOR", "Connection thread has started for fd %d.", socket_fd);
char buffer[10240];
int code, b;
while (1)
{
code = read(socket_fd, buffer, 10240);
if (code == -1)
{
tslog... | 0 |
#include <pthread.h>
int i = 0;
pthread_mutex_t mtx;
void* Thread1(){
pthread_mutex_lock(&mtx);
for (int x = 0; x < 1000000; ++x)
{
i = i+1;
}
printf("i fra trad_1: %d\\n", i );
pthread_mutex_unlock(&mtx);
return 0;
}
void* Thread2(){
pthread_mutex_lock(&mtx);
... | 1 |
#include <pthread.h>
pthread_mutex_t joblock;
int64_t jobs_available = 1000000;
void do_job(uint64_t job_id) {
for (int i = 0; i < 5; i++) {
asm("nop");
}
}
void *do_jobs(void *thread_id)
{
int64_t current_job = 0;
while (1) {
pthread_mutex_lock(&joblock);
current_job = jobs_... | 0 |
#include <pthread.h>
void *runner(void *param);
int **A, **B, **C;
size_t m1, n1, m2, n2;
void initMatrix(int ***a, int m, int n);
void getMatrix(int ***a, int m, int n);
pthread_mutex_t lock;
pthread_mutex_t threadLock;
int THREADS = 4;
int main(int argc, char const* argv[])
{
printf("Enter... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_global;
sem_t sem_fichier;
int nb_lecteurs;
}lecteur_redacteur_t;
lecteur_redacteur_t lecteur_redacteur;
int iterations;
int donnee;
} donnees_thread_t;
void debut_redaction(lecteur_redacteur_t *lect_red){
printf("Arrivée du thr... | 0 |
#include <pthread.h>
struct reactor
{
pthread_t th;
pthread_mutex_t mutex;
int fd;
int state;
};
static struct reactor g_reactor = {
.mutex = PTHREAD_MUTEX_INITIALIZER,
.fd = -1,
.state = 0
};
void *reactor_thread(void *arg)
{
struct reactor *self = (struct reactor *) arg;
st... | 1 |
#include <pthread.h>
struct wd_list wd_tempbans;
int wd_check_ban(char *ip) {
struct wd_list_node *node;
struct wd_tempban *tempban;
int result = 1;
pthread_mutex_lock(&(wd_tempbans.mutex));
for(node = wd_tempbans.first; node != 0; node = node->next) {
tempban = node->data;
if(strc... | 0 |
#include <pthread.h>
int64_t size;
struct nu_free_cell* next;
} nu_free_cell;
static const int64_t CHUNK_SIZE = 65536;
static const int64_t CELL_SIZE = (int64_t)sizeof(nu_free_cell);
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static nu_free_cell* nu_bins[8];
void*
opt_r... | 1 |
#include <pthread.h>
int x = 0;
int y = 0;
int z = 0;
int v = 0;
int c = 0;
pthread_mutex_t mc;
pthread_mutex_t mx;
pthread_mutex_t my;
pthread_mutex_t mz;
pthread_mutex_t mut[12];
int tab[12];
int main1();
int main2();
void *thread1 (void *arg)
{
unsigned id = (unsigned long) arg;
pthrea... | 0 |
#include <pthread.h>
int available_wait_seats = 6;
sem_t barberSem;
sem_t customerSem;
pthread_mutex_t wait_seats;
void *get_hair_cut(void* arg){
int id = *((int *)arg);
while(1){
pthread_mutex_lock(&wait_seats);
if(available_wait_seats > 0){
usleep(500000);
... | 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, len;
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.