text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int tableau[4] = {0};
pthread_mutex_t verrou = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condi = PTHREAD_COND_INITIALIZER;
void* T1(){
int i;
for (i=0; i<4; i++){
printf("Début de traitement de la zone %i par T1\\n", i);
sleep(1);
pthread_mutex_lock(&verrou);
table... | 1 |
#include <pthread.h>
int q_main, flag_main;
pthread_mutex_t mtx_main;
pthread_mutex_t cond_main;
int q_roll, flag_roll;
pthread_mutex_t mtx_roll;
pthread_mutex_t cond_roll;
int q_pass, flag_pass;
pthread_mutex_t mtx_pass;
pthread_mutex_t cond_pass;
int wait_pas = 0;
void *passenger();
void ... | 0 |
#include <pthread.h>
static int logging = 0;
static int loglevel = LYWARN;
static FILE *LOGFH = 0;
static char logFile[PATH_MAX];
static pthread_mutex_t log_mutex = PTHREAD_MUTEX_INITIALIZER;
int logfile(const char *file, int in_loglevel)
{
if (in_loglevel >= LYDEBUG && in_loglevel <=... | 1 |
#include <pthread.h>
void *philosopher (void *id);
int food_on_table (), numRefeicoes = 0;
pthread_mutex_t chopstick[5], mut, saleiro;
pthread_mutex_t food_lock;
pthread_t philo[5];
int main (int argn, char **argv)
{
long i;
pthread_mutex_init (&saleiro, 0);
pthread_mutex_init (&m... | 0 |
#include <pthread.h>
{
int data;
struct node* next;
}node_t;
int c=0;
void *thread1(void *);
void *thread2(void *);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void insert(int data,node_t * head)
{
node_t * last = head;
pthread_mutex_lock(&mutex);
c++;
while(last->next != 0)
{
... | 1 |
#include <pthread.h>
pthread_t tid[10];
int lletres;
int n_veg;
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
void * caracter(void *id)
{
int i;
for (i=0; i < n_veg; i++)
{
sleep(1 + rand() % 3);
pthread_mutex_lock(&mutex);
if (lletres > 0)
{
printf("%c",'a'+... | 0 |
#include <pthread.h>
struct info {
int id;
int loops;
};
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static volatile int glob = 0;
static void *
threadFunc(void *arg)
{
struct info *i = (struct info *) arg;
int loops = i->loops;
int loc, j;
for (j = 0; j < loops; j++)... | 1 |
#include <pthread.h>
int thread_count;
double dx = 0.1e-2;
double dt = 0.1e-6;
int timcnt = 250;
double sum = 0;
pthread_mutex_t mutex;
int rank;
double *uc;
double *un;
double *sum;
}thread_parm_t;
void* uc_init(void *parm){
thread_parm_t *p = (thread_parm_t *)parm;
int i, start, end;
i... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex_initialize = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t condition_init = PTHREAD_COND_INITIALIZER;
extern void queue_init(struct scheduler_queue* queue) {
queue->lock = mutex_initialize;
queue->not_empty = condition_init;
}
extern vo... | 1 |
#include <pthread.h>
pthread_attr_t attr;
pthread_t idth[10];
pthread_mutex_t mtx;
pthread_cond_t varcond;
int turno=1;
void *hilo1(void *num) {
int cont=1;
while (cont <=10){
pthread_mutex_lock (&mtx);
while (turno!=1) pthread_cond_wait(&varcond, &mtx);
printf ("th1:%d\\n",... | 0 |
#include <pthread.h>
pthread_t callThd[2];
pthread_mutex_t mutexpi;
static long num_steps = 1000000;
double sum = 0.0;
double step;
void *calpi(void *arg)
{
int i;
double x, sum_parcial = 0.0;
int offset;
offset = (int)arg;
int len = (int) num_steps/(int)2;
int start = len * (int) offset;... | 1 |
#include <pthread.h>
size_t num_bins;
size_t *bins;
double min_value;
double max_value;
double bin_width;
} histogram_t;
histogram_t *hist = 0;
pthread_mutex_t mutexsum;
size_t count = 0;
int thread_count;
int flag = 0;
double *data;
size_t search_for_bin(double value, histog... | 0 |
#include <pthread.h>
int buffer[100];
int fill = 0;
int use = 0;
int count = 0;
void put(int value) {
buffer[fill] = value;
fill = (fill + 1) % 100;
count ++;
}
int get () {
int tmp = buffer[use];
use = (use + 1) % 100;
count--;
return tmp;
}
pthread_cond_t emp... | 1 |
#include <pthread.h>
int memory[(2*32+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top;
int index_malloc(){
int curr_alloc_idx = -1;
pthread_mutex_lock(&m);
if(next_alloc_idx+2-1 > (2*32+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx = n... | 0 |
#include <pthread.h>
int mediafirefs_rmdir(const char *path)
{
printf("FUNCTION: rmdir. path: %s\\n", path);
const char *key;
int retval;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pthread_mutex_lock(&(ctx->mutex));
... | 1 |
#include <pthread.h>
int tasks = 0, done = 0;
pthread_mutex_t lock;
void dummy_task(void *arg) {
usleep(10000);
pthread_mutex_lock(&lock);
char *Buf;
Buf= (char *)arg;
printf("Buf: %s\\n", Buf);
done++;
pthread_mutex_unlock(&lock);
}
int main(int argc, char **arg... | 0 |
#include <pthread.h>
int source[30];
int minBound[6];
int maxBound[6];
int channel[6];
int th_id = 0;
pthread_mutex_t mid;
pthread_mutex_t ms[6];
void sort (int x, int y)
{
int aux = 0;
for (int i = x; i < y; i++)
{
for (int j = i; j < y; j++)
{
if (source[i] > source[... | 1 |
#include <pthread.h>
int g1, g2, g3, g4;
int found = 1;
float goertzel(int N,int Ft, float* input) {
int k, i;
float floatN;
float omega, sine, cosine, q0, q1, q2, power;
float scalingFactor = N / 2.0;
floatN = (float) N;
k = (int) (0.5 + ((floatN * Ft) / Fs));
omeg... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void threadcleanup(void *p)
{
printf("i am the %ld thread's cleaner,i unlock mutex\\n",(long int)p);
pthread_mutex_unlock(&mutex);
}
void * threadfunc(void *p)
{
pthread_cleanup_push(threadcleanup,p);
pthread_mutex_lock(&mu... | 1 |
#include <pthread.h>
{
int id;
char name[20];
int flag;
int money;
}Person;
Person per[20];
double money = 0.0;
int num = 0;
pthread_mutex_t lock;
void *producer(void* value)
{
double n = *(double*)value;
pthread_mutex_lock(&lock);
money = n;
pthread_mutex_un... | 0 |
#include <pthread.h>
void *consumeTen();
void *consumeFifteen();
struct data
{
pthread_t threadID;
char name;
int pearlsTaken;
int *pearls;
};
int pearls = 1000;
int occupied = 0;
pthread_mutex_t mutex;
pthread_cond_t full_cond;
pthread_cond_t empty_cond;
struct data threadData... | 1 |
#include <pthread.h>
int circle_count;
int total_points = 10000000;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double random_double();
void * start_routine();
int main(void){
double est_pi;
pthread_t workers[4];
pthread_attr_t attr;
pthread_attr_init(&attr);
for(int i = 0; i < ... | 0 |
#include <pthread.h>
double *x;
double *y;
double sum;
int vectorLength;
} DOTDATA;
DOTDATA dotprod;
pthread_t threads[4];
pthread_mutex_t mutex;
void *dotProduct (void *arg) {
int i, start, end, length;
long offset;
double sum, *x, *y;
offset = (long) arg;
length = dotprod.vect... | 1 |
#include <pthread.h>
void *threadFunction(void *p);
int counter;
pthread_mutex_t lock;
int main(){
pthread_t thread_id[5];
int i, ret;
counter = 0;
if( pthread_mutex_init(&lock, 0) != 0){
fprintf(stderr, "Erro ao criar mutex.\\n");
exit(1);
}
for(i=0; i<5; ++i){
ret =... | 0 |
#include <pthread.h>
int initial_shareMemory(int key, struct shared_use_st **shared)
{
int shmid = shmget((key_t)key, sizeof(struct shared_use_st), 0666 | IPC_CREAT);
if (shmid == -1) {
debug_msg("initialize share memory failed!");
return -1;
}
void *memoryAdd = shmat(shmid, 0, ... | 1 |
#include <pthread.h>
void *thread_dis01(void *arg) {
int running = 1;
int DIS01fd = 0;
enum paritymark parity = 'N';
DIS01fd = openSerial(DIS01_SEIRAL_FILE, O_RDWR, B9600, parity, 8, 1);
float factor = 40.0f;
float value=0.0f;
float current=0.0f;
while (running) {
value = sendSerialT... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
static int iTThreads = 2;
static int iRThreads = 1;
static int data1Value = 0;
static int data2Value = 0;
pthread_mutex_t *data1Lock;
pthread_mutex_t *data2Lock;
void lock(pthread_mutex_t *);
void unlock(pthread_mutex_t *);
void *funcA(vo... | 1 |
#include <pthread.h>
extern int errno;
struct param_list{
char *ip;
int sockfd;
};
void *peer_deal(void *i)
{
struct param_list *my_param = (struct param_list *)i;
int sockfd = my_param->sockfd;
int close_bit = 1;
printf("Child created for dealing with client request\\n"... | 0 |
#include <pthread.h>
void dump (uint32_t pid, int screen_log, int reporte_memoria, int reporte_tabla){
FILE *reporte = fopen ("reporte.txt", "a+");
generar_reporte(reporte, pid, reporte_memoria, reporte_tabla, screen_log);
fclose(reporte);
}
void retardo (int segundos){
pthread_mut... | 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_exit(err, "sigwait failed");
}
... | 0 |
#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;
tsp->tv_nsec = tv.tv... | 1 |
#include <pthread.h>
int race;
pthread_mutex_t mutex1;
void* adder(void* r){
int i;
pthread_mutex_lock(&mutex1);
for(i = 0; i < 20000000; i++){
race++;
}
pthread_mutex_unlock(&mutex1);
printf("%d\\n", race);
return 0;
}
void* subtractor(void* r){
int i;
pthread_mutex_lock(&mu... | 0 |
#include <pthread.h>
void aluout_register(void *not_used){
pthread_barrier_wait(&threads_creation);
while(1){
pthread_mutex_lock(&control_sign);
if(!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait,&control_sign) != 0);
... | 1 |
#include <pthread.h>
pthread_cond_t condition_alarme=PTHREAD_COND_INITIALIZER ;
pthread_mutex_t mutex_alarme=PTHREAD_MUTEX_INITIALIZER ;
static void* thread_temperature (void *inutile) ;
static void * thread_alarme (void *inutile) ;
int main(void)
{
int limit=5;
pthread_t thr ;
pthread_cr... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void){
printf("prepare() lock....\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void){
printf("parent() ....\\n");
pthre... | 1 |
#include <pthread.h>
int store_num;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *consumer(void *arg)
{
printf("开始消费\\n");
int need= (int)arg;
pthread_mutex_lock(&mutex);
while(need > store_num)
{
pthread_cond_wait(&cond,&mutex);
}
store_num = store_num... | 0 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing1(void *arg)
{
printf("%s entering...", __func__);
fflush(stdout);
pthread_mutex_lock(&lock);
printf("%s done\\n", __func__);
unsigned long i = 0;
counter += 1;
printf("\\n Job ... | 1 |
#include <pthread.h>
int buzzer_on;
int buzz_cnt;
extern pthread_mutex_t mtx;
extern int level;
void* buzzer()
{
int fd;
int buzzer_control = 1;
int null_integer = 0;
int temp = 0;
fd = open("/dev/cnbuzzer",O_RDWR);
if ( fd < 0 )
{
perror("driver (//dev//cnbuzzer) open error... | 0 |
#include <pthread.h>
void sigHandlerQuit(int);
void *find_file(void *arg);
void *dispatch_executer(void *arg);
int filesSent, filesFound = 0;
pthread_mutex_t mutexTotalTime, retrieved, sent;
int totalTime = 0;
int main() {
srand(time(0));
pthread_mutex_init(&mutexTotalTim... | 1 |
#include <pthread.h>
static pthread_t tacho_thread;
static pthread_mutex_t tacho_mutex = PTHREAD_MUTEX_INITIALIZER;
static FILE *logfile;
static char *tacho_dev;
static double tottachodist;
static double totdyndist;
static double rotlen=2.125;
static unsigned int tacholimit=250000;
static int ... | 0 |
#include <pthread.h>
struct buffer_t {
char data[20];
int in;
int out;
pthread_mutex_t mutex;
pthread_cond_t empty;
pthread_cond_t full;
} buffer;
int totalItems = 0;
pthread_t producer[2], consumer[2];
pthread_t terminatorThread;
void *produce(void *tid) {
int i;
for(... | 1 |
#include <pthread.h>
int buffer[1024];
int count=0;
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
pthread_mutex_t mutex3;
void *threadFun1(void *arg)
{
int i;
while(1)
{
pthread_mutex_lock(&mutex1);
printf("Thread 1\\n");
count++;
if((count%2)==1)
{
pthread_mutex_unlock(&mu... | 0 |
#include <pthread.h>
pthread_t tid[2];
int counter=0;
pthread_cond_t condition1,condition2;
pthread_mutex_t lock1,lock2;
void *mutex_cond_fn1(void *arg)
{
pthread_mutex_lock(&lock1);
unsigned long i=0;
counter+=1;
printf("\\n Job %d has started\\n",counter);
for(i=0;i<(0xffffffff);i++);
pr... | 1 |
#include <pthread.h>
const size_t NUMTHREADS = 20;
int done = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* ThreadEntry( void* id )
{
const int myid = (long)id;
int i;
const int workloops = 5;
for( i=0; i<workloops; i+... | 0 |
#include <pthread.h>
static char buffer[10];
static unsigned int first;
static unsigned int next;
static int buffer_size;
_Bool send, receive;
int value;
pthread_mutex_t m;
void initLog(int max)
{
buffer_size = max;
first = next = 0;
}
int removeLogElement(void)
{
assert(first>=0)... | 1 |
#include <pthread.h>
void preprocess_rgb(uint8_t * in, uint8_t * out, int width, int height);
void preprocess_ir(uint8_t * in, uint8_t * out, int width, int height);
void * preprocessor(void * args)
{
struct thread_arg * ta = (struct thread_arg *)args;
struct channel * input = ta->input, * ou... | 0 |
#include <pthread.h>
int food = 5;
int monitor = 1;
int state[5];
pthread_mutex_t monitor_mutex;
pthread_cond_t resource_ready;
pthread_t philo[5];
void *philosopher (void *num);
void get_chopsticks (int, int, int);
void test (int);
void put_chopsticks (int, int, int);
int main (int argc, char... | 1 |
#include <pthread.h>
pthread_mutex_t updatelock;
pthread_cond_t finished;
int numWorkers;
int numArrived = 0;
int final_sum;
int final_max, final_maxi, final_maxj;
int final_min, final_mini, final_minj;
int final_num_workers;
double start_time, end_time;
int size, stripSize;
int matrix[10000... | 0 |
#include <pthread.h>
pthread_cond_t my_cond;
pthread_mutex_t my_mutex;
void*
my_thread_routine(void *arg)
{
int my_id = (int)arg;
pthread_mutex_lock(&my_mutex);
pthread_cond_wait(&my_cond, &my_mutex);
pthread_mutex_unlock(&my_mutex);
while(1)
{
pthread_testcancel();
printf("%d\\n", my_id... | 1 |
#include <pthread.h>
int lock_count;
task_t lock_task = 0;
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
pthread_spinlock_t spinlock;
pthread_mutex_t mlock;
void test_spin() {
pthread_spin_lock(&spinlock);
pthread_spin_unlock(&spinlock);
}
void test_mutex() {
pthread_mu... | 0 |
#include <pthread.h>
void *Tackle(void *Dummy) {
extern pthread_mutex_t Mutex;
printf("Waiting for the snap\\n");
pthread_mutex_lock(&Mutex);
pthread_mutex_unlock(&Mutex);
printf("Tackle!!\\n");
return(0);
}
int main(int argc,char *argv[]) {
extern pthread_mutex_t... | 1 |
#include <pthread.h>
pthread_mutex_t garfo[5];
int pratadas;
void* filosofo(void *arg) {
int i;
i=*((int*)arg);
while(1) {
printf("Filosofo %d pensando!!!\\n",i);
sleep(rand()%3);
pthread_mutex_lock(&garfo[i]);
pthread_mutex_lock(&garfo[(i+(5 -1))%5]);
printf("F... | 0 |
#include <pthread.h>
static int *volatile global_ptr;
static pthread_mutex_t mux = PTHREAD_MUTEX_INITIALIZER;
static void *
thr_main(void *ign)
{
while (1) {
int *p;
pthread_mutex_lock(&mux);
STOP_ANALYSIS();
p = global_ptr;
if (p) {
p = global_ptr;
*p = 5;
}
STOP_ANALYSIS... | 1 |
#include <pthread.h>
void* deposit(void* data);
struct account
{
char name[20];
int balance;
};
struct account yac={"Gokhan",100};
pthread_mutex_t lock;
int main(int argc, char const *argv[])
{
int i,n;
n=6;
pthread_t tid[n];
int deposit_amount[n];
deposit_amount[0]=1000;
deposit_amount[1]=... | 0 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static void thread_init(void) {
pthread_key_create(&key, free);
}
int putenv_r(char *env) {
int err, envlen, ret = -1;
char *envbuf;
si... | 1 |
#include <pthread.h>
char buffer[100][100];
pthread_t ctid[10];
pthread_t ptid[5];
FILE *fpprod,*fpcons;
pthread_mutex_t mutex;
sem_t full,empty;
int counter,flag;
void *prod(void *arg);
void *cons(void *arg);
void initialize();
void insert_item();
void delete_item();
char switchBuffe... | 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(int argc , char * argv[]) {
int rtn, i;
pthread_t pthread_id = 0;
rtn = p... | 1 |
#include <pthread.h>
int count = 0;
Turn turn = None;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
void *even (void *args)
{
while(1)
{
pthread_mutex_lock(&lock);
while(turn != Even)
pthread_cond_wait(&condition, &lock);
... | 0 |
#include <pthread.h>
double *a = (double *) malloc (1000000 * sizeof(double));
double *warehouse = a;
pthread_mutex_t mutexsum = PTHREAD_MUTEX_INITIALIZER;
pthread_barrier_t barr;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
double sum =0.0;
static struct timeval start_time;
static void ... | 1 |
#include <pthread.h>
int TOTAL = 0;
pthread_mutex_t lock;
void * Count(void * a)
{
pthread_mutex_lock(&lock);
int i, tmp;
for(i = 0; i < 1000000; i++)
{
tmp = TOTAL;
tmp = tmp+1;
TOTAL = tmp;
}
pthread_mutex_unlock(&lock);
}
int main(int argc, ... | 0 |
#include <pthread.h>
void *record_fun()
{
int cmd;
while(1)
{
pthread_mutex_lock(&mutex_record);
pthread_cond_wait(&cond_record,&mutex_record);
cmd = msg.cmd;
pthread_mutex_unlock(&mutex_record);
switch(cmd)
{
case RECORD_ON:
system("killall mjpg_streamer");
... | 1 |
#include <pthread.h>
void * smoker1(void * arg);
void * smoker2(void * arg);
void * smoker3(void * arg);
void * putMaterials(void * arg);
void smoke(int i);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int * buffer;
int main(){
srand(time(0));
pthread_t * tids = (pthread_t*)malloc(3*siz... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
sem_t sem;
SharedInt* sip;
void *funcWCritSec(int* v2) {
pthread_mutex_lock(&(sip->lock));
sip->value = sip->value + *v2;
if(sip->value < 3) {
sip->value = sip->value + *v2;
pthread_mutex_unloc... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_t tid[4];
int s_lohan=100, s_kepiting=100;
void cek_game_status(){
if (s_lohan <=0 || s_kepiting <=0 || s_lohan>100 || s_kepiting >100){
printf ("game ended\\n");
exit(0);
}
}
void *makan_lohan(void *arg){pthread_mutex_lo... | 0 |
#include <pthread.h>
FILE **fp1, **fp2;
int flag[MAX_FILE_NUMBER];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *convert(void *arg)
{
int i, idx, ifhave;
int *tmp = (int *)arg;
while (1)
{
ifhave = 0;
pthread_mutex_lock(&mutex);
for (i = 0; i < ... | 1 |
#include <pthread.h>
int iter = 0, buffer[256];
pthread_mutex_t sum_mutex;
void* do_work(void *tid)
{
int *mytid = (int *) tid;
*mytid += 1;
int finish = 0;
while (1)
{
pthread_mutex_lock (&sum_mutex);
if (iter >= 256) finish = 1;
else
{
buffer[iter] = *mytid;
printf ("Escr... | 0 |
#include <pthread.h>
int balance = 1000000;
pthread_mutex_t mutex;
void *withdraw(void * n)
{
int temp = (int)n;
printf("\\nWithdraw Called :: %d Debit",temp);
pthread_mutex_lock(&mutex);
balance = balance - temp;
pthread_mutex_unlock(&mutex);
printf("\\nBalance = %d ",balance);
}... | 1 |
#include <pthread.h>
volatile long double result = 0.0;
pthread_mutex_t resultLock;
long double intervals;
int numThreads;
double a[700][700];
double b[700][700];
double c[700][700];
struct thread_info {
pthread_t thread_id;
int thread_num;
int perThread;
int threadStart;
int i, j;
};
v... | 0 |
#include <pthread.h>
void *find_words(void*);
int map_reduce(int number_threads, char *string, struct list *list);
int main(void) {
char *string;
int cur_time, i, j;
struct list *list;
struct stat *buf;
buf = (struct stat *) malloc(sizeof(struct stat));
stat("./Don_Quixo... | 1 |
#include <pthread.h>
int nblect=0;
sem_t mutex;
sem_t BD;
sem_t SAS;
pthread_mutex_t mutex2;
pthread_cond_t fprod;
pthread_cond_t fconso;
int Nmess=2;
int Pconso=0;
int Pprod=0;
int tampon[2];
void debut_lire (){
printf("Demande de lecture\\n");
sem_wait(&SAS);
sem_wait(&mutex);
nble... | 0 |
#include <pthread.h>
pthread_mutex_t pLogFileWrite_Mutex = PTHREAD_MUTEX_INITIALIZER ;
static int WriteLogFileInHex (const char* ,const char* );
static int WriteLogFile_Ex (const char*,const char* ) ;
int WriteLogFile (const char*,int) ;
int WriteLogFileInHex_Ex (const char* ,int ) ;
int WriteLo... | 1 |
#include <pthread.h>
unsigned char onebyte[128];
} BigMEMBlock;
int numblocks = 1024*1024*1024/128 ;
int numworkers = 1;
int runtime = 600;
int prepare = 5;
size_t MEMBLOCKSIZE = sizeof(BigMEMBlock);
BigMEMBlock *mempool;
pthread_t *tid;
pthread_mutex_t filelock;
FILE* logfd;
pthread_t timer... | 0 |
#include <pthread.h>
struct student{
int id;
int age;
int name;
}stu;
int i;
pthread_mutex_t mutex;
void *thread_func1(void *arg){
while(1){
pthread_mutex_lock(&mutex);
stu.id = i;
stu.age = i;
stu.name = i;
i++;
if(stu.id != stu.age || stu.id != stu.name || stu.age != stu.name... | 1 |
#include <pthread.h>
static int (*pthread_mutex_lock_orig) (pthread_mutex_t *m) = 0;
static int (*pthread_mutex_unlock_orig)(pthread_mutex_t *m) = 0;
static int enable_lock_tracking = 0;
int pthread_mutex_lock(pthread_mutex_t *m)
{
int res;
if (!pthread_mutex_lock_orig)
pthread_mutex_l... | 0 |
#include <pthread.h>
struct word_record{
char *str;
int count;
};
struct thread_data{
FILE *fp;
int start;
int blockSize;
char filepath[1024];
};
pthread_mutex_t critical_mutex;
int i=0;
struct word_record * Rec;
void* count_frequency(void* data){
int index=0,k=... | 1 |
#include <pthread.h>
pthread_t t_master;
pthread_t t_slave[4];
int master_cnt;
int slave_cnt[4];
int loop;
int done;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void* master_thread_code(void* arg) {
while(loop) {
pthread_mutex_lock(&m);
... | 0 |
#include <pthread.h>
static long TOTAL;
int counter = 0;
pthread_mutex_t lock;
int next_counter(void)
{
pthread_mutex_lock( &lock );
int temp = ++counter;
pthread_mutex_unlock( &lock );
return temp;
}
int is_prime( long x )
{
long i;
for( i = 2; i < x/2; ++i )
{
if( 0 == ... | 1 |
#include <pthread.h>
pthread_mutex_t mEnqueue = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mDequeue = PTHREAD_MUTEX_INITIALIZER;
int val;
struct element* next;
} element;
element* head;
element* tail;
int size;
} queue;
void init_queue(queue *q) {
element *e = (element*)malloc(siz... | 0 |
#include <pthread.h>
bool *is_prime;
pthread_mutex_t is_prime_mutex = PTHREAD_MUTEX_INITIALIZER;
int next = 0;
pthread_mutex_t next_mutex = PTHREAD_MUTEX_INITIALIZER;
int max_number;
void print_usage(void);
void *find_primes(void *id);
int get_next_index(void);
void rec... | 1 |
#include <pthread.h>
int available[3]={10,12,14};
int maximum[5][3]={{4,5,2},{5,7,3},{6,3,8},{5,9,7},{10,5,4}};
int allocation[5][3]={{1,1,0},{2,0,1},{0,0,2},{0,0,0},{0,0,0}};
int need[5][3]={{3,4,2},{3,7,2},{6,3,6},{5,9,7},{10,5,4}};
pthread_mutex_t mutex;
pthread_cond_t cond_var;
void release... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[8];
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>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(800)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_to... | 0 |
#include <pthread.h>
pthread_mutex_t *fork_lft, *fork_rgt;
const char *name;
pthread_t thread;
int fail;
} Philosopher;
int running = 1;
void *PhilPhunction(void *p) {
Philosopher *phil = (Philosopher*)p;
int failed;
int tries_left;
pthread_mutex_t *fork_lft, *fork_rgt, *fork_tmp;
whil... | 1 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
int seed;
void *Ta(void *param){
int totalHelpers = 8;
while(totalHelpers){
struct timeval now;
struct timespec timeout;
gettimeofday(&now);... | 0 |
#include <pthread.h>
int main()
{
char *shm = "myshm";
char *shm1 = "myshm1";
int shm_id, shm_id1;
char *buf;
pid_t pid;
pthread_mutex_t *mutex;
pthread_mutexattr_t mutexattr;
shm_id1 = shm_open(shm1, O_RDWR|O_CREAT, 0644);
ftruncate(shm_id1, 100);
mutex =(pthread_mutex_t *)mmap(0,... | 1 |
#include <pthread.h>
int cmr_msg_queue_create(unsigned int count, unsigned int *queue_handle)
{
struct cmr_msg_cxt *msg_cxt;
CMR_LOGV("count 0x%x, queue_handle 0x%x", count, (unsigned int)queue_handle);
if (0 == count) {
return -CMR_MSG_PARAM_ERR;
}
msg_cxt = (struct cmr_msg_cxt*)malloc(si... | 0 |
#include <pthread.h>
struct LinkedList
{
int data;
struct LinkedList *next;
struct LinkedList *prev;
};
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
struct LinkedList *head;
{
char A[100];
} Info;
{
Info info;
struct Element_ *next;
} Element;
struct LinkedList *
LinkedList_... | 1 |
#include <pthread.h>
void *producer(void *);
void *consumer(void *);
pthread_mutex_t mut;
pthread_cond_t producer_cv;
pthread_cond_t consumer_cv;
int supply = 0;
int num_cons_remaining = 100;
int main(int argc, char * argv[])
{
pthread_t prod_tid;
pthread_t cons_tid[100];
... | 0 |
#include <pthread.h>
int num_processes, num_resources, strategy;
int **hold, **need, **max, *avail;
unsigned long simTime = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t isDone = PTHREAD_COND_INITIALIZER;
int isSafe(){
int i,j;
int work[num_resources];
int finish[num... | 1 |
#include <pthread.h>
int threadSearch(int start,int end);
void *searching(void* arg);
int atoi(char* arg);
int numthreads = 100;
int increment = 100;
int done = 0;
int result = -1;
struct position
{
int pos;
int checked;
};
struct position pdx;
struct position * ptr=&pdx;
pthread_mutex... | 0 |
#include <pthread.h>
pthread_mutex_t _lock;
void* value;
int key;
volatile struct _setos_node* next;
} setos_node;
setos_node* head;
int setos_init(void)
{
head = (setos_node*) malloc(sizeof(setos_node));
head->next = 0;
head->key = INT_MIN;
if (pthread_mutex_init(&_lock, 0)... | 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_to... | 0 |
#include <pthread.h>
void *threadfunc(void *arg);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int main(void)
{
int ret;
pthread_t new;
struct timespec ts;
struct timeval tv;
printf("condition variable test 6: bogus timedwaits\\n");
... | 1 |
#include <pthread.h>
pthread_mutex_t corda = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t ida = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t volta = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t turno = PTHREAD_MUTEX_INITIALIZER;
int a_b = 0, b_a = 0;
void* atravessa_corda_AB(void* arg) {
int id... | 0 |
#include <pthread.h>
struct pp_thread_info {
int *msgcount;
char *msg;
int modval;
pthread_mutex_t *mutex;
};
void *
pp_thread(void *arg)
{
struct pp_thread_info *infop;
int c;
infop = arg;
while (1) {
pthread_mutex_lock(infop->mutex);
if (*infop->ms... | 1 |
#include <pthread.h>
inline uint64_t check(uint64_t ans, uint64_t guess){
cv_t cv_a, cv_g;
uint64_t i, j, result = 0;
cv_a.n = ans; cv_g.n = guess;
for (i = 0; i < 4; i++) {
if (cv_a.c[i] == cv_g.c[i]) {
result += 0x10;
} else {
for (j = 0; j < 4; j++) {
if ((i != j) && (cv_a.c... | 0 |
#include <pthread.h>
char *ID;
int N;
int procs;
volatile float A[5000][5000], B[5000], X[5000];
void gauss();
unsigned int time_seed() {
struct timeval t;
struct timezone tzdummy;
gettimeofday(&t, &tzdummy);
return (unsigned int)(t.tv_usec);
}
void parameters... | 1 |
#include <pthread.h>
pthread_mutex_t shared_array_mutex = PTHREAD_MUTEX_INITIALIZER;
char shared_array[ 256 ] = {0};
char shared_array_changed = 0;
int fileLong = 0;
void * filler_thread( void * arg )
{
FILE *f;
char line[256];
f = fopen((char*) arg, "r");
int i;
for( i = 0; i ... | 0 |
#include <pthread.h>
void delay()
{
int i = 0;
for ( i=0; i<1000000; i++) ;
}
{
int x;
int y;
pthread_mutex_t mutex;
} DATA;
DATA data;
void init_data()
{
data.x = 0;
data.y = 0;
pthread_mutex_init(&data.mutex, 0);
printf("init_data\\n");
}
pthread_once_t one = PTHREAD_ONCE_... | 1 |
#include <pthread.h>
int threadsNum;
char *fileName;
int recordsNum;
char *searched;
int file;
int signr;
pthread_t *threads;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *threadFunction(void *);
void signalHandler(int signal) {
printf("PID: %d TID: %ld received signal no %d\\n",... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.