text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int buffer[10];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;
pthread_cond_t empty, fill;
pthread_mutex_t mutex;
void put(int value) {
buffer[fill_ptr] = value;
fill_ptr = (fill_ptr + 1) % 10;
count++;
}
int get() {
int tmp = buffer[use_ptr];
use_p... | 1 |
#include <pthread.h>
void * threadPartialSum(void * args);
double globalSum;
int numberOfThreads;
long length;
float * myArray;
pthread_mutex_t updateSumLock;
int main(int argc, char* argv[]) {
long i;
pthread_t * threadHandles;
int errorCode;
double seqSum;
long startTime, endTime,... | 0 |
#include <pthread.h>
static int value = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int getValue()
{
pthread_mutex_lock(&mutex);
value++;
pthread_mutex_unlock(&mutex);
return value;
}
void *work_thread1(void *p)
{
struct timeval tv1, tv2;
gettimeofday(&tv1, 0);
printf... | 1 |
#include <pthread.h>
static pthread_mutex_t m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
char *ts="[??:??:??]";
struct tm * now;
time_t nw;
pthread_mutex_lock(&m_trace);
nw = time(0);
now = localt... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
extern int pid_map[350 -300];
int last;
int allocate_map(void)
{
int i;
for(i = 300; i<350; i++)
{
pid_map[i-300] = 0;
}
if(pid_map[0] != 0)
{
return -1;
}
return 1;
}
int allocate_pid(void)
{
int i;
for(i = 300;i<3... | 1 |
#include <pthread.h>
struct lectred {
pthread_mutex_t mutex;
int nb_l;
int nb_w;
struct list * first;
struct list * last;
};
struct list {
pthread_cond_t * ma_cond;
int est_lect;
struct list * suivant;
};
struct lectred* lectred_init() {
struct lectred * lectred = malloc(sizeof(struct l... | 0 |
#include <pthread.h>
extern struct __pthread *__pthread_free_threads;
extern pthread_mutex_t __pthread_free_threads_lock;
void
__pthread_dealloc (struct __pthread *pthread)
{
assert (pthread->state != PTHREAD_TERMINATED);
if (! __atomic_dec_and_test (&pthread->nr_refs))
return;
... | 1 |
#include <pthread.h>
long start, end;
void *async_event_server(void *arg);
void *handler1(void *arg);
void usage(void)
{
rt_help();
printf("async_handler_jk specific options:\\n");
}
int parse_args(int c, char *v)
{
int handled = 1;
switch (c) {
case 'h':
usage();
exit(0);
... | 0 |
#include <pthread.h>
struct s_word_object{
char *word;
word_object *next;
};
static word_object *list_head;
static pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t list_data_ready = PTHREAD_COND_INITIALIZER;
static pthread_cond_t list_data_flush = PTHREAD_COND_INIT... | 1 |
#include <pthread.h>
static int myFd ;
static int __spiChannel=0;
static pthread_mutex_t mutexMCP;
int channelConfig=8;
void mcp3008Setup(int spiChannel)
{
printf("INIT MCP3008\\n");
if ((myFd = wiringPiSPISetup (spiChannel, 1000000)) < 0)
{
fprintf (stderr, "Can't open t... | 0 |
#include <pthread.h>
FILE *file;
int size,chars_per_thread, current_location, current_word, current_char;
char **words;
int *count;
pthread_mutex_t mutex;
} word_counter;
void *count_words(void* a)
{
word_counter* counter = a;
pthread_mutex_lock(&counter->mutex);
int found_word = 0,... | 1 |
#include <pthread.h>
const int MAX_KEY = 100000000;
struct list_node_s {
int data;
struct list_node_s* next;
};
struct list_node_s* head = 0;
int num_hilos;
int total_ops;
double insert_percent;
double search_percent;
double delete_percent;
pthread_mutex_t mutex;
pthread_mutex_t count_mute... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
static int count = 0;
void *test_func(void *arg)
{
int i = 0;
for(i = 0; i < 2000000; i++)
{
pthread_mutex_lock(&mutex_lock);
count++;
pthread_mutex_unlock(&mutex_lock);
... | 1 |
#include <pthread.h>
enum { MAX_THREADS = 3 };
enum { MAX_CYCLES = 5 };
enum { T_UNSTARTED, T_RUNNING, T_FINISHED, T_JOINED };
static int n_threads = MAX_THREADS;
static int n_cycles = MAX_CYCLES;
static pthread_mutex_t mtx_waiting = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cnd_waiting = ... | 0 |
#include <pthread.h>
int num_iteraciones;
int max_bucket;
int count_bucket;
pthread_mutex_t lock;
pthread_cond_t bearAsleep, bearAwake;
void startProduce(){
pthread_mutex_lock(&lock);
while(count_bucket==count_bucket){
pthread_cond_wait(&bearAsleep,&lock);
}
++count_bucket;
pthread_mute... | 1 |
#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... | 0 |
#include <pthread.h>
const int mul_a[8] = {2769, 4587, 8761, 9031, 6743, 7717, 9913, 8737};
const int add_b[8] = {767, 1657, 4057, 8111, 11149, 11027, 9901, 6379};
void *bloomThread(void *args)
{
struct sharedData* sd = (struct sharedData *)args;
int tid = sd->threadid;
struct Bloom* blo... | 1 |
#include <pthread.h>
int kuz;
pthread_mutex_t zain = PTHREAD_MUTEX_INITIALIZER;
void* suma(void*arg)
{
for(int i=0;i<10000;++i)
{
pthread_mutex_lock(&zain);
kuz= kuz +1;
pthread_mutex_unlock(&zain);
}
pthread_exit(0);
}
void*... | 0 |
#include <pthread.h>
static short LOCK_INIT = 0;
static pthread_mutex_t lock;
static void init_serial_lock()
{
if (pthread_mutex_init(&lock, 0) != 0)
{
LOGGER(LOG_CRIT,"\\n mutex init failed\\n");
}
else
LOCK_INIT = 1;
}
void destroy_serial_lock()
{
if (pthread_mutex_destroy(&... | 1 |
#include <pthread.h>
int buffer[2];
int size;
int error;
pthread_mutex_t lock;
pthread_t threads[1 + 1];
void * produce (void *arg) {
int i;
for(i = 0; i < 5; i++) {
pthread_mutex_lock(&lock);
size++;
pthread_mutex_unlock(&lock);
}
return 0;
}
void * consume (void *arg) {
int i... | 0 |
#include <pthread.h>
sem_t full;
sem_t empty;
pthread_mutex_t m;
int buf[10]={0};
int n=0;
int print()
{
int i;
for(i=0;i<10;i++)
printf("%d ",buf[i]);
printf("\\n");
return 0;
}
void *producter(void* p)
{
int i;
for(i=0;i<20;i++)
{
sem_wait(&empty);
pthread_mutex_lock(&m);
buf[n++]=... | 1 |
#include <pthread.h>
static pthread_mutex_t globalmutex=PTHREAD_MUTEX_INITIALIZER;
static _getenvType __getenv=0;
static void __loadsymbol(void)
{
const char *err=0;
pthread_mutex_lock(&globalmutex);
if(__getenv) {pthread_mutex_unlock(&globalmutex); return;}
dlerror();
__getenv=(_getenvTy... | 0 |
#include <pthread.h>
int memory[(2*960+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*960+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx =... | 1 |
#include <pthread.h>
int pega_talheres(int id, int num_esquerdo, int num_direito);
void devolve_talheres(int num_esquerdo, int num_direito);
void pega_token();
void devolve_token();
void *filosofo(void *num);
int NUM_FILOSOFOS;
unsigned TMP_COMENDO;
unsigned TMP_PENSANDO;
int NUM_TOKENS;
in... | 0 |
#include <pthread.h>
pthread_mutex_t request_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_cond_t got_job_request = PTHREAD_COND_INITIALIZER;
int num_requests = 0;
int done_creating_jobRequests = 0;
struct arg_structure
{
int arg1;
int arg2;
};
struct Job
{
i... | 1 |
#include <pthread.h>
int N_MAX = 10e7;
int N_THREADS = 4;
int count = 0;
pthread_mutex_t mutex;
void *Average(void *param) {
double mean = 0;
double *ret = malloc(sizeof(double *));
assert(ret);
double *roots = *((double**) param);
long step = N_MAX / N_THREADS;
pthread_mutex_lock(&mu... | 0 |
#include <pthread.h>
pthread_mutex_t m;
void *odd(void *max)
{
int i;
FILE *fd;
struct timeval tp;
fd = fopen("odd_num", "w");
for (i = 1; i < *(int*)max; i+= 2)
fprintf(fd, "%d\\n", i);
pthread_mutex_lock(&m);
for (i = 0; i < 10000; i++)
printf("odd\\n");
pthread_mut... | 1 |
#include <pthread.h>
pthread_mutex_t mutex =PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condizione =PTHREAD_MUTEX_INITIALIZER;
int n=0;
int *a;
float media;
int i=0;
int flag =0;
void *funzione(void*para){
while (i<n){
pthread_mutex_lock(&mutex);
media += a[i];
i++;
pthread_mutex_unlock(&mutex);
}
f... | 0 |
#include <pthread.h>
struct wonk{
int a;
} *shrdPtr;
pthread_mutex_t lock;
struct wonk *getNewVal(struct wonk**old){
*old = 0;
struct wonk *newval = (struct wonk*)malloc(sizeof(struct wonk));
newval->a = 1;
return newval;
}
void *updaterThread(void *arg){
int i;
... | 1 |
#include <pthread.h>
pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
int cont = 1;
void* helper(void* v_bar) {
pthread_barrier_t* bar = (pthread_barrier_t*)v_bar;
register int* i = malloc(sizeof(*i));
*i = 3;
pthread_barrier_wait(bar);
pthread_mutex_lock(&mu);
while (cont) {
... | 0 |
#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)
{... | 1 |
#include <pthread.h>
struct heap_block {
void *ptr;
size_t size;
};
struct heap_global {
int initialized;
unsigned int block_count;
unsigned int block_count_size;
pthread_mutex_t mutex;
struct heap_block *blocks;
unsigned int blocks_array_size;
};
static struct heap_global heap_globa... | 0 |
#include <pthread.h>
static pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
static int waiting;
static void cleanup(void *p)
{
waiting = 0;
pthread_cond_signal(&cv);
pthread_mutex_unlock(&mx);
}
static void *waiter(void *p)
{
pthread_m... | 1 |
#include <pthread.h>
int ticket_no = 1001;
sem_t ticket_counter;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* ticket_buy(){
pthread_mutex_lock(&mutex);
if(sem_trywait(&ticket_counter) == 0){
printf("This customer has bought ticket %d\\n", ticket_no++);
}
else{
printf("This cus... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int32_t x = 0, y = 0;
void* fast_thread1()
{
pthread_mutex_lock(&lock);
for (uint32_t j = 0; j < 1000000; j++) {
x++;
}
pthread_mutex_unlock(&lock);
return 0;
}
void* fast_thread2()
{
pthread_mutex_lock(&lock);
fo... | 1 |
#include <pthread.h>
void *controlLED(void *p);
void *inputRead(void *p);
pthread_mutex_t lock;
int led_state[4];
uint8_t led_pins[4]={RPI_GPIO_P1_11, RPI_GPIO_P1_12, RPI_V2_GPIO_P1_13, RPI_GPIO_P1_15},
sw_pins[4]={RPI_GPIO_P1_16, RPI_GPIO_P1_18, RPI_GPIO_P1_22, RPI_V2_GPIO_P1_29};
int... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
static void *pthread_func_1(void *);
static void *pthread_func_2(void *);
int main(int argc,char **argv)
{
pthread_t pt_1=0;
pthread_t pt_2=0;
pthread_attr_t attr={0};
int ret=0;
pthread_mutex_init(&mutex,0);
pthread_cond_in... | 1 |
#include <pthread.h>
void * handle_clnt(void * arg);
void send_msg(char * msg, int len);
void error_handling(char * msg);
int clnt_cnt=0;
int clnt_socks[256];
pthread_mutex_t mutx;
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
int clnt_... | 0 |
#include <pthread.h>
int nextCustomerNo=1;
int f=0,l=0;
int waitingCustomerCount=0;
int custNos[4];
pthread_mutex_t lck;
pthread_cond_t custCond[4];
pthread_cond_t brbrCond;
void wakeUpbarber()
{ pthread_cond_signal(&brbrCond);
}
void customerWait(int chair)
{ pthread_cond_wait(&custCond[chair],&l... | 1 |
#include <pthread.h>
pthread_t thread1, thread2;
pthread_mutex_t spi_read_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t spi_read_cond = PTHREAD_COND_INITIALIZER;
int exit_spi_read = 0;
int spi_read_loop = 0;
int spi_read_start_loop (int start){
int retval = 0;
if (start){
... | 0 |
#include <pthread.h>
int buffer[10];
int position_c = 0;
int position_p = 0;
pthread_mutex_t buf = PTHREAD_MUTEX_INITIALIZER;
sem_t empty;
sem_t full;
int produce_item(int id) {
time_t t;
srand((unsigned) time(&t));
return (rand() % 197) + id;
}
void insert_item(int item, int position) {... | 1 |
#include <pthread.h>
pthread_mutex_t forks[(5 -1)];
void eat(int philosopher)
{
printf("Philosopher %i has started eating! \\n", philosopher);
usleep(100);
printf("Philosopher %i has finished eating! \\n", philosopher);
}
void think(int philosopher)
{
printf("Philosopher %i is thinking sup... | 0 |
#include <pthread.h>
char *directory;
int totalSize=0;
pthread_mutex_t totalSizeMutex;
void *copyFile(void *filename)
{
struct stat buf;
int fd = open(filename,O_RDONLY);
fstat(fd, &buf);
int size = (int) buf.st_size;
close(fd);
pthread_mutex_lock(&totalSizeMut... | 1 |
#include <pthread.h>
int value;
struct elem *next;
}elem;
unsigned int sizeBuffer, statusBuffer;
elem *head,*last;
}blockingQueue;
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 11;
blockingQueue Q;
elem* newElem(){
return malloc(1*sizeof(elem));
}
void newBloc... | 0 |
#include <pthread.h>
pthread_mutex_t tenedor[5];
sem_t s;
void pensar(int i)
{
printf("Filosofo %d pensando...\\n",i);
usleep(random() % 1000000);
}
void comer(int i)
{
printf("Filosofo %d comiendo...\\n",i);
usleep(random() % 1000000);
}
void tomar_tenedores(int i)
{
pthread_mutex... | 1 |
#include <pthread.h>
int counter= 0;
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
void dawdle(int cnt) {
int i;
double dummy= 3.141;
for(i=0;i<cnt*10;i++) {
dummy= dummy*dummy/dummy;
}
sleep(1);
}
void *thread(void *args) {
int i,val;
int arg = *((int*)args);
for (... | 0 |
#include <pthread.h>
int unpipe_create(int size_log2) {
int id;
long pagesize;
struct unpipe_ctx *p;
pthread_mutexattr_t m_attr;
pthread_condattr_t c_attr_r;
pthread_condattr_t c_attr_w;
pagesize = sysconf(_SC_PAGESIZE);
assert(sizeof(struct unpipe_ctx *) < pagesize);
id =... | 1 |
#include <pthread.h>
pthread_mutex_t locki[32];
int inode[32];
pthread_mutex_t lockb[26];
int busy[26];
void *thread_routine (void *arg)
{
int b;
long tid = (long) arg;
int i = tid % 32;
printf ("t%ld: starting, inode %d\\n", tid, i);
pthread_mutex_lock (&locki[i]);
if (inode[i] ==... | 0 |
#include <pthread.h>
void gw_dm_zombie ( void *_job_id )
{
gw_job_t * job;
gw_array_t * array;
int job_id;
int task_id;
int array_id;
int rt;
char conf_filename[2048];
if ( _job_id != 0 )
{
job_id = *( (int *) _job_id );
job = gw_job_pool_get... | 1 |
#include <pthread.h>
struct module_tick *module_tick_create(struct module_tick_master *master, struct module_base *base, float interval, unsigned long flags)
{
struct module_tick *new = malloc(sizeof(*new));
assert(new);
fprintf(stderr, "createing tick: %p, master %p, interval %f\\n", ... | 0 |
#include <pthread.h>
sem_t barber,customer;
pthread_mutex_t mutex;
int waiting=0;
int count=0;
void* barber1(void* param){
while(1){
sem_wait(&customer);
pthread_mutex_lock(&mutex);
sleep(2);
waiting=waiting-1;
sem_post(&barber);
pthread_mutex_unlock(&mutex);
printf("Cut Hair");
count++;... | 1 |
#include <pthread.h>
int num_threads;
pthread_mutex_t *mutexes;
pthread_mutex_t *share_p;
none,
one,
two
} utensil;
int phil_num;
int course;
utensil forks;
}phil_data;
phil_data *philosophers;
void shared_print(int id){
pthread_mutex_lock(&share_p[id]);
printf("No.%d Philosophe... | 0 |
#include <pthread.h>
int shared_data = 1;
int read_count = 0, write_count = 0;
pthread_mutex_t mutex_write_count,mutex_read_count,mutex_write,mutex_read;
sem_t read_ready;
void initialize()
{
pthread_mutex_init(&mutex_write,0);
pthread_mutex_init(&mutex_write_count,0);
pthread_mut... | 1 |
#include <pthread.h>
void print(char *v){
puts(v);
}
char *t;
char *p;
int start_t;
int stop_t;
int start_p;
int stop_p;
int thread_id;
int padding;
short *found_pos;
pthread_mutex_t *mutex;
}params;
int how_many_positions(char *p, char searched, int pattern_size){
int nr_pos=0;
... | 0 |
#include <pthread.h>
int avail = 2;
int happy_ind = 1;
int total_happy = 0;
pthread_mutex_t mutex_avail;
enum { h_unknown = 0, h_yes, h_no };
unsigned char buf[256] = {0, h_yes, 0};
struct th_data {
pthread_t pid;
int thread_num;
int maxnum;
int i;
int *bit_pointer;
};
struct happy_data {... | 1 |
#include <pthread.h>
static pthread_once_t g_init = PTHREAD_ONCE_INIT;
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
void init_g_lock(void)
{
pthread_mutex_init(&g_lock, 0);
}
void *input_onoff(void *arg) {
char buf[80];
int len;
char *onoff=(char*) arg;
ch... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int cnt;
void espera_activa( int tiempo) {
time_t t;
t = time(0) + tiempo;
while(time(0) < t);
}
void *tareaA( void * args) {
printf("tareaA::voy a dormir\\n");
sleep(3);
printf("tareaA::me despierto y pillo mutex\\n");
pthread_mutex_lo... | 1 |
#include <pthread.h>
pthread_t t[100];
pthread_mutex_t m[100];
void* Do_Stuff(void *ptr){
int id = *(int*)ptr;
free(ptr);
printf("The thread %d started\\n", id);
pthread_mutex_lock(m + id);
while(1){
printf("Give no:");
int nr;
scanf("%d", &nr);
if(no >= 0 && nr < n);
if(pthread_mu... | 0 |
#include <pthread.h>
sem_t male, female;
pthread_cond_t vacio;
pthread_mutex_t candado;
int variable;
int valueHombre, valueMujer;
void* hombre(void* args);
void* mujer(void* args);
int main(int argc, char* argv[]){
if(argc!=2){
printf("ERROR de argumentos. <%s> <numero de hebras>\\n",argv... | 1 |
#include <pthread.h>
char buffer[9][18] = { 0 };
int start = 0;
int end = 0;
int size = 0;
FILE *in;
FILE *out;
pthread_t producer;
pthread_t consumer;
pthread_mutex_t buf_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t empty_slot = PTHREAD_COND_INITIALIZER;
pthread_cond_t item_avai... | 0 |
#include <pthread.h>
int chopstick[5] = {0,0,0,0,0};
int state[5];
pthread_cond_t chopstic_cond[5] = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
void pick_chopstick(int id)
{
pthread_mutex_lock(&mutex_lock);
sleep(1);
if(state[id] == 1 && chopstic... | 1 |
#include <pthread.h>
char* buf[5];
int pos;
pthread_mutex_t mutex;
void* task(void* p)
{
pthread_mutex_lock(&mutex);
buf[pos] = p;
sleep(1);
pos++;
pthread_mutex_unlock(&mutex);
}
int main(void)
{
pthread_mutex_init(&mutex,0);
pthread_t tid,tid2;
pthread_create(&tid,0,task,"zha... | 0 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t lock;
void thread1(void *arg);
void thread2(void *arg);
int main(int argc, char * argv[])
{
pthread_t id1, id2;
if(pthread_mutex_init(&lock, 0) != 0){
printf("mutex init failed.\\n");
exit(1);
}
pthread_create(&id1, 0, (void *) thre... | 1 |
#include <pthread.h>
int ticketcount;
pthread_mutex_t lock;
pthread_cond_t cond1,cond2;
}NODE,*pNODE;
void* sale(void* arg)
{
pNODE p = (pNODE)arg;
while(1){
pthread_mutex_lock(&p->lock);
while(p->ticketcount <= 0)
{
pthread_cond_signal(&p->cond2);
pthread_cond_wait(&p->cond1,... | 0 |
#include <pthread.h>
void *handler ( void *ptr );
static pthread_mutex_t mutex ;
int counter;
int main()
{
int cnt;
int i[4];
pthread_t threads[4];
for (cnt = 0; cnt < 4; cnt++){
i[cnt] = cnt;
}
if (pthread_mutex_init(&mutex, 0)){
printf("ERROR on INIT ... | 1 |
#include <pthread.h>
sem_t estudante;
sem_t monitor;
pthread_mutex_t mutex;
int cadeira[4];
int count = 0;
int proxAcento = 0;
int proxEnsinar = 0;
void dormirAleatorio();
void *jogando(void* stu_id);
void *monitorEnsinado();
int main(int argc, char **argv){
pthread_t *estudantes;
... | 0 |
#include <pthread.h>
int thread_flag;
pthread_cond_t thread_flag_cv;
pthread_mutex_t thread_flag_mutex;
void initialize_flag() {
pthread_mutex_init(&thread_flag_mutex, 0);
pthread_cond_init(&thread_flag_cv, 0);
thread_flag = 0;
}
void do_work(){
printf(" [_work_] | doing work now ... \\n"... | 1 |
#include <pthread.h>
int array[3] ={0,0,0};
pthread_mutex_t mutex;
pthread_cond_t cond;
int count;
} semaphore_t;
void init_sem(semaphore_t *s, int i)
{
s->count = i;
pthread_mutex_init(&(s->mutex), 0);
pthread_cond_init(&(s->cond), 0);
}
void P(semaphore_t *sem)
... | 0 |
#include <pthread.h>
pthread_mutex_t turno = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t bd = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int rc = 0;
void * ler(void * arg){
int i = *((int*) arg);
while(1){
pthread_mutex_lock(&turno);
... | 1 |
#include <pthread.h>
pthread_cond_t myCond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t myLock = PTHREAD_MUTEX_INITIALIZER;
{
int _data;
struct ListNode* _next;
}Node,*pNode,**ppNode;
pNode AllocNode(int data)
{
pNode NewNode = (pNode)malloc(sizeof(Node));
if(NewNode == 0)
{
perror("malloc... | 0 |
#include <pthread.h>
struct data {
long counter[256];
};
const int SIZE = sizeof(struct data);
static pthread_mutex_t mutex_arr[256];
static pthread_mutex_t output_mutex;
static struct data data;
void handle_error(long return_code, const char *msg, int in_thread) {
if (return_code <... | 1 |
#include <pthread.h>
pthread_mutex_t m;
struct ThreadPool pool;
int *ptr;
size_t num;
int depth;
} args_t;
struct Task **array;
size_t size;
size_t capacity;
} tarray_t;
void add_task_array(tarray_t *t, struct Task *task) {
if (t->size == t->capacity) {
t->capacity *= 2;
t->array =... | 0 |
#include <pthread.h>
void printClinicalHistory(int index, int clientfd, int r){
pthread_mutex_lock(&lock);
sem_wait(semaforo);
read(pipefd[0], &witness, sizeof(char));
if(index < 0 || index >= dogAmount){
printf("\\nNumero de registro invalido");
fflush(stdout);
... | 1 |
#include <pthread.h>
static pthread_mutex_t trigger_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t trigger_bcast = PTHREAD_COND_INITIALIZER;
enum broadcast_t {STATUS, BLACKBOARD, CLEAR};
static int broadcast_type = STATUS;
void trigger_broadcast(int type) {
pthread_mutex_lock... | 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(void)
{
pthread_key_create(&key, free);
}
char *
getenv(const char *name)
{
int i, ... | 1 |
#include <pthread.h>
int buffer[8];
int head = 0;
int tail = 0;
int num_elem = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t production_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t consume_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t product = PTHREAD_COND_I... | 0 |
#include <pthread.h>
void* TA_Routine(void* arg);
void* Student_Routine(void* arg);
int student_id;
unsigned int seed;
} param;
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
void* TA_Routine(void* arg) {
unsigned int helping_time;
unsig... | 1 |
#include <pthread.h>
static void *(*mem_alloc)(const size_t) = &malloc;
static void (*mem_free)(void *) = &free;
void fcgi_context_module_init(void *(*mem_alloc_p)(const size_t),
void (*mem_free_p)(void *))
{
mem_alloc = mem_alloc_p;
mem_free = mem_free_p;
}
void fcgi_context_free(struct f... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
main()
{
pthread_t thread1, thre... | 1 |
#include <pthread.h>
struct sigwaiter *sigwaiters;
siginfo_t
sigwaiter_block (struct signal_state *ss, const sigset_t *restrict set)
{
assert (pthread_mutex_trylock (&sig_lock) == EBUSY);
assert (pthread_mutex_trylock (&ss->lock) == EBUSY);
assert (! ss->sigwaiter);
struct sigwaiter wa... | 0 |
#include <pthread.h>
struct bbsem {
pthread_mutex_t mutex;
pthread_cond_t is_nonzero;
int value;
};
struct bbsem *
bbseminit(int val)
{
struct bbsem *tmp;
tmp = malloc(sizeof(*tmp));
if (tmp == 0)
return(0);
pthread_cond_init(&tmp->is_nonzero, 0);
pthread_mutex_init(&tmp->mutex, 0);
tm... | 1 |
#include <pthread.h>
struct queue_root {
struct queue_head *in_queue;
struct queue_head *out_queue;
pthread_mutex_t lock;
};
struct queue_root *ALLOC_QUEUE_ROOT()
{
struct queue_root *root =
malloc(sizeof(struct queue_root));
pthread_mutex_init(&root->lock, 0);
root->i... | 0 |
#include <pthread.h>
int chopstick[5] = {0,0,0,0,0};
int state[5];
pthread_cond_t chopstic_cond[5] = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
void pick_chopstick(int id)
{
pthread_mutex_lock(&mutex_lock);
if(state[id] == 1 && chopstick[id]==0){
... | 1 |
#include <pthread.h>
void *Thread_IN(void *arg);
void *Thread_OUT(void *arg);
char thread1[]="Thread A";
char thread2[]="Thread B";
pthread_mutex_t mutx;
int counter = 0;
int queue = 0;
int main(int argc, char **argv)
{
pthread_t t1, t2;
void *thread_result;
int state;
state = pt... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void *thread1( void *arg ) {
pthread_cleanup_push( pthread_mutex_unlock, &mutex );
while ( 1 ) {
printf( "thread1 is running\\n" );
pthread_mutex_lock( &mutex );
pthread_cond_wait( &cond, &mutex );
... | 1 |
#include <pthread.h>
pthread_t tid[8];
pthread_mutex_t mutex;
struct padded_int
{
int value;
char padding[60];
} private_count[8];
int *array;
int length = 1000000000;
int count = 0;
int double_count = 0;
int t = 8;
int max_threads = 0;
void *count3s_thread(void *arg) {
int i;
struct ti... | 0 |
#include <pthread.h>
int Graph[105][105] ;
int dist[105][105] ;
void init_graph_matrix(int * , int *) ;
void print_dst(int) ;
pthread_mutex_t read_mutex ;
pthread_mutex_t write_mutex ;
int read_count ;
struct parameters{
int i ;
int k ;
int n ;
} ;
void * floyd_warshall(void * t){
s... | 1 |
#include <pthread.h>
pthread_mutex_t a;
pthread_mutex_t c;
pthread_mutex_t g;
pthread_mutex_t f;
int k;
int j;
void* fn1(void * args){
pthread_mutex_lock(&a);;
if( k == 25 ){
pthread_mutex_unlock(&f);;
} else {
pthread_mutex_lock(&c);;
}
pthread_mutex_lock(&g);;
if(j)
pr... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
double target;
void* opponent(void *arg)
{ int i;
for (i = 0; i < 10000; ++i)
{
pthread_mutex_lock(&mutex);
target -= target * 2 + tan(target);
pthread_mutex_unlock(&mutex);
}
return 0;
}
int main(int argc,... | 1 |
#include <pthread.h>
void* f1(void*);
void* f2(void*);
void* f3(void*);
void* f4(void*);
struct thread_data{
size_t last_thread_on_that_zone[10];
int picture[10];
pthread_mutex_t* mutex_data;
pthread_cond_t* vcond_data;
};
void init_thread_data(struct thread_data* p){
for(size_t... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
volatile int g=0;
void* setter(void* args)
{
pthread_mutex_lock(&mutex);
g = *(int*)args;
pthread_mutex_unlock(&mutex);
return 0;
}
void* t1(void* args)
{
pthread_t otherHandles[(2)];
int threadArgs[(2)];
size_t i;
for(i=0; i < ... | 1 |
#include <pthread.h>
void *slave(void *myid);
int data[1000];
int sum = 0;
pthread_mutex_t mutex;
int wsize;
void *slave(void *myid)
{
int i, low,high,myresult=0;
low = (int) myid * wsize;
high = low + wsize;
for(i =low;i<high;i++)
myresult += data[i];
pthread_mutex_lock(&mu... | 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(void)
{
pthread_key_create(&key, free);
}
char *
getenv(const char *name)
{
int i, len;
... | 1 |
#include <pthread.h>
struct prodcons {
int buffer[8];
pthread_mutex_t lock;
int readpos,writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct prodcons *b)
{
pthread_mutex_init(&b->lock,0);
pthread_cond_init(&b->notempty,0);
pthread_cond_init(&b->notfull,0);
... | 0 |
#include <pthread.h>
pthread_t *Students;
pthread_t TA;
int ChairsCount = 0;
int CurrentIndex = 0;
sem_t TA_Sleep;
sem_t Student_Sem;
sem_t ChairsSem[3];
pthread_mutex_t ChairAccess;
void *TA_Activity();
void *Student_Activity(void *threadID);
int main(int argc, char* argv[])
{
int number_o... | 1 |
#include <pthread.h>
pthread_mutex_t printf_mutex = PTHREAD_MUTEX_INITIALIZER;
void *print_function(void *arg)
{
char *p = arg;
int i;
for (i = 0; i < 10; i++)
{
pthread_mutex_lock(&printf_mutex);
display(p);
pthread_mutex_unlock(&printf_mutex);
sleep(1);
}
}
int m... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cond;
char str[100];
bool str_available;
void* producer(void* arg ) {
while (1) {
char buf[sizeof str];
fgets(buf, sizeof buf, stdin);
pthread_mutex_lock(&m);
strncpy(str, buf, sizeof str);
str_avai... | 1 |
#include <pthread.h>
pthread_mutex_t full,empty,acc;
int x=1;
int eflag=0,fflag=0;
int f=0,r=0,id=1;
int cnt=0;
int *q;
void* pro()
{ printf("producer started \\n");
while(1)
{ pthread_mutex_lock(&acc);
if(cnt==5)
{ printf("Producer waiting...\\n");
fflag=1;... | 0 |
#include <pthread.h>
struct data {
int IMAGE[100];
int DernierThreadSurLaZone[100];
pthread_mutex_t *verrou;
pthread_cond_t *condition;
}data;
void* Fonction1(void*);
void* Fonction2(void*);
void* Focntion3(void*);
void* Fonction4(void*);
void * Fonction1(void *par){
int ma_foncti... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc,condp;
int buffer=0;
int count=0;
void *producer(void *ptr)
{
while(count<=50)
{
pthread_mutex_lock(&the_mutex);
while(buffer>=10)pthread_cond_wait(&condp,&the_mutex);
buffer++;
printf("生产者生产了1件，当前缓冲区中有%d件\\n",buffe... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.