text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct check_farmer* create_check_farmer(FILE* p_file) {
int root_directory_offset = 0, data_cluster_offset = 0,
i;
struct check_farmer* tmp = malloc(sizeof (struct check_farmer));
tmp->p_boot_record = malloc(sizeof (struct boot_record));
fread(tmp->p_boot_record, siz... | 1 |
#include <pthread.h>
static char board[3][3] = {
{'1','2','3'},
{'4','5','6'},
{'7','8','9'}
};
int troca = 0;
static int nextPlayer = 0;
static int numPlays = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void currentBoard(char *buffer) {
pthread_mutex_l... | 0 |
#include <pthread.h>
int a[1000];
int num_iter;
struct Array{
long leftone;
long rightone;
};
void merge(int left, int right)
{
int mid=(left+right)/2;
int L[mid-left+1];
int R[right-mid];
int i,j,k;
num_iter++;
for(i=0;i<(mid-left+1);i++)
L[i]=a[i+left];
for(i=0;i<(right-mid... | 1 |
#include <pthread.h>
extern pthread_mutex_t __sfp_mutex;
extern pthread_cond_t __sfp_cond;
extern int __sfp_state;
FILE *fopen(const char *file, const char *mode)
{
register FILE *fp;
register int f;
int flags, oflags;
if ((flags = __sflags(mode, &oflags)) == 0)
return (0);
if ((f = open(... | 0 |
#include <pthread.h>
FILE *flog;
int semaforo;
struct sembuf entro, salgo;
int sock;
struct sockaddr_in6 servaddr;
struct ipv6_mreq ipv6mreq;
pthread_t thread[10];
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
{
int cada;
int durante;
char texto[100];
}MENSAJE;
MENSAJE mensaje[20]... | 1 |
#include <pthread.h>
int mediafirefs_symlink(const char *target, const char *linkpath)
{
printf("FUNCTION: symlink. target: %s, linkpath: %s\\n", target, linkpath);
(void)target;
(void)linkpath;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_d... | 0 |
#include <pthread.h>
int pbs_rerunjob_err(
int c,
char *jobid,
char *extend,
int *local_errno)
{
int rc;
struct batch_reply *reply;
int sock;
struct tcp_chan *chan = 0;
if ((jobid == (char *)0) || (*jobid == '\\0'))
return (PBSE_IVALREQ);
pthread_mutex_lock(connecti... | 1 |
#include <pthread.h>
int buffer[5];
sem_t s_empty, s_full;
pthread_mutex_t mutex;
int count, flag, front, end;
void sig_handler(int sig) {
if(sig == SIGINT) {
printf("\\nReceieved SIGINT\\n");
flag = 1;
}
}
int insert_item(int buffer_item) {
if(count < 5) {
buffer[end] = buffer_item;
cou... | 0 |
#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 );
}
void prepare()
{
pthread_mutex_lock( &mutex );
}
void infork()
{
pthread_m... | 1 |
#include <pthread.h>
void (*cxa_func)(void*);
uint32_t type;
uint32_t dso_type;
uint32_t dso_scope;
void* arg;
void* dso;
} cxxabi_atexit;
uint32_t size;
uint32_t nelem;
cxxabi_atexit* list;
} cxxabi_atexit_list;
extern void* __dso_handle;
static cxxabi_atexit_list _list;
sta... | 0 |
#include <pthread.h>
void SayiUret();
void *Siralama(void *parametre);
void *Birlesme(void *parametre);
void ThreadYarat();
void DosyayaYaz();
pthread_mutex_t lock;
int liste[1000];
int sonuc[1000];
FILE *dosya;
{
int baslangic;
int bitis;
} parametreler;
int main (int argc, const c... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_cond_t go;
int numWorkers;
int numArrived = 0;
pthread_mutex_t result_lock;
int value;
int row;
int column;
} point_value;
int sum;
point_value max;
point_value min;
}matrix_result;
matrix_result result = {0,
{-1,0,0},
... | 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>
void* run (void *arg);
int main(int argc, char *argv[]) {
pthread_mutex_t m;
pthread_mutex_init(&m, 0);
pthread_mutex_lock(&m);
pthread_t h;
pthread_create(&h, 0, run, &m);
printf("[MAIN]Esperando que termine la ejecucion el hilo disparado\\n");
pthread_join(h, 0);
... | 0 |
#include <pthread.h>
struct id_cache_entry {
generic_id_t id;
char name[32];
};
struct id_cache {
unsigned int num;
struct id_cache_entry entries[];
};
static pthread_mutex_t id_cache_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct id_cache *id_cache_uid;
static struct id_cache *id_c... | 1 |
#include <pthread.h>
int thread_count;
double total_integral;
pthread_mutex_t mutex;
long int nx;
long int ny;
void* Thread_sum(void* rank);
double f1(double x, double y);
double f2(double x, double y);
int main(int argc, char* argv[])
{
long thread;
pthread_t* thread_handles;
clo... | 0 |
#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 s... | 1 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0, 1, 2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold;
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 barrier;
pthread_cond_t go;
int numWorkers;
int numArrived = 0;
void Barrier() {
pthread_mutex_lock(&barrier);
numArrived++;
if (numArrived == numWorkers) {
numArrived = 0;
pthread_cond_broadcast(&go);
} else
pthread_cond_wait(&go, &barr... | 1 |
#include <pthread.h>
void *find_jpg(void *path){
char *file, *file_ext, file_path[1000];
DIR *inDir;
struct dirent *inDirent;
inDir = opendir(path);
if (!inDir) {
fprintf(stderr, "Error while searching for jpg files: invalid file path.\\n");
fprintf(stderr, " Unable to op... | 0 |
#include <pthread.h>
bool queue_init(struct _queue *queue, size_t bufsize) {
bool ret;
memset(queue, 0, sizeof(struct _queue));
ret = pthread_mutex_init(&queue->put_lock, 0) == 0;
if (!ret) {
goto queue_init_err0;
}
ret = pthread_mutex_init(&queue->get_lock, 0) == 0;
if (!ret) ... | 1 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t lock;
void count(int *arg){
int i;
for(i = 0; i<*arg; i++){
pthread_mutex_lock(&lock);
sum++;
pthread_mutex_unlock(&lock);
}
}
int main(int argc, char **argv){
int error, i;
int numcounters = 10;
int limit = 100;
pthread_t tid[100... | 0 |
#include <pthread.h>
void interrupt2()
{
fprintf(stdout, "Token thread exiting\\n");
return;
}
void *handler2()
{
struct sigaction act;
sigset_t sig;
act.sa_handler = interrupt2;
sigaction(SIGUSR2, &act, 0);
sigemptyset(&sig);
sigaddset(&sig, SIGUSR2);
pt... | 1 |
#include <pthread.h>
struct android_handlerthread {
pthread_t tid;
pthread_mutex_t lock;
pthread_cond_t cond;
struct android_looper *looper;
struct android_handler *handler;
};
static void *run(void * data)
{
int ret;
struct android_handlerthread *thread = data;
... | 0 |
#include <pthread.h>
struct Node* left;
struct Node* right;
int value;
} Node;
struct Node* left;
struct Node* right;
pthread_mutex_t m;
} Queue;
void push_left(Queue* q, int val) {
Node* new_left = (Node*)calloc(1, sizeof (Node));
new_left->value = val;
pthr... | 1 |
#include <pthread.h>
struct job{
double data;
struct job* next;
};
struct job* job_queue;
sem_t job_queue_count;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
void*
thread_callback_enqueue(void *arg)
{
unsigned int thread_id = *((unsigned int*)arg);
struct job* new_job = 0;... | 0 |
#include <pthread.h>
int block;
int busy;
int inode;
pthread_mutex_t m_inode;
pthread_mutex_t m_busy;
void *allocator(){
pthread_mutex_lock(&m_inode);
if(inode == 0){
pthread_mutex_lock(&m_busy);
busy = 1;
pthread_mutex_unlock(&m_busy);
inode = 1;
}
block = 1;
if (!(blo... | 1 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
long long n;
double sum = 0;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double Serial_pi(long long n);
int main(int argc, char* argv[]) {
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
unsigned long int *a;
unsigned long int *b;
unsigned long int prod;
int TAM_VET;
void *f(void *ide) {
int i = 0;
int id = atoi(ide);
int tam = TAM_VET/2;
if (id > 0) {
i = id * tam;
}
if (id == 2 -1) {
tam += TAM_VET%2;
}
... | 1 |
#include <pthread.h>
void* process_thread(void *arg) {
struct threads *p = (struct threads *) arg;
fprintf(stderr, "Thread %u: start\\n", (unsigned int)pthread_self());
pthread_mutex_lock(&p->mutex);
while(1) {
char request_filename[16];
char response_filename[16];
switch(p->inout) {
... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer[100];
int i = 0;
void * producer(void *ptr)
{
while(1)
{
printf("producer locking critical region\\n");
pthread_mutex_lock(&the_mutex);
while( i == 100)
{
printf("buffer not empty, producer s... | 1 |
#include <pthread.h>
struct proc
{
pid_t pid;
int status;
bool exited;
int write_fd;
int read_fd;
pthread_mutex_t lock;
struct fcgi* fcgi;
};
static struct proc procs[NUM_PROCS];
static unsigned int procs_available;
static pthread_mutex_t procs_lock;
static st... | 0 |
#include <pthread.h>
void grab_forks(int* philosopher_id);
void put_away_forks(int* philosopher_id);
void test(int* philosopher_id);
void initialize_mutex();
void* philosopher_life(void* philosopher_id);
void think(int* philosopher_id);
void eat(int* philosopher_id, int current_meal);
pthread_mute... | 1 |
#include <pthread.h>
static char envbuf[4096];
extern char **environ;
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_... | 0 |
#include <pthread.h>
char shared_buffer[10];
int shared_count;
pthread_mutex_t mutex;
unsigned int prod_index = 0;
unsigned int cons_index = 0;
void * producer(void *arg);
void * consumer(void *arg);
int main()
{
pthread_t prod_tid, cons_tid1, cons_tid2;
pthread_mutex_init(&mutex, 0... | 1 |
#include <pthread.h>
struct rtpp_pcnt_strm_priv {
struct rtpp_pcnt_strm pub;
struct rtpp_pcnts_strm cnt;
pthread_mutex_t lock;
};
static void rtpp_pcnt_strm_dtor(struct rtpp_pcnt_strm_priv *);
static void rtpp_pcnt_strm_get_stats(struct rtpp_pcnt_strm *,
struct rtpp_pcnts_strm *);
... | 0 |
#include <pthread.h>
static int global = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
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) {
sleep (1);
fprintf (stderr, "s... | 1 |
#include <pthread.h>
void* mutex = 0;
void lock()
{
pthread_mutex_lock((pthread_mutex_t*)mutex);
}
void unlock()
{
pthread_mutex_unlock((pthread_mutex_t*)mutex);
}
void lock_init()
{
mutex = malloc(sizeof(pthread_mutex_t));
if(0 == mutex)
return;
pthread_mutex_init((pthread_mutex_t*)mute... | 0 |
#include <pthread.h>
int nr;
char *filename;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void *SmartFunction(void *arg)
{
char *s,command[150],result[10];
unsigned int len;
int z;
FILE *p;
s = (char *) arg;
len = snprintf(command,sizeof(com... | 1 |
#include <pthread.h>
int variableManoseada;
time_t tiempo;
int a;
pthread_mutex_t lock;
pthread_mutex_t lock2;
void tocarVariable(){
int variable = 0;
while(1){
pthread_mutex_lock(&lock);
pthread_mutex_lock(&lock2);
printf("Dentro de los locks del Thread - Numero: %d\\n", variable);
... | 0 |
#include <pthread.h>
struct AgentInfo{
int agent_id;
int *num_tickets_p;
};
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void *sell_tickets(void *arg){
struct AgentInfo *st_info = arg;
while(1){
pthread_mutex_lock(&mutex);
if(*st_info->num_t... | 1 |
#include <pthread.h>
int val_a, val_b, val_c;
int finished = 0;
pthread_mutex_t mutex;
pthread_cond_t conditionInput, conditionAdd, conditionPrint;
void *add(void *none);
void *print(void *none);
int main()
{
int inp_a, inp_b;
pthread_t thread_add, thread_print;
if( pthread_create(&thr... | 0 |
#include <pthread.h>
int counter = 0;
int readcounter = 0;
int reads = 0, writes = 0;
int maxcounter = 12;
pthread_mutex_t counter_mutex;
pthread_mutex_t write_mutex;
pthread_cond_t counter_cond;
void *write_counter(void *p) {
long id = (long)p;
int i = 20;
while (i --> 0) {
pthread_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int i = 1;
void *thread2(void *junk)
{
pthread_mutex_lock(&mutex);
printf("---------------------------------\\n");
printf("thread2: id %lu\\n", pthread_self());
printf("t... | 0 |
#include <pthread.h>
pthread_mutex_t verrou = PTHREAD_MUTEX_INITIALIZER;
struct data {
int IMAGE[10];
int QuelThreadTravail[10];
}data;
void * Fonction1(void *par){
int ma_fonction_numero = 1;
struct data *mon_D1 = (struct data*)par;
pthread_t moi=pthread_self();
printf("Je s... | 1 |
#include <pthread.h>
pthread_mutex_t a;
pthread_cond_t dispo, piece;
int place=5;
void* machineA()
{
while (1) {
pthread_mutex_lock(&a);
printf("Machine A crée une pièce.\\n");
while (place==0) {
printf("Le panier est plein...\\n");
pthread_cond_wait(&dispo, &a);
}
printf("Mach... | 0 |
#include <pthread.h>
int numOfPassengersOnBus;
void* print_message(void* ptr);
pthread_mutex_t verrou;
int main(int argc, char* argv[])
{
pthread_t tProducer, tConsumer1, tConsumer2;
const char* msg1 = "Producer";
const char* msg2 = "Consumer A";
numOfPassengersOnBus = 0;
pthread_mutex... | 1 |
#include <pthread.h>
{
int global;
pthread_mutex_t glock;
int locals[4];
pthread_mutex_t llocks[4];
int threshold;
} counter_t;
counter_t *c;
void init(counter_t *c, int threshold)
{
c->threshold = threshold;
c->global = 0;
pthread_mutex_init(&c->glock, 0);
... | 0 |
#include <pthread.h>
static pthread_mutex_t pthread_file_locks[OPEN_MAX] =
{ PTHREAD_MUTEX_INITIALIZER };
static inline pthread_mutex_t * pthread_fd_lock(int fd)
{
pthread_mutex_t * m = &pthread_file_locks[fd];
m->m_kind = PTHREAD_MUTEX_RECURSIVE_NP;
return m;
}
void flockfile(FILE *st... | 1 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo *
foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) == 0... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void *
threadA(void *param )
{
int i;
for (i = 0; i < 5; i++) {
pthread_mutex_lock(&mutex1);
printf("threadA --> %d iteration\\n", i);
sleep(rand() % 3);... | 1 |
#include <pthread.h>
int calcSunriseSunset(double lat, double lon, int day, int month, int year, double zenith, int localOffset, double *riseTime, double *setTime) {
int retVal=SUN_RISES_AND_SETS;
lon=-lon;
double N=floor(275*month/9)-(floor((month+9)/12)*(1+floor((year-4*floor(year/4)+2)/... | 0 |
#include <pthread.h>
void *sum(void *p);
unsigned long int psum[8];
unsigned long int sumtotal = 0;
unsigned long int n;
int numthreads;
pthread_mutex_t mutex;
int main(int argc, char **argv) {
pthread_t tid[8];
int i, myid[8];
struct timeval start, end;
gettimeofday(&start, 0);
scanf... | 1 |
#include <pthread.h>
int voti[2];
char film[2][40];
int pareri;
pthread_mutex_t m;
} sondaggio;
sondaggio S;
void init(sondaggio *s) {
int i;
s->pareri=0;
for(i=0;i<2; i++)
{ printf("Qual è il nome del film numero %d ?", i+1);
gets(s->film[i]);
s->voti[i]=0;
}
pthread_mutex_init(&s... | 0 |
#include <pthread.h>
int buff[10];
int buff_index;
pthread_mutex_t buff_mutex;
pthread_cond_t buff_cond_full, buff_cond_empty;
int push_front(int val)
{
if(buff_index < 10) {
buff[buff_index++] = val;
return 0;
} else
return -1;
}
int pop_front()
{
if(buff_index > 0)
return buff[--b... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_key_t key;
pthread_once_t once = PTHREAD_ONCE_INIT;
void key_create(void)
{
pthread_key_create(&key, free);
}
char * mygetenv(char *name)
{
int i;
char *ptr;
char *buf = 0;
... | 0 |
#include <pthread.h>
int food = 10;
int portions = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_cooker = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_cannibal = PTHREAD_COND_INITIALIZER;
void * cooker (void * arg);
void * cannibals (void * arg);
int main (int ar... | 1 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main()
{
int res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if (res != 0) {
perror("Mutex initi... | 0 |
#include <pthread.h>
static const char SINGLENODE_CLVMD_SOCKNAME[] = "\\0singlenode_clvmd";
static int listen_fd = -1;
static int init_comms()
{
struct sockaddr_un addr;
listen_fd = socket(PF_UNIX, SOCK_STREAM, 0);
if (listen_fd < 0) {
DEBUGLOG("Can't create local socket: %s\\n", strerror... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char buf[10][1024];
int in;
int out;
int size;
char* element[10];
}Ring_st;
void QueueInit(Ring_st * ring)
{
int i;
ring->in = 0;
ring->out = 0;
ring->size = 10;
for(i=0;i<10;i++)
ring->element[i] = buf[i];... | 0 |
#include <pthread.h>
pthread_mutex_t messageMutex = PTHREAD_MUTEX_INITIALIZER;
char * msgSend, * msgRcv;
char beaconsLocation[NUMBER_BEACONS][20];
void initBeaconsLocation(char beacon[NUMBER_BEACONS][20], int size) {
float margin = 1.1;
sprintf(beacon[0], "%.2f %.2f ", margin, ma... | 1 |
#include <pthread.h>
pthread_mutex_t bookLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t rwCondition = PTHREAD_COND_INITIALIZER;
int buffer[5] = {1,2,3,4,5};
int writing = 0;
int reading = 0;
int writers = 0;
void *reader(void *param) {
int id = (int) param;
pthread_mutex_lock(&bookLock... | 0 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
int isGreen1 (int s) {
return s == 0;
}
int isOrange1(int s) {
return s == 1;
}
int isRed1(int s) {
return s == 2;
}
void * signal1(void* d) {
int status = ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1,mutex2,mutex3,mutex4,mutex5;
void *thr_fn1(void *arg);
void *thr_fn2(void *arg);
void *thr_fn3(void *arg);
void *thr_fn4(void *arg);
void *thr_fn5(void *arg);
int main(void)
{
pthread_t tid1,tid2,tid3,tid4,tid5;
pthread_mutex_init(&mutex1,0);
pthr... | 0 |
#include <pthread.h>
int data = 0;
pthread_cond_t c_par;
pthread_cond_t c_impar;
pthread_mutex_t senial;
void *Par(void *arg);
void *Impar(void *arg);
int main(){
pthread_t par, impar;
pthread_mutex_init(&senial, 0);
pthread_cond_init(&c_par, 0);
pthread_cond_init(&c_impar, 0);
pth... | 1 |
#include <pthread.h>
pthread_mutex_t mut_num;
pthread_mutex_t mut_file;
sem_t sem;
int number=1;
int i=1;
void read_data1(void)
{
int fd,fd2;
char name[10];
char buf[100];
size_t size=0;
int j=0;
while(1)
{
pthread_mutex_lock(&mut_num);
if(number > 10)
{
pthread_mutex_unlock(... | 0 |
#include <pthread.h>
int n, *array;
pthread_mutex_t array_mutex = PTHREAD_MUTEX_INITIALIZER;
void *func(void *arg)
{
int thread_number = *((int *)arg), i, j;
for (i = 0; i < n; i++)
{
int index_of_min = i;
for (j = i; j < n; j++)
{
if (array[index... | 1 |
#include <pthread.h>
int num_philosophers;
pthread_mutex_t stdout_mutex;
pthread_mutex_t random_mutex;
pthread_mutex_t *fork_mutex;
pthread_t *philosophers;
void *
xmalloc (size_t n)
{
void *p = malloc (n);
if (! p)
{
fprintf (stderr, "out of memory\\n");
exi... | 0 |
#include <pthread.h>
int buffer[20 +1];
int slot;
pthread_t producers[10 +1];
pthread_t consumers[7 +1];
pthread_mutex_t mutex;
sem_t full;
sem_t empty;
void* produce(void* x) {
int *y = (int*)x;
int p = *y + 1;
while (1) {
sem_wait(&empty);
pthread_mutex_lock(&mutex);
slot++;
p... | 1 |
#include <pthread.h>
double **doubleVettToVerticalMatrix(double *vett, int dim);
double **doubleMatrixTranspone(double **mat, int m, int n);
void doubleMatrixPrint(double **mat, int m, int n);
double *v1, *v2, *v;
double **mat, **m1, **m1t, **m2;
double result;
int k;
int n_thread_l... | 0 |
#include <pthread.h>
int allocated = 0;
int bitmap_size;
int free_num;
int units_num;
char* bitmap_ptr;
void* alloc_ptr;
int
Mem_Init(int sizeOfRegion){
int pagesize = getpagesize();
int initsize = sizeOfRegion;
if(allocated != 0 || sizeOfRegion <= 0){
fprintf(stderr, "ERROR!\\n");
return ... | 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 *incrementer(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>
volatile double pi = 0.0;
pthread_mutex_t pi_lock;
volatile double intervals;
void * process(void *arg)
{
register double width, localsum;
register int i;
register int iproc = (*((char *) arg) - '0');
width = 1.0 / intervals;
localsum = 0;
for (i=iproc; i<inter... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_num = PTHREAD_COND_INITIALIZER;
static void *thr_primer(void *p);
int main()
{
int i,err;
pthread_t tid[3];
for(i = 0; i < 3; i++)
{
err = pthread_create(ti... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2=PTHREAD_MUTEX_INITIALIZER;
int px=1,py=2;
void* thread1(void* arg)
{
int i;
for(i=0;i<10;i++)
{
sleep(1);
pthread_mutex_lock(&mutex1);
printf("thread1:the value of px is %d\\n",px);
pthr... | 1 |
#include <pthread.h>
pthread_t tid[5];
int counter;
pthread_mutex_t lock;
pthread_cond_t cond;
int work=0;
void* doSomeThing(void *arg)
{
int who,tmp;
int i = 0,j;
counter += 1;
who = counter;
printf("\\n Job %d created\\n", who);
for(j=0;j<5;j++){
pthread_mutex_lock(&lock);
while(!... | 0 |
#include <pthread.h>
static struct sigaction sact[32];
static unsigned int jvmsigs = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_t tid = 0;
static signal_t os_signal = 0;
static sigaction_t os_sigaction = 0;
... | 1 |
#include <pthread.h>
struct timeval begin_time;
long int late = 0;
long int done = 0;
pthread_mutex_t lock;
long int temp[128];
struct setting setting;
struct record records[MAXREC];
void *context;
void trace_replay(void *arg)
{
struct req_data req_data;
struct timeval end_time, result_ti... | 0 |
#include <pthread.h>
static int running = 1;
static pthread_mutex_t running_lock;
static int initialized = 0;
static pthread_t thread;
static void* query_running_thread() {
while( initialized ) {
FILE* bspcfp;
char output[128];
bspcfp = popen("bspc query 2>&1", "... | 1 |
#include <pthread.h>
extern char **environ;
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);
pthrea... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int matriz[100][10];
void imprime_matriz(){
int i, j;
for(i=0;i<100;i++){
for(j=0;j<10;j++){
printf("%d\\t", matriz[i][j]);
}
printf("\\n\\n");
}
}
void* inicializa_matriz(void *p){
int i, col;
col = (int)(size_t)p;
pthread_mutex_loc... | 1 |
#include <pthread.h>
pthread_mutex_t head_p_mutex;
struct list_node_s* lista = 0;
pthread_mutex_t list_mutex;
pthread_rwlock_t rwlock;
struct list_node_s{
int data;
struct list_node_s* next;
pthread_mutex_t mutex;
};
int Member(int value, struct list_node_s* head_p){
struct list_node_s* cu... | 0 |
#include <pthread.h>
int run_thread_a = 1;
pthread_mutex_t run_lock_a = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t run_cond_a = PTHREAD_COND_INITIALIZER;
int run_thread_b = 0;
pthread_mutex_t run_lock_b = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t run_cond_b = PTHREAD_COND_INITIALIZER;
void *a(voi... | 1 |
#include <pthread.h>
extern char **environ;
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);
pthre... | 0 |
#include <pthread.h>
pthread_t Thread_set;
pthread_t Thread_get;
pthread_t timeout;
pthread_attr_t schedAttr_set;
pthread_attr_t schedAttr_get;
pthread_attr_t schedAttr_time;
struct sched_param set_param;
struct sched_param get_param;
struct sched_param time_param;
pthread_mutex_t mutexL... | 1 |
#include <pthread.h>
struct propset {
char * str;
int row;
int delay;
int dir;
};
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
int main(int ac, char * av[])
{
int c;
pthread_t thrds[10];
struct propset props[10];
void *animate();
int num_msg;
int i;
... | 0 |
#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) {
... | 1 |
#include <pthread.h>
int *buffer;
struct timeval t_a, t_b, t_c;
double ta;
double tb;
double tc;
int N;
int B;
int P;
int C;
pthread_mutex_t mutex;
sem_t emptyBuf;
sem_t fullBuf;
int head = 0;
int tail = 0;
int special_flag = 0;
int* consumer_array;
void *producer(void *param)
{
int i = 0;... | 0 |
#include <pthread.h>
static void *handle_case(size_t num, size_t nsize)
{
size_t size;
void *ret;
if (!num || !nsize)
return (0);
size = num * nsize;
if (nsize != size / num)
return (0);
ret = malloc(size);
if (!ret)
return (0);
ft_memset(ret, 0, size);
return (ret);
}
void *callo... | 1 |
#include <pthread.h>
static struct termios old, new;
static struct termios g_old_kbd_mode;
static char *device = "default";
float buffer_null[1024];
int main(void)
{
int err;
int j,k;
num_det = 0;
send = 0;
Fs = 44100;
durationdefaultsize = 0;
mode = 2;
num_jef[0... | 0 |
#include <pthread.h>
sem_t th1_sem;
sem_t th2_sem;
pthread_mutex_t rsrcA;
char filename[100];
FILE *fp;
pthread_t thread1;
pthread_t thread2;
int32_t linecount, wordcount, charcount;
void sighandler(int signum)
{
printf("Received signal %d\\n", signum);
if(signum == SIGUSR1)
{
... | 1 |
#include <pthread.h>
int i = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double x;
double y;
double z;
double acc;
double roll;
double pitch;
double yaw;
timespec_t time;
} attitude_t;
attitude_t attitude;
void *writer(void *ptr) {
pthread_mut... | 0 |
#include <pthread.h>
int typ;
int pocz;
int kon;
int numer;
} par_t;
volatile int running_threads = 0;
volatile int p_count = 0;
pthread_mutex_t primes_mutex = PTHREAD_MUTEX_INITIALIZER;
int pid;
int chid;
void *count_primes2(void *arg) {
int status;
int coid;
par_t reply;
coid = Connec... | 1 |
#include <pthread.h>
static volatile sig_atomic_t iSig_quit;
static volatile sig_atomic_t iSig_stats;
static FILE* fout = 0;
static void close_file(void* f)
{
fclose((FILE*)f);
}
static void* print_stats(void* arg)
{
pthread_detach(pthread_self());
ER_PTH(pthread_mutex_lock, &rep.mtx... | 0 |
#include <pthread.h>
pthread_t *threads;
pthread_mutex_t mutex_variable;
int nb_readers;
sem_t sem_writers;
}struct_priority_reader;
void init_priority_reader(struct_priority_reader *struct_priority)
{
sem_init(&(struct_priority->sem_writers), 0, 1);
pthread_mutex_init(&(struc... | 1 |
#include <pthread.h>
int mojazmiennaglobalna;
pthread_mutex_t mojmuteks=PTHREAD_MUTEX_INITIALIZER;
void *Hello(void *arg) {
int i,j;
for ( i=0; i<20; i++ ) {
pthread_mutex_lock(&mojmuteks);
j=mojazmiennaglobalna;
j=j+1;
printf(".");
f... | 0 |
#include <pthread.h>
void *req_handler(void *);
void *pro_handler(void *);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int n;
char buffer[256];
char record[50][3][20],temp[50][3][20],result[50][3][20];
char services[25][50] = {
"AddTwoNumbers","SubtractTwoNumbers","MultiplyTwoNumbers","... | 1 |
#include <pthread.h>
pthread_mutex_t mutexsum;
int *a, *b;
long sum=0.0;
void* dotprod(void* arg){
int i, start, end, offset, len;
long tid;
tid = (long)arg;
offset = tid;
len = 100000;
start = offset*len;
end = start + len;
printf("thread: %ld starting. start=%d end=%d\\n",tid,s... | 0 |
#include <pthread.h>
int buffer[8];
int head = 0;
int tail = 0;
int num_elem = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * produtor(){
int i = 0;
while(i < 64){
sleep(1);
if(num_elem < 8){
pthread_mutex_lock(&mutex);
buffer[tail] = rand() % 64;
printf("Produtor... | 1 |
#include <pthread.h>
int *vet;
int left;
int right;
} mergeParamType;
int swapsCount;
int runningThreadsSorting;
pthread_mutex_t runningThreadsSortingME;
mergeParamType *params;
int nthreads;
sem_t sem1, sem2;
void inefficientSort(int *v, int dim);
void bubbleSort(mergeParamType *param... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.