text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
void signal_handler(int);
clock_t program_time();
double ptime();
void add_line(const char*);
void print_lines();
char* buffer[11];
int frnt = 0, back = 0;
pthread_mutex_t buffer_lock;
struct sigaction act;
int main(void)
{
if (pthread_mutex_init(&buffer_lock, 0... | 1 |
#include <pthread.h>extern int __VERIFIER_nondet_int();
int idx=0;
int ctr1=1, ctr2=0;
int readerprogress1=0, readerprogress2=0;
pthread_mutex_t mutex;
void __VERIFIER_atomic_use1(int myidx) {
__VERIFIER_assume(myidx <= 0 && ctr1>0);
ctr1++;
}
void __VERIFIER_atomic_use2(int myidx) {
... | 0 |
#include <pthread.h>
pthread_t tid[8];
pthread_mutex_t mutex;
int *array;
float arraytime[8];
int length = 1000000000;
int count = 0;
int double_count = 0;
int t = 8;
int max_threads = 0;
void *count3s_thread(void *arg) {
int i;
clock_t t1th, t2th;
int length_per_thread = length/max_thr... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int *value;
int shmid;
void init()
{
shmid = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT|0700);
value = (int*) shmat(shmid, 0, 0);
*value = 1000;
}
void terminate()
{
pthread_mutex_destroy(&mutex);
if (shmid > 0... | 0 |
#include <pthread.h>
pthread_mutex_t mut1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut2=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut3=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void sigint_handler(int s)
{
pthread_mutex_destroy(&mut1);
pthread_mutex_destroy... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_hit_threshold;
void *inc_count( void *idp )
{
while(1){
pthread_mutex_lock( &count_lock );
count++;
printf( "inc_count: %d\\n", count );
if(cou... | 0 |
#include <pthread.h>
static pthread_mutex_t testlock;
static void *Func(void *arg)
{
pthread_mutex_lock(&testlock);
char *s = (char *)arg;
printf("%s\\n", s);
pthread_mutex_unlock(&testlock);
return (void *)strlen(s);
}
int main(int argc, char *argv[])
{
pthread_t thread;
void... | 1 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static unsigned int seed0;
static unsigned int seed1;
static int have_init = 0;
static int read_dev_random (void *buffer, size_t buffer_size)
{
int fd;
ssize_t status = 0;
char *buffer_position;
size_t yet_to_... | 0 |
#include <pthread.h>
static struct option gLongOptions[] = {
{"server", required_argument, 0, 's'},
{"port", required_argument, 0, 'p'},
{"workload-path", required_argument, 0, 'w'},
{"nthreads", required_argument, 0, 't'},
{"nrequests", required_argument, 0, 'n'},
{"help", no_argum... | 1 |
#include <pthread.h>
struct job {
int id;
struct job *next;
};
void process_job (struct job *one_job)
{
printf("Thread_%d is process job %d\\n", (int)pthread_self (), one_job->id);
}
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
int thread_flag;
pthread_cond_t thr... | 0 |
#include <pthread.h>
struct GlobalMemory {
int id;
pthread_mutex_t id_lock;
pthread_barrier_t barrier_rank;
} *global;
struct GlobalPrivate {
int *rank_ff;
} gp[(1024)];
int p;
int radix;
int max_key;
int **rank_me;
int max_num_digits;
int log2_radix;
void *slave_sort(void *arg) {
int... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_cv;
void *child (void *args)
{
int tid;
tid = (int) ((long) args);
pthread_mutex_lock (&count_mutex);
count++;
if (count == 4)
pthread_cond_signal (&count_cv);
pthread_mut... | 0 |
#include <pthread.h>
enum fstat {
FSTAT_EMPTY,
FSTAT_USED,
FSTAT_CLOSED,
FSTAT_NUM
};
struct fd_entry {
time_t access_time;
enum fstat fstat;
pthread_mutex_t lock;
};
extern int loglevel;
extern FILE *debugfp;
static inline void debug_log(const char *action, int fd)
{
if (loglevel > ... | 1 |
#include <pthread.h>
pthread_mutex_t lock_mutex = PTHREAD_MUTEX_INITIALIZER;
int agent_s, smokerPaper_s, smokerTobacco_s, smokerMatches_s;
void *chooseIngredients();
void *smokePaper();
void *smokeTobacco();
void *smokeMatches();
int count = 0;
int randNum;
main() {
pthread_t agent_t,... | 0 |
#include <pthread.h>
int *array;
int l;
int r;
int id;
} arg_t;
pthread_mutex_t lock;
int count;
} Counter;
sem_t barrier, barrier1;
Counter count;
int nthreads, swapped = 1, regionsize, n;
static int comp_integers(const void *p1, const void *p2){
int *x = (int*) p1;
int *y = (int*) p... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int numSortedArr = 0;
int arrLength = 150;
int* globArray;
void createArray(int length)
{
int *arr = (int*)malloc(sizeof(int)*length);
for(int i= 0; i < length; i++)
{
arr[i] = i;
}
permutation(arr, length);
bubbleSor... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thread_1(void *arg)
{
pthread_mutex_lock(&mutex);
DPRINTF(stdout,"Thread 1 lock the mutex\\n");
pthread_exit(0);
return 0;
}
void *thread_2(void *arg)
{
pthread_t self = pthread_self();
int policy = SCHED_FIFO;
struct sched_param param;
... | 1 |
#include <pthread.h>
pthread_mutex_t forks[3];
pthread_mutex_t fork1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fork2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fork3 = PTHREAD_MUTEX_INITIALIZER;
static void *philosopher(void *seat)
{
printf("seat: %d\\n", seat);
int f_left = seat;
int f... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
void __VERIFIER_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
char *v;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *thread1(void * arg)
{
v = malloc(sizeof(char));
return 0;
}
void *thread2(... | 1 |
#include <pthread.h>
int arr[1000][1000];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void initArray()
{
int i = 0;
int j = 0;
for (i = 0; i < 1000; i++)
{
for (j = 0; j < 1000; j++)
{
srand(time(0));
arr[i][j] = rand() % 100 + 100... | 0 |
#include <pthread.h>
void *sense(void* arg);
void *stateOutput(void* arg);
void *userInterface(void* arg);
short isRealState(char s);
char state;
short changed;
pthread_cond_t stateCond;
pthread_mutex_t stateMutex;
int main(int argc, char *argv[]) {
printf("Hello World!\\n");
state = ... | 1 |
#include <pthread.h>
struct _qsd_pool {
qsd_pool *next;
qsd_pool *prev;
};
static qsd_pool *pool_list_head = 0;
static pthread_mutex_t pool_list_lock;
qsd_pool *get_new_pool ()
{
qsd_pool *new_pool;
new_pool = (qsd_pool *) malloc(sizeof(qsd_pool));
new_pool->prev = 0;
pthread_mutex_loc... | 0 |
#include <pthread.h>
struct msg
{
struct msg *next;
int num;
};
struct msg *head = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
void *consumer(void *p)
{
struct msg *mp;
for (;;){
pthread_mutex_lock(&lock);
while (head == 0)... | 1 |
#include <pthread.h>
double start_time, end_time;
double read_timer();
void *findPalin(void*);
int main(int argc, char *argv[]);
pthread_mutex_t mutex;
int chunkSize;
int numWorkers;
int numberOfPalinFound[10];
char wordArray[(25143)][(40)];
char line[(40)];
int len;
FILE *outFile;
int m... | 0 |
#include <pthread.h>
extern int keepRunning;
extern pthread_mutex_t compute_pos_mux;
extern pthread_mutex_t track_pos_mux;
void intHandlerThread3(int sig){
keepRunning=0;
printf("CTRL+C signal in track_position\\n");
}
void print_position(void)
{
time_t rawtime;
struct tm * timeinfo;
ch... | 1 |
#include <pthread.h>
static bool wait;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void* thread_timedwait (void* arg)
{
(void)arg;
pthread_mutex_lock(&mutex);
wait = 1;
struct timespec ts;
spec_gettim... | 0 |
#include <pthread.h>
void process_reader(FILE *trace_file) {
int trace_line = 1;
char my_line[128];
float arrival_time;
time_current();
while(fgets(my_line, 128, trace_file) != 0) {
pthread_mutex_lock(&mutex_ptable);
if (p_table.first_free >= p_table.size)
realloc_table(2);
pthread_... | 1 |
#include <pthread.h>
int result[8]={0, 0, 0, 0, 0, 0, 0, 0};
pthread_mutex_t my_mutex;
int share=100;
int thread_args[8]={0, 1, 2, 3, 4, 5, 6, 7};
void *TaskCode(void *argument)
{
int tid;
tid = *((int *) argument);
result[tid] = tid;
pthread_mutex_lock( &my_mutex );
printf("Exec thread... | 0 |
#include <pthread.h>
void mylib_init_barrier(struct barrier_node *b)
{
b -> count = 0;
pthread_mutex_init(&(b -> count_lock), 0);
pthread_cond_init(&(b -> ok_to_proceed), 0);
}
void mylib_barrier(struct barrier_node *b, int num_threads)
{
pthread_mutex_lock(&(b -> count_lock));
... | 1 |
#include <pthread.h>
extern void do_work ();
int thread_flag;
pthread_cond_t thread_flag_cv;
pthread_mutex_t thread_flag_mutex;
void initialize_flag ()
{
pthread_mutex_init (&thread_flag_mutex, 0);
pthread_cond_init (&thread_flag_cv, 0);
thread_flag = 0;
}
void* thread_function... | 0 |
#include <pthread.h>
int M, N, posInicial, posfinal;
int *vetorPrefixos;
pthread_mutex_t mutex;
void *somaPrefixos(void *threadid)
{
int i;
for (i = posInicial; i < posfinal; ++i)
{
pthread_mutex_lock(&mutex);
vetorPrefixos[i] = vetorPrefixos[i - 1] + vetorPrefixos[i];
pthread_mutex_unl... | 1 |
#include <pthread.h>
struct udt_pipe_struct {
struct udt_pipe_struct *up, *down;
int sock_udt, sock_sys;
pthread_t thread_up, thread_down;
int running_count;
pthread_mutex_t running_mutex;
};
static void *thread_udtpipe (void *arg)
{
struct udt_pipe_struct *udt_pipe = *(struct udt_pipe_stru... | 0 |
#include <pthread.h>
int out_max,in_max;
int prod_number=0;
int cons_number=0;
pthread_mutex_t mu= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t sig_consumer= PTHREAD_COND_INITIALIZER;
pthread_cond_t sig_producer= PTHREAD_COND_INITIALIZER;
void cpu_eat(int count){
unsigned lon... | 1 |
#include <pthread.h>
pthread_t gl_thread;
volatile int die = 0;
int g_argc;
char **g_argv;
int window;
pthread_mutex_t gl_backbuf_mutex = PTHREAD_MUTEX_INITIALIZER;
uint8_t gl_depth_front[640*480*4];
uint8_t gl_depth_back[640*480*4];
uint8_t gl_rgb_front[640*480*4];
uint8_t gl_rgb_back[640*... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void* produtor(void *ptr) {
int i;
for (i = 1; i <= 100000000; i++) {
pthread_mutex_lock(&mutex);
while (buffer != 0) {
printf("PRODUTOR: Buffer CHEIO. Indo dormir\\n");
pthread_con... | 1 |
#include <pthread.h>
struct random_src {
pthread_mutex_t lock;
unsigned int rand_state;
};
struct random_src *random_src_alloc(struct htrace_log *lg)
{
struct random_src *rnd;
int ret;
rnd = calloc(1, sizeof(*rnd));
if (!rnd) {
htrace_log(lg, "random_src_al... | 0 |
#include <pthread.h>
struct args {
pthread_cond_t cond_var;
pthread_mutex_t cond_lock;
};
void *
lazy_thread(void *arg ) {
printf("thread!\\n");
struct args *t_args = (struct args *)arg;
pthread_mutex_lock(&(t_args->cond_lock));
pthread_cond_wait(&(t_args->cond_var), ... | 1 |
#include <pthread.h>
pthread_t tid[8];
pthread_mutex_t mutex;
int *array;
int length = 1000000000;
int count = 0;
int double_count = 0;
int t = 8;
int max_threads = 0;
void *count3s_thread(void *arg) {
int i;
int length_per_thread = length / max_threads;
int id = (int) arg;
... | 0 |
#include <pthread.h>
int _mosquitto_handle_connack(struct mosquitto *mosq)
{
uint8_t byte;
uint8_t result;
int rc;
assert(mosq);
_mosquitto_log_printf(mosq, MOSQ_LOG_DEBUG, "Client %s received CONNACK", mosq->id);
rc = _mosquitto_read_byte(&mosq->in_packet, &byte);
if(rc) return rc;
... | 1 |
#include <pthread.h>
int *nVal;
int nSize;
int *dVal;
int dSize;
float result=1;
float numer=1;
float denom=1;
void *nFunc(void *arg);
void *dFunc(void *arg);
int count;
pthread_mutex_t lock;
sem_t bar;
}Barrier;
Barrier b;
int main(int argc, char *argv[]){
if(argc != 3){
printf("Usa... | 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 *)mall... | 1 |
#include <pthread.h>
void *thread1(void *);
void *thread2(void *);
pthread_cond_t cond;
pthread_mutex_t mutex;
int i;
int main(void)
{
pthread_t t1,t2;
pthread_cond_init(&cond,0);
pthread_mutex_init(&mutex,0);
pthread_create(&t1,0,thread1,0);
pthread_create(&t2,0,th... | 0 |
#include <pthread.h>
char buffer[256],employ[100],str[100],pass[30];
struct sockaddr_in serv_addr, cli_addr;
int n,nu=1,i;
FILE *fp;
struct userinfo
{
char username[100];
int socket;
}u[1000];
pthread_t thread;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void error(char *msg)
{
... | 1 |
#include <pthread.h>
char buffer[100];
int indice;
pthread_mutex_t mutex;
sem_t sem_espacios_vacios;
sem_t sem_espacios_ocupados;
void agregar(char c);
void quitar();
void * productor()
{
while(1)
{
char c = 'a' + rand()%24;
agregar(c);
sleep(1);
}
}
void * consumidor()
{
whi... | 0 |
#include <pthread.h>
int bfr_net_listener_init()
{
return 0;
}
void bfr_net_listener_close()
{
}
void * bfr_net_listener_service(void * arg)
{
prctl(PR_SET_NAME, "bfr_net", 0, 0, 0);
struct listener_args * net_args = arg;
log_print(g_log, "bfr_net_listener_service: listening... | 1 |
#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 *tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
... | 0 |
#include <pthread.h>
const int primes[] = {
233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283,
293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359,
367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431,
433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491,
499, 503, 509, 521, 523, 5... | 1 |
#include <pthread.h>
int *m1[1025];
int *m2[1025];
int *res1[1025];
int *res2[1025];
int *res3[1025];
int *res4[1025];
pthread_mutex_t mutex;
int m1rows, m1cols, m2rows, m2cols, resrows, rescols;
long int row_matrix_mult() {
int i, j, k;
struct timeval ti, tf;
gettimeofday(&ti, 0);
... | 0 |
#include <pthread.h>
void * escritor(void *);
void * lector(void *);
int dato = 5;
int n_lectores = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutex_lectores;
main(int argc, char *argv[])
{
pthread_t th1, th2, th3, th4;
pthread_mutex_init(&mutex, 0);
pthread_create(&th1, 0, (void *) lector, ... | 1 |
#include <pthread.h>
pthread_t pthreads[8];
int aantal_tickets = 1000;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *ticket_broker(void * args){
int aantal_verkocht=0;
int brokernum = *((int *)args);
time_t rawtime;
struct tm * timeinfo;
while(1){
sleep(ran... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int count = 0;
void *func(void *argv)
{
int *a = (int *)argv;
printf(" Thread%d start!\\n", *a);
int i;
for (i = 0; i < 10; i++)
{
printf(" Thread%d running...%d\\n", *a, count);
sleep(1);
pthread_m... | 1 |
#include <pthread.h>
int *a, *b;
long sum=0;
pthread_mutex_t mymutex;
void *dotprod(void *arg)
{
int i, start, end, offset, len;
long tid = (long)arg;
long tempsum;
offset = tid;
len = 100000;
start = offset*len;
end = start + len;
tempsum = 0;
printf("thread:... | 0 |
#include <pthread.h>
int globalCounter=0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
struct params
{
int maxCount;
int threadId;
};
void *Contador(void *arg)
{
struct params *p = (struct params *)arg;
printf("Thread %i. Counting until %i\\n",(*p).threadId,(*p).maxCo... | 1 |
#include <pthread.h>
uint8_t mem[((1<<12) * (20 - (20 % 8)))];
int counter=0;
int failures=0;
pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
void do_work(size_t id){
for (int i=0;i<(20 - (20 % 8));++i){
mem[(i*(1<<12))+id]++;
}
}
int count_array(){
int count=0;
for... | 0 |
#include <pthread.h>
char documentRoot[] = "/usr/local/apache/htdocs";
void *do_web(void *);
void web_log(int, char[], char[], int);
pthread_t tid;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int log_fd;
int
main(int argc, char *argv[]) {
struct sockaddr_in s_addr, c_addr;
int s_soc... | 1 |
#include <pthread.h>
void program_counter(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);
}
pthread_mutex_... | 0 |
#include <pthread.h>
int contador;
pthread_mutex_t mutex;
void agregar(char c);
void quitar();
void * productor()
{
while(1)
{
char c = 'a' + rand()%24;
agregar(c);
usleep(1000);
}
}
void * consumidor()
{
while(1)
{
quitar();
usleep(1000);
}
}
void * imprimir()
... | 1 |
#include <pthread.h>
static int glob = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void *thread_func(void *arg)
{
int ii;
for (ii = 0; ii < 100000; ii++) {
pthread_mutex_lock(&mtx);
glob++;
pthread_mutex_unlock(&mtx);
}
return 0;
}
int m... | 0 |
#include <pthread.h>
pthread_t jsthread;
pthread_mutex_t js_lock = PTHREAD_MUTEX_INITIALIZER;
volatile struct js_state js_state = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0};
struct thread_data {
char *path;
void (*update)(struct js_event);
};
float deadzone(float in) ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t lock1, unlock1;
sem_t full, empty;
int stack[3];
int cnt;
pthread_t pid,cid;
pthread_attr_t attr;
void *producer(void *param);
void *consumer(void *param);
void initializeData()
{
pthread_mutex_init(&mutex, 0);
sem_init(&full, ... | 0 |
#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;
len... | 1 |
#include <pthread.h>
static pthread_mutex_t m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
char *ts="[??:??:??]";
struct tm * now;
time_t nw;
pthread_mutex_lock(&m_trace);
nw = time(0);
now = localt... | 0 |
#include <pthread.h>
static FILE *fz;
pthread_mutex_t fz_mutex = PTHREAD_MUTEX_INITIALIZER;
static void open_file(const char* file) {
fz = fopen(file, "w+");
if (fz == 0) {
printf("Konnte Datei %s nicht öffnen\\n", file);
exit(1);
}
}
static void thread_schreibe... | 1 |
#include <pthread.h>
struct product_cons
{
int buffer[5];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
}buffer;
void init(struct product_cons *p)
{
pthread_mutex_init(&p->lock, 0);
pthread_cond_init(&p->notempty, 0);
pth... | 0 |
#include <pthread.h>
extern char **environ;
static pthread_mutex_t env_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void init_mutex( void ) {
pthread_mutexattr_t attr;
pthread_mutexattr_init( &attr );
pthread_mutexattr_settype( ... | 1 |
#include <pthread.h>
pid_t pid;
bool has_done;
pthread_mutex_t mutex;
void kill_child(int);
void *read_output(void *);
void *read_output(void *arg) {
int fd = *((int *)arg);
free(arg);
int ret = 0;
char buffer[1024];
do {
ret = read(fd, buffer, 1024);
pthr... | 0 |
#include <pthread.h>
int ready;
sig_atomic_t sigusr1_received;
sig_atomic_t sigusr2_received;
sig_atomic_t sigabrt_received;
int thread_count;
pthread_mutex_t thread_count_mutex;
pthread_cond_t thread_count_condvar;
static void
incr_thread_count (void)
{
pthread_mutex_lock (&thread_count_mu... | 1 |
#include <pthread.h>
int inCircle = 0;
int point = 0;
int count = 0;
pthread_mutex_t mutex;
int i;
int thread[10];
void help()
{
printf("\\n-----------------------------------------------------------\\n");
printf("| usage: ./OShw3_3 [sample points number] [thread number] |\\n");
printf("| [samp... | 0 |
#include <pthread.h>
int num_threads;
pthread_mutex_t * mutexes;
none,
one,
two
} utensil;
int phil_num;
int course;
utensil forks;
}phil_data;
void * eat_meal(void * args){
phil_data * phil = (phil_data *) args;
phil->course += 1;
sleep(1);
return 0;
}
void run(phil_... | 1 |
#include <pthread.h>
sem_t customers;
sem_t barbers;
pthread_mutex_t mutex;
int waiting = 0;
void barber(void);
void customer(void);
void cut_hair(void);
int main(void)
{
pthread_t tid_b, tid_c;
int i = 0;
sem_init(&customers, 0, 0);
sem_init(&barbers, 0, 1);
pthread_create(&tid_b, 0, ba... | 0 |
#include <pthread.h>
int i = 4;
pthread_mutex_t mutex;
pthread_cond_t cond;
void* Thread1(void* arg)
{
printf("Thread1 called \\n");
pthread_mutex_lock(&mutex);
printf("Thread1 mutex taken\\n");
if (i != 10)
{
printf("Thread1 cond wait\\n");
pthread_cond_wait... | 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("Cleanup handler of second thread./n");
free(... | 0 |
#include <pthread.h>
int MyTurn = 0;
{
pthread_mutex_t *lock;
pthread_cond_t *wait;
int id;
int size;
int iterations;
char *s;
int nthreads;
} Thread_struct;
void *infloop(void *x)
{
int i, j, k;
Thread_struct *t;
t = (Thread_struct *) x;
for (i = 0; i < t->iterations; i++)
{... | 1 |
#include <pthread.h>
pthread_mutex_t count_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_nonzero = PTHREAD_COND_INITIALIZER;
unsigned count = 4;
void *decrement_count(void *arg)
{
while(1) {
pthread_mutex_lock(&count_lock);
printf("desc locked\\n");
while (cou... | 0 |
#include <pthread.h>
int mesa[4];
int sentados=0;
int platos=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t kuz = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t consume_t = PTHREAD_COND_INITIALIZER;
pthread_cond_t sits = PTHREAD_COND_INITIALIZER;
pthread_cond_t produce_t = PT... | 1 |
#include <pthread.h>
struct propset {
char *str;
int row;
int col;
int delay;
int dir;
int vert;
int prevr;
};
pthread_mutex_t myLock = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, const char *argv[])
{
void *animate(void *);
int setup(int, char **, struct ... | 0 |
#include <pthread.h>
static struct {
struct dht22 dht_street;
struct dht22 dht_room;
struct dht22 dht_veranda;
struct dht22 dht_2nd;
float street_temp;
float street_hum;
float room_temp;
float room_hum;
float second_temp;
float second_hum;
float veranda_temp;
float veranda_hum;
pth... | 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 < 10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
printf("inc_count():... | 0 |
#include <pthread.h>
time_t time;
int roomNumber;
} WakeUpCall;
int size;
WakeUpCall *alarm;
} AlarmHeap;
pthread_mutex_t lock;
pthread_cond_t cond;
AlarmHeap* heap=0;
static void AlarmGeneratorExit()
{
printf("\\ncleaning memory up");
free(heap->alarm);
printf("\\nGood... | 1 |
#include <pthread.h>
int c[10];
pthread_mutex_t mut[10];
void enter_critical(int i, int j){
pthread_mutex_lock (&mut[(i<j)?i:j]);
pthread_mutex_lock (&mut[(i<j)?j:i]);
}
void exit_critical(int i, int j){
pthread_mutex_unlock (&mut[i]);
pthread_mutex_unlock (&mut[j]);
}
void ... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("preparing locks ...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent unlocking locks ...\\... | 1 |
#include <pthread.h>
extern char **environ;
static 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 );... | 0 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void pthread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthre... | 1 |
#include <pthread.h>
struct timespec start,finish;
double elapsed;
pthread_mutex_t forks;
pthread_cond_t freed[50];
int NoPhil;
int *timed;
char *fork_state;
int display();
int pickup_fork(int phil);
int return_fork(int phil);
void *activity(int phil);
int main()
{
char choice='Y';
int err_... | 0 |
#include <pthread.h>
static struct psample_context *context;
static const char *my_addr = "127.0.0.1";
static int port = 6666;
static int srv_port;
static const char *srv_ip;
static char *fprefix;
static pthread_mutex_t neigh_lock;
static void cmdline_parse(int argc, char *argv[])
{
int o;
... | 1 |
#include <pthread.h>
sem_t sem;
int semVal;
pthread_mutex_t mut;
pthread_cond_t condC;
pthread_cond_t condA;
void utiliserPont(int type){
if (type == 1){
sem_wait(&sem);
sem_getvalue(&sem, &semVal);
}
else{
int i = 0;
for(i=0; i<3; i++){
sem_wait(&sem);
sem_getvalue(&se... | 0 |
#include <pthread.h>
static char wbuff[P4_NET_SERVER_BUFFER_SIZE_WRITE];
pthread_mutex_t wbuffmutex;
int
server_net_game_curplay(struct p4_server_game *game)
{
static int start = 1;
struct p4_net_protocol_match *proto;
char *ptr;
int rbufflen;
if (start)
{
pthread_mutex_init(&wbuffmut... | 1 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cnd = PTHREAD_COND_INITIALIZER;
int toexit = 0;
void * start_thread(void * arg) {
pthread_mutex_lock(&mtx);
while(0 == toexit) {
do{ printf("ptid [%ld] -- ", (long int)pthread_self()); printf("wait... | 0 |
#include <pthread.h>
{
int sfd;
struct wait_queue_struct *pnext;
}wait_queue,*p_wait_queue;
{
int sfd;
struct ready_queue_struct *pnext;
}ready_queue,*p_ready_queue;
p_wait_queue wait_phead;
p_wait_queue wait_ptail;
p_ready_queue ready_phead;
p_ready_queue ready_ptail;
pthread_mutex_t mute... | 1 |
#include <pthread.h>
static struct logdb_queue_node* logdb_queue_node_new(void* value);
static int logdb_queue_node_destroy(struct logdb_queue_node** p_node);
static struct logdb_queue_node* logdb_queue_node_new(void* value){
struct logdb_queue_node* new_node = (struct logdb_queue_node ... | 0 |
#include <pthread.h>
extern pthread_mutex_t httpd_mutex;
extern int created_httpd_threads;
extern int current_httpd_threads;
void
thread_httpd(void *args)
{
void **params;
httpd *webserver;
request *r;
int serialnum;
pthread_mutex_lock(&httpd_mutex);
current_httpd_threads++;
pthrea... | 1 |
#include <pthread.h>
int brashno = 1000;
int masa[4];
pthread_mutex_t lock;
void* Mama(){
int position = 0;
while(brashno) {
int mama_get_brashno = rand() % 100 + 1;
if(mama_get_brashno > brashno){
mama_get_brashno = brashno;
}
brashno -= mama_g... | 0 |
#include <pthread.h>
enum pipe_funcs {
ADD1,
MUL2,
READER,
WRITER,
FREER,
};
struct stage {
struct stage *next;
pthread_cond_t *cv;
pthread_mutex_t *mut;
char *data;
unsigned int size;
int func;
int last;
};
unsigned int do_work(char *data, unsig... | 1 |
#include <pthread.h>
struct philosopher
{
pthread_t threadHandle;
pthread_mutex_t *leftFork;
pthread_mutex_t *rightFork;
int threadResponse;
char name[15];
};
void *supper(void * args)
{
struct philosopher* philo = (struct philosopher*)args;
int response = 0;
int action = 0;
int tries;
... | 0 |
#include <pthread.h>
struct threadpool* threadpool_init(int thread_num, int queue_max_num)
{
struct threadpool *pool = 0;
do
{
pool = (struct threadpool *)malloc(sizeof(struct threadpool));
if (0 == pool)
{
printf("failed to malloc threadpool!\\n");
... | 1 |
#include <pthread.h>
static FILE *writefp;
static pthread_mutex_t mem_handle;
{
void *address;
unsigned long size;
}memInfo;
{
memInfo mem_info;
struct _memLeak *next;
}memLeak;
static memLeak *mem_start;
static memLeak *mem_end;
void add_meminfo(void *alloc, unsigned long size... | 0 |
#include <pthread.h>
struct thread_data
{
int t_index;
};
int k,n,x,thread_count=0,col_count=0,status1=0,status2=0;
int **arr;
pthread_t thread_id[5];
pthread_mutex_t cnt_mutex;
pthread_cond_t *cnt_cond;
void row_swap(int tid)
{
int i,j;
for(i = tid * (n/x) ;i<(tid+1)*(n/x);i++)
{ int tmp ... | 1 |
#include <pthread.h>
int thisCount;
int blockSize;
int offsetLow;
} read_data;
pthread_mutex_t lock;
void* countWords(void*);
int ourFile;
int main(){
read_data data_array[16];
if((ourFile = open("Assign3.txt",O_RDONLY))< -1)
return 1;
pthread_t threads[16];
... | 0 |
#include <pthread.h>
extern void do_work ();
int thread_flag;
pthread_cond_t thread_flag_cv;
pthread_mutex_t thread_flag_mutex;
void initialize_flag ()
{
pthread_mutex_init (&thread_flag_mutex, 0);
pthread_cond_init (&thread_flag_cv, 0);
thread_flag = 0;
}
void* thread_function (void... | 1 |
#include <pthread.h>
void* threadFunc(void* rank);
int driverParallel(int start, int stop);
int mergeParallel(int start, int middle, int stop);
int binSearch(int arr[], int a, int b, int x);
void printParallel(int start, int stop);
int validateParallel();
int combine(long myRank);
void ba... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.