text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
int out = 0;
char q[10];
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
while(!out){
fprintf(stdout,"Enter q to quit: ");
fscanf(stdi... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t fillmore;
pthread_cond_t macchina;
int tank = 4;
int i, j, ii = 0;
void *prepare(void *a) {
while(ii < (15/4)){
pthread_mutex_lock(&mutex);
if (tank != 0) printf("(P)I'm resting\\n");
while (tank != 0){
pthread_cond_wait(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condA;
pthread_cond_t condB;
sem_t sem1;
sem_t sem2;
int contadorA;
int contadorB;
void * imprimirA()
{
while(1)
{
pthread_mutex_lock(&mutex);
if(contadorA == 2)
pthread_cond_wait(&condA, &mutex);
printf("A\\n")... | 1 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static volatile int counter = 0;
static volatile int exiting = 0;
void *decrementer (void *arg)
{
int counterVal;
for (;;) {
pthread_mutex... | 0 |
#include <pthread.h>
const int MAX_THREADS = 5;
long tid;
char name[20];
unsigned int age;
} tls_t;
static pthread_mutex_t lock;
static pthread_key_t key_tls;
static pthread_once_t once = PTHREAD_ONCE_INIT;
static void make_key(){
pthread_key_create(&key_tls, 0);
}
static void ... | 1 |
#include <pthread.h>
int cond =0;
pthread_cond_t condthread = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int max = 0;
void* thread_func(void* arg) {
int i, nb;
int *param;
int *lvl = (int*)arg;
pthread_t *tid;
nb = (*lvl)+1;
pthread_mutex_lock(&mute... | 0 |
#include <pthread.h>
void
iOsalTimespecPlusMs (struct timespec *pTS, unsigned int millisecond)
{
struct timeval tv;
struct timespec ts;
gettimeofday (&tv, 0);
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000;
ts.tv_sec += (millisecond / 1000);
ts.tv_nsec += (millisecond % 100... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex_C;
static int A [3][2] = { {1,2}, {3,4}, {5,6} };
static int B [2][3] = { {7,8,9}, {3,7,1} };
static int C [3][3];
void *hesapla(void *mat);
struct matris
{
int i;
int j;
};
int main() {
pthread_t thread[3][3];
int ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void sleep_rand(void) {
sleep(rand() % 8 + 1);
}
void *northbound_farmer(void *param) {
int id = *((int *) param);
sleep_rand();
pthread_mutex_lock(&mutex);
sleep_rand();
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
void *southb... | 1 |
#include <pthread.h>
struct ezcfg_ezctp {
struct ezcfg *ezcfg;
int shm_id;
size_t shm_size;
void *shm_addr;
size_t cq_unit_size;
size_t cq_length;
size_t cq_free;
int cq_head;
int cq_tail;
pthread_mutex_t cq_mutex;
};
static bool fill_ezctp_info(struct ezcfg_ezctp *ezctp, const c... | 0 |
#include <pthread.h>
int main(int argc, char *argv[])
{
int i;
int num_req_threads = argc-2;
int num_res_threads = MIN_RESOLVER_THREADS;
pthread_t req_threads[num_req_threads];
pthread_t res_threads[num_res_threads];
pthread_mutex_init(&queue_mutex, 0);
pthread_mutex_init(&output_mutex, 0... | 1 |
#include <pthread.h>
const char invalid[] = {' ','\\n', '<'};
int sharedByteRead = 0;
int sharedTotalCount = 0;
int total_length;
FILE *fp;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void* GetDataBytes() {
char data[5000 + 1];
... | 0 |
#include <pthread.h>
long *id;
void *data;
} Message;
Message * message_create() {
Message *message = (Message*) malloc( sizeof(Message ) );
return message;
}
void message_destroy( Message * message ) {
if ( message != 0 ) {
free( message );
}
}
struct LinkedNode *link;
Mes... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
FILE *fp;
int numero = 0;
void * worker(void *arg)
{
int tempo = rand() % 20;
int temp;
int order = (int)arg;
pthread_t thread_id = pthread_self();
printf("Nova thread %d criada TID = %d\\n", order, (unsigned int)thread_id);
pthread_mutex... | 0 |
#include <pthread.h>
char buf[4];
int occupied;
int in,out;
pthread_mutex_t mutex;
pthread_cond_t m;
pthread_cond_t l;
} buffer_t;
buffer_t buffer;
void * thread1(void *);
void * thread2(void *);
pthread_t tid[2];
int main( int argc, char *argv[] )
{
int i;
pthread_cond_init(&... | 1 |
#include <pthread.h>
{
double *a, *b, 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 = (long)arg;
double mysum, *x, *y;
len = dotstr.veclen;
start = offset*len;
end = start+len... | 0 |
#include <pthread.h>
unsigned long seqNum;
double dt;
FILE *file_fd;
struct img_struct* img_old;
struct img_struct* img_new;
float xv_buffer[5];
float yv_buffer[5];
int buf_ind = 0;
pthread_t horizontal_velocities_thread;
pthread_mutex_t velocity_access_mutex = PTHREAD_MUTEX_INITIALIZER;
... | 1 |
#include <pthread.h>
int campo[10][10], op[10][10], countbombas[100];
pthread_mutex_t mutex_bomba[25];
pthread_t gerando[25];
int verificaBomba(int linha, int coluna, int comparado)
{
int z;
for(z=0; z<25; z++)
{
if(op[linha][coluna] == comparado)
{
return... | 0 |
#include <pthread.h>
extern void __VERIFIER_error() ;
int __VERIFIER_nondet_int(void);
void ldv_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
pthread_t t1;
pthread_mutex_t mutex;
int pdev;
void *thread1(void *arg) {
pthread_mutex_lock(&mutex);
pdev = 6;... | 1 |
#include <pthread.h>
extern char *strtok_r(char *str, const char *delim, char **saveptr);
pthread_mutex_t mutex;
char **palabras;
int num_palabras[3] = {0, 0, 0};
char *ruta;
int *numCaracteresLinea;
int bloque;
char **parrafos;
int hilos;
int numero_lineas(char *ruta, int *tam_lineas) {
i... | 0 |
#include <pthread.h>
int file_des;
int record_number;
size_t buffer = 1024;
char *word;
int thread_no;
pthread_t *threads_arr;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2= PTHREAD_MUTEX_INITIALIZER;
struct record{
int id;
char text[1020];
};
int finish =0;
lon... | 1 |
#include <pthread.h>
enum
{
OFF,
ON
};
void *WriteFunc(void *arg);
void *ReadFunc(void *arg);
void Handler(int signal_num);
sem_t sem;
pthread_cond_t cond_read;
pthread_mutex_t mutex;
size_t g_read_counter = 0;
size_t counter = 0;
int num_of_readers = 10;
volatile int g_flag = 1;
int main(in... | 0 |
#include <pthread.h>
double variancia_threads = 0;
double media_t = 0;
static pthread_mutex_t mutexLock;
struct parametros_calculo
{
int posicao;
long int *v;
};
void* calcula_variancia(void* args)
{
struct parametros_calculo* p = (struct parametros_calculo*) args;
int i = p->posicao;
whi... | 1 |
#include <pthread.h>
char** theArray;
pthread_mutex_t mutex;
void* ServerEcho(void *args);
int main(){
printf("creating mutex \\n");
pthread_mutex_init(&mutex,0);
theArray=malloc(100*sizeof(char));
for (int i=0; i<100;i++){
theArray[i]=malloc(100*sizeof(char));
... | 0 |
#include <pthread.h>
pthread_mutex_t *muts;
struct node ** list;
int SIZE;
void hash_init(int N)
{
printf("hash init\\n");
if(N <= MAXTH){
srand( time(0));
SIZE = 10;
printf("Number of buckets is %d\\n", SIZE);
list = (struct node**)malloc(SIZE * sizeof(struct node*));
muts = (pthre... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[400];
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>
struct csema
{
pthread_mutex_t m_mutex;
pthread_cond_t m_cond;
int m_count;
};
void csema_ctr(struct csema* p)
{
memset(p, 0, sizeof(*p));
pthread_mutex_init(&p->m_mutex, 0);
pthread_cond_init(&p->m_cond, 0);
}
void csema_dtr(struct csema* p)
{
pthread_cond... | 1 |
#include <pthread.h>
struct pthread_args
{
int iterations;
pthread_mutex_t mutex;
};
void * pi_thread(void *ptr)
{
double tsum = 0; struct pthread_args *args = (struct pthread_args*)ptr;
for(;;)
{
pthread_mutex_lock(&(args->mutex));
int i = args->iterations;
args->iterations += 10... | 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 = malloc(sizeof(struct foo))) != 0)
{
... | 1 |
#include <pthread.h>
int w, h;
v2df zero = { 0.0, 0.0 };
v2df four = { 4.0, 4.0 };
v2df nzero;
double inverse_w;
double inverse_h;
char *whole_data;
int y_pick;
pthread_mutex_t y_mutex = PTHREAD_MUTEX_INITIALIZER;
static void * worker(void *_args) {
char *data;
double x, y;
int ... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cl, ce;
int ecriture;
int nb_lecteurs, nb_lect_att, nb_ecri_att;
} lectred;
int nb;
struct linked_list *next;
} linked_list;
struct lectred sync;
struct linked_list *head;
} linked_list_head;
linked_list_... | 1 |
#include <pthread.h>
struct thread_args
{
int allocation_size;
int array_size;
int thread_count;
};
struct timespec timer_start()
{
struct timespec start_time;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_time);
return start_time;
}
long timer_end(struct timespec st... | 0 |
#include <pthread.h>
int my_num=500;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t win= PTHREAD_MUTEX_INITIALIZER;
int client_guessed=0;
int winner_thread=-1;
pthread_t threads[10];
int client_count=0;
int thread_count=0;
void* worker(void*param){
struct sockaddr_i... | 1 |
#include <pthread.h>
void (*function)(void*);
void* argument;
} pool_task_t;
pthread_mutex_t lock;
pthread_cond_t notify;
pthread_t *threads;
pool_task_t *queue;
int thread_count;
int task_queue_size_limit;
int head;
int tail;
} pool_t;
static void *thread_do_work(vo... | 0 |
#include <pthread.h>
int many_handles = 1;
int fd;
const char * filename;
uint64_t stride;
uint64_t offset;
uint64_t last;
uint64_t write_size;
pthread_cond_t cond;
pthread_mutex_t mutex;
struct worker * next;
} worker;
void * func(void * argp) {
worker * arg = argp... | 1 |
#include <pthread.h>
void* frame_base;
struct RINGBUFFER;
{
void *pBuffer[4];
unsigned int indexInsert;
unsigned int indexRemove;
unsigned int count;
pthread_mutex_t mutex;
sem_t semEmpty;
sem_t semFull;
void (*f_addBuffer)(struct RINGBUFFER *ringBuffer, void *buffer);
... | 0 |
#include <pthread.h>
struct rt_extrRoadStationTime *extrRoadStationTime(int *findErr)
{
struct rt_extrRoadStationTime *rt;
int num;
FILE *fp;
mxml_node_t *root;
mxml_node_t *item;
int statNo;
int tmisNo;
int routeNo;
int bifurcation_distance;
int bifurcation_speed;
int up_down_trip = -1;... | 1 |
#include <pthread.h>
int VT_mc34704_OC_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc34704_OC_cleanup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc34704_test_OC(void) {
int fd;
fd = open(MC34704_DEVICE, O_RDWR);
if (fd < 0) {
pthre... | 0 |
#include <pthread.h>
static int top=0;
static unsigned int arr[(10)];
pthread_mutex_t m;
_Bool flag=(0);
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(void)
{
return top;
}
int stack_empty(void)
{
(top==0) ? (1) : (0);
}
int push(unsigned int *stack, int x)
{
... | 1 |
#include <pthread.h>
double _glfwPlatformGetTime( void )
{
struct timeval tv;
gettimeofday( &tv, 0 );
return tv.tv_sec + (double) tv.tv_usec / 1000000.0 - _glfwTimer.t0;
}
void _glfwPlatformSetTime( double time )
{
struct timeval tv;
gettimeofday( &tv, 0 );
_glfwTimer.t0... | 0 |
#include <pthread.h>
struct _qsd_pool {
qsd_pool *next;
qsd_pool *prev;
void *data;
void *cur;
size_t data_sz;
pthread_mutex_t pool_lock;
};
static qsd_pool *pool_list_head = 0;
static qsd_pool *pool_list_tail = 0;
static pthread_mutex_t pool_list_lock = PTHR... | 1 |
#include <pthread.h>
int global_PULSE = 1000;
int PIN = 7;
pthread_mutex_t lock;
void setup()
{
wiringPiSetup ();
int PULSE = 1000;
pinMode (PIN,OUTPUT);
int arming_time;
digitalWrite(PIN,HIGH);
for (arming_time = 0; arming_time < 200; arming_time++)
{
digitalWrite(PIN,HIGH);
delayM... | 0 |
#include <pthread.h>
extern int dev_buzzer_fd;
extern char dev_buzzer_mask;
extern pthread_mutex_t mutex_buzzer;
extern pthread_cond_t cond_buzzer;
void *pthread_buzzer (void *arg)
{
struct input_event event;
if ((dev_buzzer_fd = open (DEV_BUZZER, O_RDWR | O_NONBLOCK)) < 0)
{
printf ("Cann... | 1 |
#include <pthread.h>
int *arr;
int tid;
int size;
int nthreads;
double *time;
} params;
int pairmax(int *arr, int startIndex, int endIndex);
void *threadParallelSum( void *ptr );
double maximum(double a, double b);
long upper_power_of_two(long v);
static int globa... | 0 |
#include <pthread.h>
unsigned int nthreads = 30;
int load_grid(int grid[][9], char *filename);
int grid[9][9];
int erros = 0;
int nextTask = 0;
pthread_mutex_t mutexErr, mutexTask;
void checkCol(int col) {
for (int i = 0; i < 9; i++) {
for (int j = i + 1; j < 9; j++) {
if (grid[i][co... | 1 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0, 1, 2};
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) ... | 0 |
#include <pthread.h>
pthread_mutex_t M;
int DATA = 0;
int accessi1 = 0;
int accessi2 = 0;
void *thread1_process (void * arg) {
int k = 1;
while (k) {
pthread_mutex_lock(&M);
accessi1++;
DATA++;
k = (DATA >= 10 ? 0 : 1);
printf("accessi di T1: %d\\n", accessi1);
pthread_mutex_unlo... | 1 |
#include <pthread.h>
long thread_count;
long long n;
double sum;
pthread_mutex_t mutex;
void GET_TIME(double now) {
struct timeval t;
gettimeofday(&t, 0);
now = t.tv_sec + t.tv_usec/1000000.0;
}
void* Thread_sum(void* rank) {
long my_rank = (long) rank;
double factor;
long... | 0 |
#include <pthread.h>
void error(const char * msg){
fprintf(stderr, "%s: %s\\n", strerror(errno));
exit(1);
}
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
int beers = 2000000;
void* drink_lots(void* a){
int i;
pthread_mutex_lock(&beers_lock);
for(i = 0; i < 100000; i++){
bee... | 1 |
#include <pthread.h>
int count;
struct foo *m_fp;
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *
foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(siz... | 0 |
#include <pthread.h>
struct hdr_mutex* hdr_mutex_alloc(void)
{
return malloc(sizeof(hdr_mutex));
}
void hdr_mutex_free(struct hdr_mutex* mutex)
{
free(mutex);
}
int hdr_mutex_init(struct hdr_mutex* mutex)
{
return pthread_mutex_init(&mutex->_mutex, 0);
}
void hdr_mutex_destroy... | 1 |
#include <pthread.h>
static int global_time = 100;
pthread_mutex_t lock;
struct _pulse pulse;
} my_message_t;
void *time_update( void *ptr );
void *teller_1( void *ptr );
void *teller_2( void *ptr );
void *teller_3( void *ptr );
struct Customer
{
int time_in;
int time... | 0 |
#include <pthread.h>
extern pthread_mutex_t mutex_refresh;
extern pthread_mutex_t mutex_refresh_updata;
extern pthread_mutex_t mutex_global;
extern pthread_mutex_t mutex_slinklist;
extern pthread_cond_t cond_refresh;
extern pthread_cond_t cond_refresh_updata;
extern pthread_cond_t cond_sqlite;
... | 1 |
#include <pthread.h>
pthread_mutex_t lockclassroom;
pthread_cond_t cv_students;
pthread_mutex_t lockquestion;
void* answerqestion(void);
void Student(int id,pthread_t studentId[]);
void* EnterOffice(int id);
void QuestionStart(int id);
void QuestionDone(int id);
void LeaveOffice(int id);
vo... | 0 |
#include <pthread.h>
int N = 0;
int P = 0;
int C = 0;
int X = 0;
int Ptime = 0;
int Ctime = 0;
int *buffer;
pthread_mutex_t queue_lock;
sem_t queue_empty, queue_full;
void enqueue(int value)
{
int i = 0;
for(i=0; i<N; i++)
{
if(buffer[i]==0){
buffer[i]=value;
break;
}
}
fprintf(st... | 1 |
#include <pthread.h>
int id;
int claseCliente;
} Cliente;
sem_t cajGeneral;
sem_t cajEmpresarial;
pthread_mutex_t mutex;
int contGeneral=0;
int contEmpresarial=0;
void * procesoGeneral(void*);
void * procesoEmpresarial(void*);
int main(int argc, const char * argv[]) {
srand (time(... | 0 |
#include <pthread.h>
int My_pthread_create(pthread_t *tidp, const pthread_attr_t *attr, void *(*start_rtn)(void *), void *arg)
{
int result=pthread_create(tidp,attr,start_rtn,arg);
if(0!=result)
{
printf("thread(0x%x) call pthread_create failed,because %s\\n",
pt... | 1 |
#include <pthread.h>
long long unsigned int in = 0;
unsigned int n_threads, nval, *id;
pthread_t *monte_carlo_threads;
pthread_mutex_t monte_carlo_mutex;
void *monte_carlo_pi_thread(void *rank) {
unsigned int my_rank = *((unsigned int*) rank);
int local_size = nval / n_threads,
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
char *services[25] = {"AddTwoNumbers","SubtractTwoNumbers","MultiplyTwoNumbers","DivideTwoNumbers",
"Square","SquareRoot","Area","Volume","Perimeter","Circumference","Surf... | 1 |
#include <pthread.h>
static const char alphabet[] =
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789";
static const int alphabet_size = sizeof(alphabet) - 1;
static const int max_chars = 20;
int current_number_chars = 0;
bool success_decrypt = 0;
char* md5_to_decryp... | 0 |
#include <pthread.h>
pthread_t threads[2];
struct sched_param nrt_param;
pthread_mutex_t rsrcA, rsrcB;
volatile int rsrcACnt=0, rsrcBCnt=0, noWait=0;
void *grabRsrcs(void *threadid)
{
if((int)threadid == 1)
{
printf("THREAD 1 grabbing resources\\n");
pthread_mutex_... | 1 |
#include <pthread.h>
const int LIMIT = -1;
const int COUNT = 11;
struct prodcons {
int buffer[4];
pthread_mutex_t key;
int read, write;
pthread_cond_t notEmpty;
pthread_cond_t notFull;
} buffer;
void init(struct prodcons * b)
{
pthread_mutex_init(&b->key, 0);
pthread_c... | 0 |
#include <pthread.h>
int balance;
int id;
pthread_mutex_t mutex;
} bank_account;
bank_account A, B;
int counter = 0;
init_account(bank_account *a) {
a->id = counter++;
a->balance = 0;
pthread_mutex_init(&a->mutex, 0);
}
void deposit(bank_account *f, bank_account *t, int ammount) {... | 1 |
#include <pthread.h>
double result;
pthread_mutex_t mutexsum;
double func(double x) {
return x * x * x + 3;
}
struct threadArgs {
int id;
double left;
int steps;
double step;
};
void *PrintHello(void *arguments) {
struct threadArgs *args = (struct threadArgs *)arguments... | 0 |
#include <pthread.h>
sem_t semaphore;
pthread_mutex_t mutex;
pthread_cond_t cond;
int count = 0;
void *writePipe(void* f)
{
int *fd = (int*)f;
char * msg = "Ashish through pipe!";
int i=0;
printf("\\nchild:\\n");
while(msg[i] !='\\0')
{
pthread_mutex_lock(&mutex);
... | 1 |
#include <pthread.h>
static int next_command;
static int leftSpeed;
static int rightSpeed;
static unsigned char * leftBump;
static unsigned char * rightBump;
static int run_thread;
static pthread_mutex_t command_mutex;
static char bumpsRead;
void roombath_init() {
pthread_mutex_init(&command_mut... | 0 |
#include <pthread.h>
pthread_mutex_t spoons[20];
pthread_mutex_t pr = PTHREAD_MUTEX_INITIALIZER;
int spoon_stat[20]={0};
void think(int id){
}
void eat(int id){
pthread_mutex_lock(&pr);
printf("Philosopher %d is eating with spoons %d and %d!\\n",id,(id)%(20),(id+1)%(20));
spoon_stat[(i... | 1 |
#include <pthread.h>
pthread_once_t __continuation_pthread_once = PTHREAD_ONCE_INIT;
pthread_key_t __async_pthread_key;
int __continuation_pthread_jmpbuf_initialized = 0;
int __continuation_pthread_jmpcode[sizeof(jmp_buf) / sizeof(void *)] = { 0 };
static pthread_mutex_t jmpbuf_mutex;
sta... | 0 |
#include <pthread.h>
enum { PROC0, PROC1 } volatile state = PROC0;
void *print();
const int LINES = 5,
LOOP = 10;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t proceed = PTHREAD_COND_INITIALIZER;
int main() {
pthread_t* handle = malloc(2*sizeof(pthread_t));
... | 1 |
#include <pthread.h>
char *outboard;
char *inboard;
pthread_barrier_t *barrier;
pthread_mutex_t *mutex;
int *return_count;
int total_nrows;
int tid;
int gens_max;
} arguments;
void *evaluate_board(void *thread_args);
char*
parallel_game_of_life(char* outboard, char* inboard, const int nrow... | 0 |
#include <pthread.h>
static volatile unsigned char bee_control = STOP;
pthread_mutex_t *bee_mutex;
int bee_init()
{
if (-1 == wiringPiSetup()) {
printf("Setup wiringPi failed!");
return 0;
}
pinMode (bee_Pin, OUTPUT);
bee_mutex = (pthread_mutex_t *) malloc( sizeof(pthread_mutex_t) );
... | 1 |
#include <pthread.h>
double *A;
int num_threads = 2;
int N = 33554432;
int ocurrencia = 0;
double buscar = 1;
pthread_mutex_t sumando;
double dwalltime(){
double sec;
struct timeval tv;
gettimeofday(&tv,0);
sec = tv.tv_sec + tv.tv_usec/1000000.0;
return ... | 0 |
#include <pthread.h>
void *reader(void *);
void *writer(void *);
int nloop = 1000, nreaders = 6, nwriters = 4;
struct {
pthread_rwlock_t rwlock;
pthread_mutex_t rcountlock;
int nreaders;
int nwriters;
} shared = { PTHREAD_RWLOCK_INITIALIZER, PTHREAD_MUTEX_INITIALIZER };
int main(... | 1 |
#include <pthread.h>
struct job
{
struct job* next;
};
struct job * job_queue = 0;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
void process_job(struct job *job)
{
}
void* thread_function(void* arg)
{
while(1)
{
struct job *next_job;
pthread_mute... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cv;
int elves_exited;
elf_status *status;
void *
elf_thread(void *arg)
{
int id;
id = (int) arg;
usleep(((int)(20 + ((double)random() / 32767) * (30 - 20 + 1))));
printf("Elf %d prepared sumptious feast!\\n", id);
... | 1 |
#include <pthread.h>
static int const writerMaxPeriod = 10;
static int const writingMaxPeriod = 5;
static int const readerMaxPeriod = 30;
static int const readingMaxPeriod = 5;
static int const randomSleepsPeriod = 3;
{
pthread_t threadId;
int userId;
} thread_info_type;
static pthr... | 0 |
#include <pthread.h>
int *buffer;
int N, B;
int front = 0;
int end = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *producer(void *params)
{
srand(time(0));
int i = 0;
int num = 0;
while ( i<N )
{
while(((front+1) % B) == end);
num = rand()... | 1 |
#include <pthread.h>
static void* (*oldMalloc) (size_t, const void*);
static void* (*oldRealloc) (void*, size_t, const void*);
static double failDelay;
static size_t failMinSize;
static double failProbability;
static double failStartStamp;
pthread_mutex_t lock;
static double currentTimeStamp (... | 0 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mut;
int number=0, i;
void *thread1()
{
printf ("thread1 : I'm thread 1\\n");
for (i = 0; i < 10; i++)
{
printf("thread1 : number = %d\\n",number);
pthread_mutex_lock(&mut);
number++;
pthread_... | 1 |
#include <pthread.h>
pthread_mutex_t mx, my;
int x=2, y=2;
void *thread1() {
int a;
pthread_mutex_lock(&mx);
a = x;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
pthread_mutex_unlock(&my);
a = a + 1;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y... | 0 |
#include <pthread.h>
int main(int argc, char const *argv[])
{
srand(time(0));
int i,tmp[P],err;
err = pthread_mutex_init(&disp_mutex,0);
assert(!err);
for(i = 0;i < P;++i) {
forkState[i] = 1;
phil_cycles[i] = 0;
err = pthread_mutex_init(&mutex[i],0);
assert(!err);
err = pthread_... | 1 |
#include <pthread.h>
pthread_mutex_t shared_array_mutex = PTHREAD_MUTEX_INITIALIZER;
char shared_array_changed = 0;
int a[] = {1, 2, 3, 4, 5, 6, 7, 8};
int b[] = {1, 3, 5, 7, 11, 13, 17, 19, 23};
int c[] = {-9, -7, -5, -3, -1, 0, 1, 2};
void * thread_func1 (void * arg)
{
int i;
for(i = 0; i < ... | 0 |
#include <pthread.h>
struct cores_pthread *cores_pthread_make (int availables)
{
int i;
struct cores_pthread *cores = malloc(sizeof(struct cores_pthread));
cores->cores = availables;
cores->running = 0;
cores->threads = malloc(sizeof(pthread_t)*cores->cores);
for (i=0; i < cores->cores; ++i)
... | 1 |
#include <pthread.h>
pthread_mutex_t semaforo;
int * buffer;
int tamBuffer;
int usoBuffer=0;
void * produce(void * l);
void * consume(void *);
void validaCreate(int e);
void validaJoin(int e);
int main(){
srand(time(0));
pthread_mutex_init(&semaforo,0);
pthread_t * hilos;
hilos=(... | 0 |
#include <pthread.h>
pthread_mutex_t stdout_mutex = PTHREAD_MUTEX_INITIALIZER;
int global_histogram[8] = { 0 };
int fhistogram(char const *path) {
FILE *f = fopen(path, "r");
int local_histogram[8] = { 0 };
if (f == 0) {
fflush(stdout);
return -1;
}
int i = 0;
... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double c;
int wsize;
int repeat;
} dotdata_t;
dotdata_t dotdata;
pthread_mutex_t mutexsum;
void *dotprod_worker(void *arg)
{
int i, k;
long offset = (long) arg;
double *a = dotdata.a;
double *b = dotdata.b;
int... | 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;
l... | 1 |
#include <pthread.h>
static int first[9];
static int second[9];
static int result[9];
char p;
static char cmd = 'c';
static pthread_mutex_t mutex;
void *crt(void *p) {
while (1) {
if (cmd == 'c') {
pthread_mutex_lock(&mutex);
for (int i = 0; i < 9; ++i) {... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
int n = 0, size = 0;
char buf[5];
void *fun1(void *arg)
{
pthread_mutex_unlock(&mutex1);
int fd = *(int*)arg;
while (1)
{
pthread_mutex_lock(&mutex1... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void thread_init(void)
{
printf("thread_init\\n");
pthread_key_create(&key, free);
}
char *mygetenv(const char ... | 0 |
#include <pthread.h>
pthread_t threads[2];
int tasks[2];
pthread_mutex_t locks[2];
void *thr_f(void *arg)
{
int id = (int)arg;
while (1)
{
printf("Thread %d waiting for task\\n", id);
pthread_mutex_lock(&locks[id]);
pthread_mutex_lock(&locks[id]);
pthread_mutex_unlock(&locks[id]);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int compare(const int * a, const int * b){
if (*a > *b){
return(1);
}
else if( *b > *a){
return(-1);
}
else{
return(0);
}
}
int is_prime(int p){
int i;
if(p < 2){
return(0);
}
i = 2;
while(i*i <= p){
... | 0 |
#include <pthread.h>
struct MessagePool *CreateMessagePool() {
struct MessagePool *pool = (struct MessagePool *)malloc(sizeof(struct MessagePool));
if (pool == 0) {
printf("allocated pool error\\n");
return 0;
}
pthread_mutex_init(&pool->poolMutex, 0);
pool->count = 0;
int i = 0;
for ... | 1 |
#include <pthread.h>
static int fd;
static int disconnect;
static char *ip;
static char *port;
static uint32_t cuid;
static pthread_t hthid;
static pthread_t rthid;
static pthread_mutex_t fdlock;
pthread_t thid;
pthread_mutex_t mutex;
pthread_cond_t cond;
uint8_t *buff;
uint32_t buffsize;... | 0 |
#include <pthread.h>
double time_diff(struct timeval x , struct timeval y)
{
double x_ms , y_ms , diff;
x_ms = (double)x.tv_sec*1000000 + (double)x.tv_usec;
y_ms = (double)y.tv_sec*1000000 + (double)y.tv_usec;
diff = (double)y_ms - (double)x_ms;
return diff;
}
pthread_mutex_... | 1 |
#include <pthread.h>
int result = 0;
pthread_mutex_t mutex;
pthread_mutex_t fict;
pthread_mutex_t write;
pthread_cond_t blocked;
char password[256];
void *WritingThread() {
while(1) {
pthread_mutex_lock(&write);
if (result)
break;
pthread_mutex_lock(&mutex);
printf("Enter password... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
struct foo * foo_alloc(int id)
{
struct foo *fp;
if ((fp = (struct foo*)malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
fp->f_id = id;
if (pthread_mutex_init(&fp->f_lock, 0) != 0) {
free(fp);
... | 1 |
#include <pthread.h>
int vec[5000] = {0};
int n = 0;
pthread_mutex_t exclusion;
void printVector() {
int i;
for(i = 1; i <= 2000; i++) {
printf("%d ", vec[i]);
}
printf("\\n");
}
void *computeThread(void *arg) {
printf("Started thread \\n");
int i;
fo... | 0 |
#include <pthread.h>
int buffer[10];
sem_t buffer_full;
sem_t buffer_empty;
pthread_mutex_t thread_mutex;
pthread_t produce_thread;
pthread_t consume_thread;
void *consume()
{
int k = 0;
while (k < 100)
{
sem_wait(&buffer_empty);
pthread_mutex_lock(&thread_mutex);... | 1 |
#include <pthread.h>
int N=100;
int T=4;
pthread_mutex_t count_lock;
pthread_cond_t ok_to_proceed;
int count;
} barrier;
double escalar;
barrier *barrera;
double max, min, suma;
double *R;
double* M[3];
pthread_mutex_t mutexMax;
pthread_mutex_t mutexMin;
pthread_mutex_t mutexAvg;
vo... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.