text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int id;
int numPhilo;
int numEat;
}Arguments;
void *philosopher (void *id);
pthread_mutex_t chopstick[1000];
pthread_t philo[1000];
int main (int argn,char **argv)
{
int i=0,timesEatting=0,numPhilo=0;
Arguments* args;
if (argn < 3||argn > 3){... | 1 |
#include <pthread.h>
pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t id_mutex = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int getId() {
static int id = 0;
pthread_mutex_lock(&id_mutex);
id++;
pthread... | 0 |
#include <pthread.h>
void *threadfunc(void *arg);
pthread_barrier_t barrier;
pthread_mutex_t mutex;
int serial_count;
int after_barrier_count;
int
main(int argc, char *argv[])
{
int i, ret;
pthread_t new[10];
void *joinval;
pthread_mutex_init(&mutex, 0);
ret = pthread_barrier_init(&ba... | 1 |
#include <pthread.h>
pthread_mutex_t chopsticks_mutex;
unsigned int state = 0;
int eat(int id){
int f[2], ration, i;
f[0] = f[1] = id;
f[id & 1] = (id + 1) % 5;
for (i = 0; i < 2; i++) {
pthread_mutex_lock(&chopsticks_mutex + f[i]);
}
int timer = abs(randomGaussian_r(9, 3, ... | 0 |
#include <pthread.h>
static int sigsegv_caught;
static pthread_t tid1;
static pthread_t tid2;
static sigjmp_buf env;
static void* glb_si_ptr;
static void* glb_si_addr;
static void* glb_si_call_addr;
pthread_mutex_t mutex;
static const int addresses_size = 64;
static void* worker_thread( void*... | 1 |
#include <pthread.h>
{
int count;
pthread_mutex_t m;
pthread_cond_t cv;
} sem_t;
{
sem_t occupied;
sem_t freeSpace;
int vp;
int vc;
sem_t pmut;
sem_t cmut;
pthread_mutex_t m;
} buffer_t;
sem_post(sem_t *s)
{
pthread_mutex_lock(&s->m);
s->count+... | 0 |
#include <pthread.h>
static void *handle_msg_shoot(void *ptr);
static inline void send_msg_image_buffer(void);
static inline void send_msg_status(void);
static volatile int is_shooting, image_idx, image_count, shooting_idx, shooting_count, shooting_thread_count;
static char image_buffer[25][70];
... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int avail = 0;
static int data = 0;
static void * producer(void *arg)
{
int cnt = *((int *) arg);
int j,ret;
for (j = 0; j < cnt; j++) {
... | 0 |
#include <pthread.h>
long long int size;
char* D1;
char* D2;
int* bit1;
int* bit2;
int* bitr;
pthread_mutex_t* D1_lock;
pthread_mutex_t* D2_lock;
int STATE;
} database;
database global_db;
int is_finished = 0;
long long int throughput = 0;
long long int active0=0;
long long int acti... | 1 |
#include <pthread.h>
struct archivoVersion{
int v;
char* archivo;
};
struct archivoVersion* arch;
char* ips[6];
pthread_mutex_t versiones = PTHREAD_MUTEX_INITIALIZER;
int cantIps=0;
int cantArch=0;
int imprimirIPConectada(struct svc_req *rqstp)
{
printf("%d.%d.%d.%d",
(rqstp->rq_xprt->x... | 0 |
#include <pthread.h>
struct glob{
int a;
int b;
}obj;
pthread_mutex_t r_mutex;
int a_bakup,b_bakup;
void recover(void){
pthread_mutex_consistent_np(&r_mutex);
obj.a = a_bakup;
obj.b = b_bakup;
pthread_mutex_unlock(&r_mutex);
}
void *threadFunc1(void *arg){
printf("thread1 has crea... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void * another(void* arg){
printf("in child thread,lock the mutex\\n");
pthread_mutex_lock(&mutex);
sleep(5);
pthread_mutex_unlock(&mutex);
}
int main(){
pthread_mutex_init(&mutex,0);
pthread_t tid;
pthread_create(&tid,0,another,0);
sleep(1);... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
char msg[100];
}user_data_t;
pthread_mutex_t mutex;
int ref_cnt;
user_data_t* data;
}comm_t;
void comm_get(comm_t * p)
{
pthread_mutex_lock(&p->mutex);
if(p->ref_cnt == 0){
p->data=malloc(sizeof(user_data_t));
pthread_mutex_init(&p->data->... | 1 |
#include <pthread.h>
int counter = 4;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *inc_counter(void *arg)
{
(void) arg;
pthread_mutex_lock(&mutex);
counter++;
fprintf(stderr, "Thread %ld : Counter value: %d\\n", pthread_self(), counter);
pthread_mutex_unlock(&mute... | 0 |
#include <pthread.h>
void init_consensus()
{
int i;
pthread_mutex_init(&mutex_consensus, 0);
consensus_state_others=(float**)malloc(sizeof(float*)*(CONSENSUS_AGENTS));
for (i=0;i<CONSENSUS_AGENTS;i++)
consensus_state_others[i]=(float*)malloc(sizeof(float)*3);
consensus_v... | 1 |
#include <pthread.h>
int pocz ,kon,licznik = 0;
char bufor[4][255];
pthread_mutex_t mutex;
pthread_cond_t puste, pelne;
int pk, kk;
void* producent( void* arg ) {
int num = 0;
int cnt = 1;
int prod = 1;
char str[255];
num = (int) arg;
printf("Start producent: %d\\n",num);
while( p... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void* thread_worker(void*);
void critical_section(int thread_num, int i);
int main(void)
{
int rtn, i;
pthread_t pthread_id = 0;
rtn = pthread_create(&pthread... | 1 |
#include <pthread.h>
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count = 0;
void * decrement_count(void *arg){
pthread_mutex_lock(&count_lock);
printf("decrement_count get count_lock ^-^-%d-^-^\\n", count);
while (count == 0){
printf("decrement_count co... | 0 |
#include <pthread.h>
int map_minerals = 5000;
int owned_minerals = 0;
int collected_minerals_overall = 0;
int soldiers = 0;
int workers_count = 0;
pthread_t command_centers[200];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* command_center_activity(void* arg)
{
pthread_mutex_lock(&mu... | 1 |
#include <pthread.h>
{
pthread_t thread;
char* name;
int id;
sem_t* glob_dance_sem;
sem_t* glob_eat_sem;
int isDancing;
int isEating;
} customer_t;
customer_t customers[12];
int dancing_status;
int eating_status;
int isCurfew;
pthread_mutex_t dance_mutex = PTHREAD_MUTEX_INITIALIZ... | 0 |
#include <pthread.h>
static int global = 0;
static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t v = PTHREAD_COND_INITIALIZER;
void perror_exit(const char *info)
{
perror(info);
exit(1);
}
void *count_times(void *args)
{
int i = 1;
while(1){
... | 1 |
#include <pthread.h>
enum {ARRAY_SIZE = 1000,};
const unsigned long int LOOP_ITERATIONS = (1 << 25);
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_barrier_t b;
int global_array[ARRAY_SIZE];
void *reader(void *arg)
{
int tmp = *(int *)&m;
pthread_barrier_wait(&b);
wh... | 0 |
#include <pthread.h>
pthread_mutex_t xLock, yLock;
int x, y;
void * procA () {
int flag = 9, step;
while (flag--) {
printf ("A: Incrementing x\\n");
pthread_mutex_lock (&xLock);
for (step = 1000000; step > 0; step--) x++;
pthread_mutex_unlock (&xLock);
pthread_mutex_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
double target;
void* opponent(void *arg)
{
for(int i = 0; i < 10000; ++i)
{
pthread_mutex_lock(&mutex);
target -= target * 2 + tan(target);
pthread_mutex_unlock(&mutex);
}
return 0;
}
int main(int argc, cha... | 0 |
#include <pthread.h>
{
struct node *next;
} node;
{
node *head;
node *tail;
pthread_mutex_t headLock;
pthread_mutex_t tailLock;
} queue;
void Queue_Init(struct queue *q);
void Queue_Enqueue(struct queue *q);
int Queue_Dequeue( struct queue *q);
void* Thread_Enqueue(void *q);
void* Thread_D... | 1 |
#include <pthread.h>
static const char *sem_prefix = "/AnonSem";
static int is_mutex_inited = 0;
static pthread_mutex_t sem_ptr_mutex;
static int sem_id = 0;
static sem_t *sem_list[16];
int sem_init(sem_t *sem, int pshared, unsigned int value) {
assert(sem != 0);
pid_t pid;
int id;
char... | 0 |
#include <pthread.h>
static const int max_fd=40;
const int pthread_num=30;
const int port=8888;
const char *ip="127.0.0.1";
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
int server_fd[max_fd],iget=0,iput=0,work_count_end=1,work_count_begin=1,free_coun... | 1 |
#include <pthread.h>
int running = 1;
int thread1_waiting = 0;
pthread_t thread1;
pthread_cond_t thread1_cond;
int thread2_waiting = 0;
pthread_t thread2;
pthread_cond_t thread2_cond;
void*
thread1_func(void *arg){
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
while(running){
usl... | 0 |
#include <pthread.h>
pthread_mutex_t mutex ;
pthread_cond_t avail;
pthread_cond_t ready;
int data_ready;
int data;
pthread_t thread;
struct stage_tag * next;
} stage_t;
pthread_mutex_t mutex;
stage_t *head;
stage_t *tail;
int stages;
int active;
} pipe_t ;
int
pipe_send(stage_t ... | 1 |
#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_exi... | 0 |
#include <pthread.h>
int joystickServer( )
{
int joy_fd = open( "/dev/input/js0", O_RDONLY );
if ( joy_fd == -1 ) return 1;
int num_of_axis, num_of_buttons;
ioctl( joy_fd, JSIOCGAXES, &num_of_axis );
ioctl( joy_fd, JSIOCGBUTTONS, &num_of_buttons );
int * axis = ( int * ) calloc( num_of_... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail... | 0 |
#include <pthread.h>
void *passenger(void* arg);
pthread_mutex_t mutex;
pthread_cond_t cond;
int np, n, C, T, N, headOfArray, count;
long long ln;
int *array;
int *line;
struct timeval *back_to_queue;
int main(int argc, char** argv){
if(argc<5){
puts("execution error, ./hw2_SRCC n C T N");
e... | 1 |
#include <pthread.h>
sem_t c_sem;
int count;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *producer_thread() {
while(1) {
printf("\\nIN PRODUCER THREAD:[%u]\\n", pthread_self());
if(0 != pthread_mutex_lock( &mutex1)... | 0 |
#include <pthread.h>
void philosopher_fn(void*);
pthread_mutex_t mutex_arr[5];
int main()
{
int i=0;
pthread_t threads[5];
for(i=0;i<5;i++){
pthread_mutex_init(&mutex_arr[i],0);
}
i = 0;
while(i<5){
if(pthread_create(&threads[i],0,philosopher_fn,(... | 1 |
#include <pthread.h>
pthread_mutex_t speaking;
pthread_mutex_t asking;
pthread_mutex_t room;
pthread_cond_t question;
pthread_cond_t answer;
pthread_barrier_t barrier;
int reporters_in_room;
int done = 0;
int ready = 0;
int numReporters;
int roomCapacity;
int active_id;
void *Speaker(){
pthread_... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_mutex_t trans;
int money = 1000;
int transactions = 0;
void* deposit(void* arg){
int taskid;
taskid = (int) arg;
pthread_mutex_lock(&m);
money -= 100;
printf("100 withdrawn from %d banker\\n", taskid);
pthread_mutex_unlock(&m);
pthread_mut... | 1 |
#include <pthread.h>
{
int nb_ingredient1;
int nb_ingredient2;
int nb_ingredient3;
int nb_ingredient4;
pthread_t thread_epicier;
pthread_t thread_cuisinieres [6];
pthread_mutex_t mutex_epicier;
pthread_cond_t condition_epicier;
pthread_cond_t condition_cuisinie... | 0 |
#include <pthread.h>
void *print(void *m);
struct data {
pthread_mutex_t lock1;
};
int main ()
{
int rt;
pthread_t tid;
pthread_attr_t attr;
struct data d;
struct data *dPtr = &d;
rt = pthread_mutex_init(&(d.lock1), 0);
rt = pthread_mutex_lock(&(d.lock1));
rt = p... | 1 |
#include <pthread.h>
struct quick_exit_handler {
struct quick_exit_handler *next;
void (*cleanup)(void);
};
static struct quick_exit_handler *pool_page;
static struct quick_exit_handler *pool;
static size_t pool_size;
static pthread_mutex_t atexit_mutex = PTHREAD_MUTEX_INITIALIZER;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cc, cp;
int n = 0, queue[8], head = 0, tail = 0;
volatile int to_consume = 10;;
volatile int to_produce = 10;;
void * producer(void *ptr) {
pthread_mutex_lock(&mutex);
while(to_produce) {
if(n == 8) pthread_cond_wait(&cp, &mutex)... | 1 |
#include <pthread.h>
int get_request(struct jtag_debug_data *d, struct dbg_request *req)
{
ssize_t br;
int rc = -EAGAIN;
pthread_mutex_lock(&d->lock);
if (d->client_fd < 0)
goto out;
if (!d->more_data)
goto out;
br = read(d->client_fd, req, sizeof(*req));
if (br < 0 && errno == E... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
void *func(void *arg)
{
while (1)
{
pthread_mutex_lock(&mutex);
int i;
for (i = 1; i <= 5; i++)
{
printf("Thread 1 - %d\\n", i);
}
sleep(1);
pt... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
int students_finished;
void *student(void *args) {
int index = (int) args;
int seed = (index + 1) * 3 * 4 * 2 * 2;
int help_count = 0;
while (help_count < 2) {
int ra... | 0 |
#include <pthread.h>
int count = 0;
int in = 0;
int out = 0;
int buffer [20];
pthread_mutex_t mutex;
pthread_t tid;
pthread_cond_t full;
pthread_cond_t empty;
void insert(int item){
pthread_mutex_lock(&mutex);
while (count == 20){
pthread_cond_wait(&full, &mutex);
}
buffer[in]... | 1 |
#include <pthread.h>
pthread_barrier_t br;
pthread_cond_t cv;
pthread_mutex_t lock;
bool n, exiting;
FILE *f;
int count;
void *
tf (void *dummy)
{
bool loop = 1;
pthread_setschedparam_np(0, SCHED_FIFO, 0, 0xF, PTHREAD_HARD_REAL_TIME);
pthread_barrier_wait(&br);
while (loop)
{
... | 0 |
#include <pthread.h>
int thread_count;
int n;
int total = 0;
pthread_mutex_t mutex;
void Usage(char prog_name[]);
void* Lock_and_unlock(void* rank);
int main(int argc, char* argv[]) {
pthread_t* thread_handles;
long thread;
double start, finish;
if (argc != 3) Usage(argv[0]);
thr... | 1 |
#include <pthread.h>
enum
{
STATE_R=1,
STATE_W,
STATE_Ex,
STATE_T
};
struct rel_fsm_st
{
int state;
int sfd;
int dfd;
char buf[1024];
int len;
int pos;
int64_t count;
char *errstr;
};
struct rel_job_st
{
int job_state;
int fd1,fd2;
struct rel_fsm_st fsm12,fsm21;
int fd1_save,... | 0 |
#include <pthread.h>
const char *names[5] = { "Aleksander", "Marius", "Ingvald", "Gustav", "Martin" };
pthread_mutex_t forks[5];
const char *topic[5] = { "Spaghetti!", "Life", "Universe", "Everything", "Bathroom" };
void print(int y, int x, const char *fmt, ...)
{
static pthread_mutex_t s... | 1 |
#include <pthread.h>
struct thread_data {
int t_index;
};
int global_count = 0;
pthread_t thread_id[5];
pthread_mutex_t mutex1;
void *thread_start(void *param)
{
struct thread_data *t_param = (struct thread_data *) param;
int tid = (*t_param).t_index;
pthread_mutex_lock(&mutex... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t thr1, thr2, thr3;
pthread_attr_t attr1, attr2, attr3;
void * fonction_2(void * unused)
{
int i, j;
fprintf(stderr, " T2 demarre\\n");
fprintf(stderr, " T2 travaille...\\n");
for (i = 0; i < 100000; i ++)
for (j = 0; j < 10000; j ++... | 1 |
#include <pthread.h>
pthread_mutex_t forks[5];
void eat(void *temp){
int *me;
me = temp;
printf("Philo %i initializing\\n\\r", *me);
int left_fork = *me;
int right_fork = *me+1;
if(*me == 4) {
right_fork = 0;
}
printf("Philo %i have left fork: %i, right fork: %i \\n\\r", *me, left_fork,... | 0 |
#include <pthread.h>
pthread_mutex_t thread_sum ;
static size_t limit = 4;
size_t n_thread = 1;
static double sec(void)
{
struct timeval t;
gettimeofday(&t,0);
return t.tv_sec + (t.tv_usec/1000000.0);
}
int cmp_double(double a, double b){
int result = a < b ? -1 : a == b ? 0 : 1;
retur... | 1 |
#include <pthread.h>
struct mt {
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(void)
{
int i;
struct mt *mm;
pid_t pid;
mm = mmap(0, sizeof(*mm), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
memset(mm, 0, sizeof(*mm));
... | 0 |
#include <pthread.h>
int sum;
char *dir;
void *threadcp(void *args)
{
char buf[16384];
char pathFile[260];
char *fd;
int num_read;
int fileIn,fileOut;
fd= args;
sprintf(pathFile,"%s/copy",dir);
strcat(pathFile,fd);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIAL... | 1 |
#include <pthread.h>
extern struct user myself;
extern struct user *activeChatBuddy;
extern struct group *activeChatGroup;
void addUserConversationElement(struct user *src, struct user *dst,
char *message) {
struct user *user = (src == &myself ? dst : src);
struct conversation *conv =... | 0 |
#include <pthread.h>
int pencil = 10;
pthread_mutex_t mutex;
pthread_cond_t cond;
int flag = 0;
void *thread_producer(void *argv)
{
for (int i = 0; i < 100; i++)
{
pthread_mutex_lock(&mutex);
++pencil;
printf("thread produce a pencil %d\\n", pencil);
pthread_mutex_unlock(&mutex);
usl... | 1 |
#include <pthread.h>
static char* output_string = 0;
static pthread_mutex_t output_lock;
static int initialized = 0;
static pthread_t thread;
static void* query_desktop_thread() {
if( output_string == 0 ) {
output_string = calloc( 512, sizeof(char) );
}
FILE *bspcfp;
... | 0 |
#include <pthread.h>
unsigned short * bellman_ford(unsigned size, unsigned vertex){
int mat[MAX][MAX], v, u, d;
FILE * F;
unsigned dist[MAX];
unsigned short *parent = malloc((size + 1)*sizeof(unsigned short));
if(!(F = fopen("config/enlaces.config", "r"))) return;
for ( v = 1; v <= size; v... | 1 |
#include <pthread.h>
int buffer1[10];
int buffer2[10];
int buffer1_pointer;
int buffer1_length;
int buffer2_pointer;
int buffer2_length;
pthread_mutex_t buffer1_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t buffer2_mutex = PTHREAD_MUTEX_INITIALIZER;
void produce1() {
while (1) {
... | 0 |
#include <pthread.h>
void *Producer();
void *Consumer();
int BufferIndex=0;
char *BUFFER;
pthread_cond_t Buffer_Not_Full=PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar=PTHREAD_MUTEX_INITIALIZER;
int main()
{
pthread_t ptid,ctid;
... | 1 |
#include <pthread.h>
void *thread_fmain(void *);
void *thread_mmain(void *);
void man_leaveRR1();
void man_leaveRR2();
void man_enter();
void woman_leaveRR1();
void woman_leaveRR2();
void woman_enter();
void use_rr();
void do_other_stuff();
int get_simple_tid(pthread_t);
int maleCountRR1 = 0;
in... | 0 |
#include <pthread.h>
int buffer;
int count = 0;
pthread_cond_t cond;
pthread_mutex_t mutex;
void put(int value) {
assert(count == 0);
count = 1;
buffer = value;
}
int get() {
assert(count == 1);
count = 0;
return buffer;
}
void *producer(void *arg) {
int i;
int ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
int nbrF=0,nbrT=0,fichier_corrant=0;
char** cp;
void *conversion_func(void *agc) {
char* nomF;
int l;
while (fichier_corrant<nbrF) {
pthread_mutex_lock(&mutex);
l=strlen(cp... | 0 |
#include <pthread.h>
static void setNumPuts(struct aipc_audiopluginmixer *audiopluginmixer){
int num_inputs=0;
int num_outputs=0;
int lokke;
for(lokke=0;lokke<audiopluginmixer->num_callers;lokke++){
if(num_inputs<audiopluginmixer->callers[lokke]->num_inputs)
num_inputs=audioplug... | 1 |
#include <pthread.h>
int sum = 0;
sem_t items;
sem_t slots;
pthread_mutex_t my_lock = PTHREAD_MUTEX_INITIALIZER;
int producer_done = 0;
void *producer(void *arg1)
{
int i;
for(i = 1; i <= 100; i++) {
sem_wait(&slots);
put_item(i*i);
sem_post(&items);
}
pthread_mutex_lo... | 0 |
#include <pthread.h>
void fun_thread1(char *msg);
void fun_thread2(char *msg);
int g_value = 1;
pthread_mutex_t mutex;
int main(int argc,char *argv[])
{
pthread_t thread1;
pthread_t thread2;
if(pthread_mutex_init(&mutex,0) !=0 )
{
printf("init mutex error.\\n");
... | 1 |
#include <pthread.h>
static pthread_barrier_t s_barrier;
static pthread_mutex_t s_mutex;
static pthread_cond_t s_cond;
static int s_counter;
static void* thread_func(void* argp)
{
const int thread_num = (ptrdiff_t)(argp);
pthread_mutex_t invalid_mutex;
char thread_name[32];
snprin... | 0 |
#include <pthread.h>
double total_grade = 0;
double total_bellcurve = 0;
pthread_mutex_t mutex;
pthread_barrier_t barrier;
void *read_grades(void *param)
{
FILE *fp;
int i;
int* grades = (int*)param;
fp = fopen("grades.txt", "r");
if (fp == 0) {
printf("ERROR: Could not open file ... | 1 |
#include <pthread.h>
static int cant_hilos;
static int resto;
static pthread_mutex_t lock;
static int tarea = -1;
static int A[2500][2500], B[2500][2500], C[2500][2500];
struct indices
{ int i, j;
};
void cargarMatrices();
void realizarTarea(indice indiceGral);
void *mapearTarea(void *);
ind... | 0 |
#include <pthread.h>
struct th_arg{
char *disk;
char *bmap;
char *host;
int bsize;
};
int finish = 0;
pthread_mutex_t map_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t finish_lock = PTHREAD_MUTEX_INITIALIZER;
int transfer(int sockfd, int fd, char *map, int size, long long *total)
{
int r... | 1 |
#include <pthread.h>
int sum;
void *runner(void *param);
char buffer [65536];
int letters[128];
pthread_mutex_t lock;
struct threadData{
int start;
int end;
pthread_t tid;
int index;
};
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr,"usage: a.out <filename>\\n... | 0 |
#include <pthread.h>
int isRunning;
char* command_queue[1];
pthread_t sendhello_thread;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int calculate(int a, int b)
{
return a + b;
}
char* dequeue_Command(void)
{
char* cmd = 0;
while (isRunning)
{
pthread_mutex_lo... | 1 |
#include <pthread.h>
int thread_id;
int num_elements;
float *vector_a;
float *vector_b;
double *sum;
pthread_mutex_t *mutex_for_sum;
} ARGS_FOR_THREAD;
float compute_gold(float *, float *, int);
float compute_using_pthreads(float *, float *, int);
void *dot_product(voi... | 0 |
#include <pthread.h>
int memory_chunk_size = 10000000;
int wait_time_us = 10000;
int autotesting;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct node {
void *memory;
struct node *prev;
struct node *next;
};
struct node head, tail;
void work(void)
{
int i;
while (1) {
struct ... | 1 |
#include <pthread.h>
int cont = 1;
pthread_cond_t gate;
pthread_cond_t S;
pthread_mutex_t cont_mutex;
int a = 0;
void le_entrada(char** args, long int* N, int* threads){
*N = (long int) strtol(args[1], (char**) 0, 10);
*threads = (int) strtol(args[2], (char**) 0, 10);
}
void *Semaphoro(void ... | 0 |
#include <pthread.h>
void error(char *msg){
fprintf(stderr, "%s: %s\\n", msg, strerror(errno));
exit(1);
}
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
int beers = 200000000;
void* drink_lots(void *a){
int i;
pthread_mutex_lock(&beers_lock);
for (i = 0; i< 10000000; i++){
... | 1 |
#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 ... | 0 |
#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... | 1 |
#include <pthread.h>
int a;
pthread_mutex_t mutex_a;
pthread_cond_t cond;
int end_state;
} incrementer_data_t;
void *incrementer_work(void *args);
void *incrementer2_work(void *args);
int main(int argc, char **argv)
{
incrementer_data_t incr_in_data;
incr_in_data.a = ... | 0 |
#include <pthread.h>
extern pthread_mutex_t mutexLock[10];
extern volatile int condition_variable;
extern pthread_barrier_t activation;
extern pthread_barrier_t completion;
void timespec_diff(struct timespec* time1, struct timespec* time2,struct timespec* res)
{
long tmp;
if(time1->tv_se... | 1 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long long number_of_tosses;
long long number_in_circle;
long thread_count;
pthread_mutex_t mutex;
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
void* Compute_number_in_circle();
double randfrom(double min, double max... | 0 |
#include <pthread.h>
static int count;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *func_1(void* args)
{
while(1){
pthread_mutex_lock(&mutex);
sleep(1);
count++;
printf("this is func_1, count %d!\\n",count);
pthread_mutex_unlock(&mutex);
... | 1 |
#include <pthread.h>
int numRefeicoes = 0;
pthread_mutex_t palitos[5];
pthread_mutex_t mut_comida;
void meditar(){
sleep (1 + rand() % 2);
}
void pegarPalito(long id, long palito){
pthread_mutex_lock(&palitos[palito]);
printf("Filosofo %ld, pegou palito %ld.\\n", id, palito);
}
void solta... | 0 |
#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... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *double_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_c... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_key_t key;
void
thread_init(void)
{
pthread_key_create(&key,free);
}
char *my_getenv3( const char *name )
{
char *cp;
int namelen,envirlen,i;
extern char **environ;
pth... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int avail = 0;
static int data = 0;
static void *producer(void *arg)
{
int cnt = *((int *)arg);
int j, ret;
for (j = 0; j < cnt; j++) {
sleep(1);... | 0 |
#include <pthread.h>
static void
assert_rw(struct lock_object *lock, int what)
{
rw_assert((struct rwlock *)lock, what);
}
struct lock_class lock_class_rw = {
.lc_name = "rw",
.lc_flags = LC_SLEEPLOCK | LC_RECURSABLE | LC_UPGRADABLE,
.lc_assert = assert_rw,
};
void
rw_sysinit(void *... | 1 |
#include <pthread.h>
int buffer[102400];
int in=0;
int out=0;
pthread_mutex_t lock;
void Producer()
{
while(1)
{
int item=rand()%100;
if(in==102400 -1)
break;
else
{
pthread_mutex_lock(&lock);
... | 0 |
#include <pthread.h>
static char envbuf[ARG_MAX];
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][len] == '=')) {
strncpy(envbuf, &environ[i][... | 1 |
#include <pthread.h>
struct h2x_thread* h2x_thread_new(struct h2x_options* options, void *(*start_routine)(void *), uint32_t thread_id)
{
struct h2x_thread* thread = malloc(sizeof(struct h2x_thread));
thread->options = options;
thread->thread_id = thread_id;
thread->epoll_fd = 0... | 0 |
#include <pthread.h>
int available_resources = 5;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *partC(void*);
void *partA(void*);
int increase_count(int);
int decrease_count(int);
int main(int argc, char *argv[]){
if (argc != 2){
printf("incorrect number of arguments.");
return... | 1 |
#include <pthread.h>
FILE *compras;
{
int id_cliente;
int id_compra;
}peticion_t;
{
int pos_lectura;
int pos_escritura;
int num_peticiones;
peticion_t peticiones[5];
}buffer_peticiones_t;
buffer_peticiones_t bufferPeticiones;
buffer_peticiones_t bufferPrioridad;
pthread_mutex_t m... | 0 |
#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()
{
pthread_key_create(&key,free);
}
char* getenv(const char* name)
{
int i,len;
char* envbuf;
... | 1 |
#include <pthread.h>
pthread_mutex_t lock_x;
void StartThread(int cs, pthread_mutex_t lock)
{
pthread_t pt;
int* arg = malloc(sizeof(*arg));
if(arg == 0)
{
fprintf(stderr, "Couldn't Allocate memeory for thread argument.\\n");
exit(1);
}
else {
*arg = cs;
lock_x = lock;
}
i... | 0 |
#include <pthread.h>
pthread_mutex_t buffer_mutex, bounded_queue_mutex;
int buffer_space_error = 0;
int fill = 0, pages_downloaded = 0;
char buffer[100][50];
char *fetch(char *link) {
pthread_mutex_lock(&bounded_queue_mutex);
if(pages_downloaded == 1)
{
pthread_mutex_unlock(&bounded_que... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void test_filelock(int locktimes)
{
struct flock lock, unlock;
int count = 0;
int fd;
lock.l_type = F_WRLCK;
lock.l_start = 0;
lock.l_whence = 0;
lock.l_len = 1;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int kap_valov,n_kobyl,stav_valov;
pthread_cond_t emp_valov,fill;
void* spravca(void* param){
while(1){
pthread_mutex_lock(&mutex);
while(stav_valov>0){
pthread_cond_wait(&emp_valov,&mutex);
}
stav_valov = kap_valov;
printf("Spravca naplna... | 1 |
#include <pthread.h>
unsigned long Flag_Count;
unsigned long Flag_Range;
unsigned long Flag_Threads;
unsigned long Threads_Completed;
pthread_mutex_t Lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t Job_Done = PTHREAD_COND_INITIALIZER;
void emit_help(void);
void *worker(void *unused);
int m... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.