text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int balanco=10000;
pthread_t threads[3];
pthread_mutex_t mutex_balanco;
void *deposita(void *valor)
{
int *a= (int *) valor;
pthread_mutex_lock(&mutex_balanco);
balanco += *a;
pthread_mutex_unlock(&mutex_balanco);
pthread_exit(0);
}
void *levanta(vo... | 1 |
#include <pthread.h>
extern pthread_mutex_t global_data_mutex;
void init_wsi(int mem_fd) {
char memory[MEMSIZE];
int i;
read(mem_fd,memory,MEMSIZE);
memory[0x80] = READ_DATA_CMD;
memory[0x81] = READ_DATA_CMD;
memory[0x82] = DATA_END_BYTE;
lseek(mem_fd,0,0);
i = write(mem_fd,... | 0 |
#include <pthread.h>
int nitems=0;
unsigned int crcTable[256];
int BUFF_SIZE=0;
sem_t producer, consumer;
pthread_mutex_t mutex;
void *pro(void*);
void *con(void*);
unsigned int crc_computation(char*, int);
void crc_init(void);
int main(int argc, char *argv[]){
BUFF_SIZE=atoi(argv[1]);
pt... | 1 |
#include <pthread.h>
struct fork_t {
int num;
pthread_mutex_t mutex;
} fork_t;
fork_t fork_array[5] = {
{0, PTHREAD_MUTEX_INITIALIZER},
{1, PTHREAD_MUTEX_INITIALIZER},
{2, PTHREAD_MUTEX_INITIALIZER},
{3, PTHREAD_MUTEX_INITIALIZER},
{4, PTHREAD_MUTEX_INITIALIZER}
};
int eat_count[5];
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
void* thread_worker(void*);
void critical_section(int thread_num , int i);
int main(int argc , char* argv[])... | 1 |
#include <pthread.h>
int chopsticks[5];
int eat_time[5];
int think_time[5];
int block_time[5];
int block_start[5];
int stop;
unsigned int seed;
pthread_mutex_t aux_mutex;
void Init();
void Close();
void Philosopher(int);
void Think(int);
void Eat(int);
unsigned int random_time(void)... | 0 |
#include <pthread.h>
FILE *arq, *arqSaida;
int nThreads;
char* Buffer[5];
int count = 0, out = 0;
int fimDeArquivo = 0;
pthread_mutex_t mutex;
pthread_cond_t cond_cons, cond_prod;
void insereCaracteres(long int* cnt, char* s);
void merge(long int* a, long int* b);
void print(long int* c, FI... | 1 |
#include <pthread.h>
int array[4];
int array_index = 0;
pthread_mutex_t mutex;
void *thread(void * arg)
{
pthread_mutex_lock(&mutex);
array[array_index] = 1;
pthread_mutex_unlock(&mutex);
return 0;
}
int main()
{
int i, sum;
pthread_t t[4];
pthread_mutex_init(&mutex, ... | 0 |
#include <pthread.h>
pthread_mutex_t threadExclusion, dataExclusion;
int n, v[100 +5];
void *computeThread(void *arg) {
int nr = *(int *) arg;
printf("Thread started. Nr: %d \\n", nr);
while(n < 100) {
printf("while\\n");
sleep(nr);
pthread_mutex_lock(&threadExclusion);
p... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
void *work(void *arg) {
pthread_mutex_unlock(&lock);
pthread_mutex_lock(&lock);
return arg;
}
int main() {
int ret;
pthread_t thread1, thread2;
ret = pthread_mutex_init(&lock, 0);
if (ret) {
fprintf(stderr, "pthr... | 0 |
#include <pthread.h>
pthread_mutex_t *mutex_init( void ) {
pthread_mutex_t *mutex = (pthread_mutex_t *) myalloc( sizeof(pthread_mutex_t) );
if( pthread_mutex_init( mutex, 0) != 0 )
fail( "pthread_mutex_init() failed." );
return mutex;
}
void mutex_destroy( pthread_mutex_t *mutex ) {
if( m... | 1 |
#include <pthread.h>
static int glob = 0;
static pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER;
void incr1(){
pthread_mutex_lock(&mtx2);
glob += 1;
printf("in t1 glob = %d\\n", glob);
pthread_mutex_unlock(&mtx2);
}
void incr2(){
pt... | 0 |
#include <pthread.h>
pthread_mutex_t write;
FILE* fp;
void* write_1()
{
int i=0;
for(i=0;i<=1000;i++) {
pthread_mutex_lock(&write);
fprintf(fp,"$%d \\n", i);
pthread_mutex_unlock(&write);
}
printf("write_1 performed \\n");
}
void* write_2()
{
... | 1 |
#include <pthread.h>
unsigned int cnt = 0;
unsigned int NUM_ITERS;
pthread_mutex_t cnt_lock;
void *count(void *arg)
{
int i;
for(i = 0; i < NUM_ITERS; i++)
{
pthread_mutex_lock(&cnt_lock);
cnt++;
pthread_mutex_unlock(&cnt_lock);
}
return 0;
}
int main(int argc, char *argv[])
{
... | 0 |
#include <pthread.h>
const int NHASH=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* fh[NHASH];
struct foo* foo_alloc(int id){
struct foo* fp;
int idx;
if((fp=(struct foo*)malloc(sizeof(st... | 1 |
#include <pthread.h>
char n[1024];
pthread_mutex_t lock= PTHREAD_MUTEX_INITIALIZER;
int string_read=0;
pthread_cond_t cond;
void * read1()
{
while(1){
while(string_read);
pthread_mutex_lock(&lock);
printf("Enter a string: ");
... | 0 |
#include <pthread.h>
int const N_THR = 10;
double Ns = 0;
double Zs = 0;
double const e = 0.0001;
int const N = 100;
pthread_mutex_t lock ;
pthread_cond_t pogoj ;
int piFound = 0;
void *funkcija_niti(void *arg)
{
int n = 0;
int z = 0;
double piP = 0;
while (1)
{
i... | 1 |
#include <pthread.h>
pthread_t thread1, thread2;
static pthread_mutex_t verrou1, verrou2;
int var=5, N=10, i=1,j=1;
void *lire(void *nom_du_thread)
{
pthread_mutex_lock(&verrou1);
printf(" lire variable = %d\\n",var);
for (i=0;i<N-1;i++)
{
pthread_mutex_unlock(&verrou2);
pthrea... | 0 |
#include <pthread.h>
static volatile bool running_flag = 0;
static int pipe_input[2];
static int pipe_output[2];
static char server_dir[PATH_MAX];
static char server_cmd[PATH_MAX];
static int server_pid = -1;
static pthread_mutex_t fd_mutex;
static pthread_t wait_thread_id;
static int run_ser... | 1 |
#include <pthread.h>
static void* thread_func(void* thread_arg);
static pthread_mutex_t s_mutex;
static pthread_cond_t s_cond;
static int s_use_mutex = 0;
static void set_thread_name(const char* const name)
{
int res;
VALGRIND_DO_CLIENT_REQUEST(res, 0, VG_USERREQ__SET_THREAD_NAM... | 0 |
#include <pthread.h>
struct MuxerList * MuxerListInit(int maxLen)
{
struct MuxerList * list = (struct MuxerList*)malloc(sizeof(struct MuxerList));
memset(list, 0, sizeof(struct MuxerList));
list->listMaxLen = maxLen;
return list;
}
void MuxerListPutData(struct MuxerList * list, char * data, ... | 1 |
#include <pthread.h>
void *fetch_player_orders(void *args)
{
char line[LINE_SIZE];
struct ARGS *arg = args;
fgets(line, LINE_SIZE, arg->P->in);
while (strcmp(line, "go\\n") != 0) {
struct fleet *f = malloc(sizeof(*f));
fgets(line, LINE_SIZE, arg->P->in);
... | 0 |
#include <pthread.h>
pthread_mutex_t lock1;
int coins = 10;
struct Node {
int value, guard;
struct Node *left, *center, *right;
};
struct Node *root = 0;
struct Node* newNode(int value) {
struct Node* temp = (struct Node*) malloc(sizeof( struct Node ));
temp->value = value;
... | 1 |
#include <pthread.h>
int gnum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void * print(void * arg)
{
pthread_mutex_lock(&mutex);
while (gnum < 5)
{
pthread_cond_wait(&cond, &mutex);
}
printf("gnum is ready: %d\\n", gnum);
pthrea... | 0 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node
{
int n_number;
struct node*n_next;
}*head=0;
static void cleanup_handler(void*arg)
{
printf("Cleanuphandlerofsecondthread.\\n");
free(arg);
(void... | 1 |
#include <pthread.h>
int init_pc_buffer(struct in_packet_buffer ** b) {
(*b) = (struct in_packet_buffer*) malloc(sizeof (struct in_packet_buffer));
if(*b == 0) {
fprintf(stderr, "Problem to allouate buffer memory\\n");
return 1;
}
(*b)->buffer = (struct wrapper* ) malloc(9999*sizeof(s... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void *mouseListener();
void *tableRotator();
void makeStep(char *ws);
int mouseStateFlag=0;
int ret1, ret2;
int main() {
pthread_t mouseThread, tableThread;
int mouseThreadError, tableThreadError;
int *ptr[2]... | 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>
int thread_count;
int barrier_thread_count = 0;
pthread_mutex_t barrier_mutex;
pthread_cond_t ok_to_proceed;
void Usage(char* prog_name);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
double start... | 1 |
#include <pthread.h>
int * a;
pthread_mutex_t * mutexs;
pthread_t * threads;
pthread_barrier_t * barrera;
void * hebra(void * input) {
int tid = input;
int myVal;
int ptid = (tid == 0) ? 40 -1 : tid-1;
int minTid = (tid == 0) ? tid : ptid
,maxTid = (tid == 0) ? ptid : tid;
myVal = a[tid... | 0 |
#include <pthread.h>
int p1=0;
int p2=0;
int n=0;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar=PTHREAD_MUTEX_INITIALIZER;
void *referee(void *arg);
void *player1(void *arg);
void *player2(void *arg);
int vcheck();
int dcheck();
void mprint();
int test=0;
int game_finish=0;
int... | 1 |
#include <pthread.h>
struct foo *queue[(29)];
static pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER;
struct foo
{
int f_count;
void *f_data;
pthread_mutex_t f_lock;
struct foo *f_next;
};
static int resource_queue_init(int id)
{
int index = ((id) % (29));
... | 0 |
#include <pthread.h>
pthread_mutex_t chopstick[5];
void *philosophy(void *arg);
void pickup(int me);
void drop(int me);
int main(int argc, const char *argv[])
{
pthread_t tid[5];
int i, p[5];
srand(time(0));
for (i = 0; i < 5; i++)
{
pthread_mutex_init(&chopstic... | 1 |
#include <pthread.h>
int asc_code;
int ocorrencias;
}Caracter;
long buffleng;
int nthreads;
char *buffer;
Caracter *lista_asc;
pthread_mutex_t mutex;
int hashCode(int key) {
return ( key + 61) % 94;
}
int search(int key) {
int hashIndex = hashCode(key);
if(key == lista_a... | 0 |
#include <pthread.h>
const int beatup_iterations = 10000;
const int num_threads = 30;
const int max_keys = 500;
struct key_list {
struct key_list *next;
pthread_key_t key;
};
struct key_list *key_list;
pthread_mutex_t key_lock = PTHREAD_MUTEX_INITIALIZER;
static void
beat_up(void)
{
... | 1 |
#include <pthread.h>
int value;
pthread_cond_t rc, wc;
pthread_mutex_t rm, wm;
int r_wait, w_wait;
}Storage;
void setValue(Storage *s, int value) {
s->value = value;
}
int getValue(Storage *s) {
return s->value;
}
void *set_th(void *arg) {
Storage *s = (Storage *)arg;
for (int i = 1; ... | 0 |
#include <pthread.h>
char** argtab;
int next_file = 1;
int nbfiles;
pthread_mutex_t next_file_mutex = PTHREAD_MUTEX_INITIALIZER;
void convert_file(char* file_name)
{
FILE *fp1, *fp2;
int c = 1;
fp1= fopen (file_name, "r");
fp2= fopen (file_name, "r+");
if ((fp1== 0) || (fp2== 0)) ... | 1 |
#include <pthread.h>
int whoseTurn(){
int turn;
if ((tobacco == 0) && (matches == 0) && (paper == 0)){
turn = 0;
}
if ((tobacco == 0) && (matches == 1) && (paper == 1)){
turn = 1;
}
if ((tobacco == 1) && (matches == 0) && (paper == 1)){
turn = 2;
}
if ((tobacco == 1) ... | 0 |
#include <pthread.h>
struct node_struct* next;
char* data;
pthread_mutex_t mtx;
} node;
pthread_mutex_t head_mtx;
node* head;
node* push_front(node* p, char* buf) {
int len = strlen (buf);
node* q = (node*) malloc (sizeof (node));
pthread_mutex_init (&(q -> mtx), 0);
q -> data = (char... | 1 |
#include <pthread.h>
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
int g_key = 0x3333;
void TestFunc(int loopnum)
{
printf("loopnum:%d\\n", loopnum);
int ncount = 0;
int ret = 0;
int shmhdl = 0;
int *addr = 0;
int semid = 0;
sem_open(g_key, &semid);
sem_p(semid);
ret =... | 0 |
#include <pthread.h>
int make_listen(int port);
void handle_connection(FILE* fin, FILE* fout);
int remove_trailing_whitespace(char* buf);
static pthread_mutex_t mutex;
static pthread_cond_t condvar;
static int n_connection_threads;
void* connection_thread(void* arg) {
FILE* f = (FILE*) arg;
... | 1 |
#include <pthread.h>
int numReaders = 0;
int numWriters = 0;
int resourceFlag =0;
int sharedVariable = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_write = PTHREAD_COND_INITIALIZER;
void * Reader_thread(void * param);
vo... | 0 |
#include <pthread.h>
static int balance = 0;
static pthread_mutex_t lock;
void report_and_die(const char* msg) {
perror(msg);
exit(0);
}
void* deposit(void* n) {
int* ptr = (int*) n;
int limit = *ptr, i;
for (i = 0; i < limit; i++) {
if (pthread_mutex_lock(&lock) == 0) {
... | 1 |
#include <pthread.h>
void error(char *msg,int i)
{
fprintf(stderr, "%s %i: %s\\n", msg,i, strerror(errno));
exit(1);
}
int beers = 200000000;
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void* drink_lots(void* a)
{
int i;
pthread_mutex_lock(&beers_lock);
for(i=0; i<10000000; i++)... | 0 |
#include <pthread.h>
int sqrtN,N,NThreads;
int mysum;
pthread_attr_t attr;
pthread_mutex_t mutexsum;
void * Factorize(void *arg)
{
int i;
long tid;
tid = (long) arg;
for(i=tid+2;i<=sqrtN;i=i+NThreads)
{
if((N%i)==0)
{
pthread_mutex_lo... | 1 |
#include <pthread.h>
static pthread_mutex_t getprotoby_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
convert (struct protoent *ret, struct protoent *result,
char *buf, int buflen)
{
int len, i;
if (!buf) return -1;
*result = *ret;
result->p_name = (char *) buf;
len = strlen... | 0 |
#include <pthread.h>
void* nokta(void*);
void help(char*);
unsigned int seed;
long total = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char *argv[])
{
if (argc != 3)
{
help(argv[0]);
}
int i, thread_say = atoi(argv[2]);
int *errCode;
... | 1 |
#include <pthread.h>
int start;
int end;
} args_struct;
int min;
int max;
pthread_mutex_t mutex;
pthread_cond_t condition;
} result_struct;
static result_struct results = {
.mutex = PTHREAD_MUTEX_INITIALIZER
};
int myArray[(int) 1e8];
struct timeval begin, end;
void * search_min(voi... | 0 |
#include <pthread.h>
void *trabajador(void *arg);
int vector[1024];
struct b_s {
int n;
pthread_mutex_t m;
pthread_cond_t ll;
} b;
int main(void) {
pthread_t hilo[10];
int i;
b.n = 0;
pthread_mutex_init(&b.m, 0);
pthread_cond_init(&b.ll, 0);
par=0; impar=1;
for(i=0; i<... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_3 = PTHREAD_MUTEX_INITIALIZER;
int elementos[3] = {1,2,3};
int fumado;
int elemento = 0;
int elemento1;
int elemento2;
int elemento3;
void* fuma... | 0 |
#include <pthread.h>
int a;
pthread_mutex_t mutex;
int thread_index;
} thread_param;
void *Thread_Fn(void *arg) {
thread_param *param = (thread_param *) arg;
int k;
for (k=0; k < 10; k++) {
pthread_mutex_lock(&mutex);
a++;
printf("%d says: a is %d now\\n", param->thread_index, a);
... | 1 |
#include <pthread.h>
size_t alloc_len;
size_t len;
size_t elem_size;
void *elems;
pthread_mutex_t lock;
} queue;
queue *queue_new (size_t elem_size) {
queue *q = malloc(sizeof(queue));
q->alloc_len = 1024;
q->elem_size = elem_size;
q->elems = malloc(q->alloc_len * elem_size);
... | 0 |
#include <pthread.h>
int stack[5];
int stptr = 0;
pthread_mutex_t mutex;
pthread_cond_t condv;
void
stack_push(int xx)
{
pthread_mutex_lock(&mutex);
while (stptr >= 5) {
pthread_cond_wait(&condv, &mutex);
}
stack[++stptr] = xx;
pthread_cond_broadcast(&condv);
pthr... | 1 |
#include <pthread.h>
static void
*adz_player_entry(void *arg)
{
long n;
void *result;
char id = *(char *)arg;
n = start_adz(id , STDOUT_FILENO);
result = (void *)n;
return result;
}
int
main(int argc, char *argv[])
{
char id;
char *message = 0;
char name[] = "?.bookz";
i... | 0 |
#include <pthread.h>
static pthread_mutex_t priv_pid_mutex;
static unsigned long priv_pid_pool=0;
static void * priv_pid_data[MAX_PLAYER_THREADS];
static unsigned long priv_pid_used[MAX_PLAYER_THREADS];
int player_id_pool_init(void)
{
priv_pid_pool=0;
MEMSET(priv_pid_data,0,sizeof(pr... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
long acc = 0;
int nque = 1;
struct mymesg {
long mtype;
char mtext[512];
};
int thread_id[16];
int msgid[16];
pthread_t tid[16];
void *thread_fn(void *arg) {
int n = *((int *)arg);
struct mymesg sbuf, rbuf;
pthread_m... | 0 |
#include <pthread.h>
unsigned int sum = 0;
pthread_mutex_t m;
int counter;
void *incr(){
unsigned int i;
counter += 1;
printf("\\n Lock\\n");
for(i=0;i<=10;i++){
pthread_mutex_lock(&m);
sum += 1;
printf("\\n Job %d started\\n", i);
fflush(stdout);
pthread_mutex_unlock(&m);
}... | 1 |
#include <pthread.h>
void* declare_init_files(void* rank)
{
long my_rank = rank;
pthread_mutex_t mutex;
int check = pthread_mutex_init(&mutex, 0);
if (my_rank == 0)
{
pthread_mutex_lock(&mutex);
firingcoherenceid = fopen("FiringCoherenceVaryingDs(100,8) (0.9; 0.6).txt", ... | 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_mutex_t lock;
pthread_cond_t wait;
int vagas;
} semaforo;
void error(char *msg) {
fprintf(stderr, "%s: %s\\n", msg, strerror(errno));
exit(1);
}
void init(semaforo *s, int vagas) {
if (vagas <= 0) {
error("O valor de vagas tem que ser maior que 0!")... | 0 |
#include <pthread.h>
void*recv_t(void*in)
{
struct t_args*args=(struct t_args*)in;
char*buffer=(char*)malloc(256);
int i;
while(*(args->sig))
{
memset(buffer,0,256);
pthread_mutex_lock(args->mutex);
if(recv(*(args->sock),buffer,256,0)>0)
{
printf("\\r");fflush(stdout);
for... | 1 |
#include <pthread.h>
pthread_mutex_t mut;
pthread_t thread[2];
int number=0,i;
void
*thread1 ()
{
printf("thread1: I'am thread 1\\n");
for(i=0;i<10;i++)
{
printf("thread1:number=%d\\n",number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(2);
}
print... | 0 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
extern void __VERIFIER_error() ;
int element[(800)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(800)];
_Bool enqueue_flag, dequeue_flag;
QType queu... | 1 |
#include <pthread.h>
sem_t sem_agent;
sem_t sem_tobacco;
sem_t sem_paper;
sem_t sem_match;
sem_t tobacco;
sem_t match;
sem_t paper;
sem_t sem_mutex;
bool tobFree = 0;
bool paperFree = 0;
bool matchesFree = 0;
void *agentA(void *);
void *agentB(void *);
void *agentC(void *);
void *pusherA(void *... | 0 |
#include <pthread.h>
{
double think_time;
double eat_time;
int left_fork;
int right_fork;
long thread_id;
time_t total_thinking_time;
time_t total_eating_time;
time_t total_starvation_time;
long spagetti;
} philosoph_t;
static pthread_mutex_t forks[ 5 ];
sta... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t mutex1;
void *low_pri_thread(){
int i=0;
for (i=0;i<20;i++){
printf("Executing the low priority thread: %d\\n",pthread_self());fflush(stdout);
pthread_mutex_lock(&mutex1);
count++;
pthread_mutex_unlock(&mutex1);
}
}
void *hi_pri_thread(){... | 0 |
#include <pthread.h>
static pthread_t thread[256];
static pthread_mutex_t mutex[256];
static pthread_cond_t cond[256];
static volatile int full[256];
static volatile int data[256];
static int cycles;
static int tokens;
static void send_to (int i, int d)
{
pthread_mutex_lock (&(mutex[i]));
wh... | 1 |
#include <pthread.h>
pthread_cond_t condicao_cheio, condicao_vazio;
pthread_mutex_t mutex_contador;
pthread_t threadProdutora, threadConsumidora;
int contador;
void * produtor (void* );
void * consumidor (void *);
void produzir(void);
void consumir(void);
int main(){
pthread_mutex_init(&m... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thread_1(void *arg)
{
pthread_mutex_lock(&mutex);
DPRINTF(stdout,"Thread 1 locked the mutex\\n");
pthread_exit(0);
return 0;
}
void *thread_2(void *arg)
{
int rc;
pthread_t self = pthread_self();
int policy = SCHED_FIFO;
struct sched_pa... | 1 |
#include <pthread.h>
int reader_count = 0;
int writer = 0;
pthread_mutex_t rw_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t rw_cond = PTHREAD_COND_INITIALIZER;
void start_read(void) {
pthread_mutex_lock(&rw_mutex);
reader_count = reader_count + 1;
while(writer == 1) {
pt... | 0 |
#include <pthread.h>
int word_len;
long start,end;
double cost_time;
void *count(void *m);
void *total(void *m);
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int main(int argc,char *argv[])
{
start = clock();
if(argc<3){
printf("error \\n");
return 0;
}
pthrea... | 1 |
#include <pthread.h>
sem_t sem;
struct msgs{
long msgtype;
char msg_text[512];
};
static int num = 2;
struct prodcons
{
char buf[512];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
struct prodcons buffer;
void in... | 0 |
#include <pthread.h>
int ITERS = 6;
int SLOWNESS = 30000;
int NUM_R = 7;
int NUM_W = 3;
char BUFFER[35 + 1];
pthread_mutex_t r_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t rw_lock = PTHREAD_MUTEX_INITIALIZER;
int read_count = 0;
void rest() {
usleep(SLOWNESS * (rand() % (NUM_R + NUM_... | 1 |
#include <pthread.h>
struct msg{
struct msg *next;
int num;
};
struct msg *head;
struct msg *mp;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *con(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
while (head == 0)
{
pt... | 0 |
#include <pthread.h>
int clnt_cnt = 0;
int clnt_socks[256];
pthread_mutex_t mutx;
void send_msg(char *msg, int len) {
int i;
pthread_mutex_lock(&mutx);
for (i = 0; i < clnt_cnt; i++) {
write(clnt_socks[i], msg, len);
}
pthread_mutex_unlock(&mutx);
}
void *handle_clnt(void *arg) {
int ... | 1 |
#include <pthread.h>
unsigned int textureID;
float vertices[] =
{0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f};
float texture[] =
{0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f};
unsigned char indices[] =
{0, 1, 3, 0, 3, 2};
int texWidth, texHeight, stupidTegra;
void glInit()
{
glSha... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void
prepare(void)
{
printf("preparing locks...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void
parent(void)
{
printf("parent unlocking l... | 1 |
#include <pthread.h>
char _buffer[50][30];
int _nbmess = 0;
pthread_cond_t _full_buff = PTHREAD_COND_INITIALIZER;
pthread_cond_t _empty_buff = PTHREAD_COND_INITIALIZER;
pthread_mutex_t _mut = PTHREAD_MUTEX_INITIALIZER;
void * Ecriture(void * arg)
{
int index_ecriture = 0;
while(1)
{
pth... | 0 |
#include <pthread.h>
int ticks = 0;
pthread_t thread[1];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wakeupsig = PTHREAD_COND_INITIALIZER;
void* time_triggered_thread(){
char buff[100];
time_t now = time (0);
pthread_mutex_lock(&mutex);
while(1){
pthread_cond_... | 1 |
#include <pthread.h>
pthread_mutex_t gMutex;
static long num_steps=10000000;
double step, pi,sum = 0.0;
void *Pi(void* arg)
{
int* p = (int*)arg;
int parametro = *p, i;
double x;
for (i=parametro; i< num_steps; i=i+2)
{
x = (i+0.5)*step;
pthread_mutex_lock( &gMutex ... | 0 |
#include <pthread.h>
int cliente;
sem_t pedido;
}TVENDEDOR;
TVENDEDOR vendedores[4] = {0};
int senha = 1;
int proximo = 1;
pthread_mutex_t mutex_senha = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_proximo = PTHREAD_MUTEX_INITIALIZER;
void atende_cliente(int vendedor, int cliente... | 1 |
#include <pthread.h>
char chDbgBuf[8192];
static FILE *pFile = 0;
static pthread_mutex_t tDebuggerMutex = PTHREAD_MUTEX_INITIALIZER;
void StartDebugger()
{
pFile = fopen("debug.log","w");
}
void OutputDebugString(char *pcString)
{
pthread_mutex_lock( &tDebuggerMutex );
if (pFile == 0)
... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int fd;
char buf[100];
void* writeit()
{
pthread_mutex_lock(&lock);
printf("Enter data to send to client.\\n");
fgets(buf,100,stdin);
int wret=write(fd,buf,100);
if(wret<0)
{
printf("Failed to Write.\\n");
close(fd);
pthread_mutex_unlock(&lock)... | 1 |
#include <pthread.h>
pthread_t philosopher[20];
pthread_mutex_t forks[20];
sem_t s;
unsigned int randr (unsigned int min, unsigned int max)
{
double scaled = (double)rand()/32767;
return scaled*(max - min + 1) + min;
}
void *func(void *id){
long n = (long)id;
while(1){
... | 0 |
#include <pthread.h>
pthread_mutex_t cnt_mutex;
sem_t sem_write;
sem_t pre;
int reader_count = 0;
int content = 1;
pthread_t readers[10];
void * writer_func()
{
printf("writer start\\n");
while (1)
{
sem_wait(&pre);
sem_wait(&sem_write);
content++;
pr... | 1 |
#include <pthread.h>
static bool isFimglibInit = 0;
static pthread_mutex_t instanceLock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t sharedLock;
static int g2dFd;
static unsigned char *g2dVirtualAddress;
static unsigned int g2dSize;
static unsigned char *g2dDestinationVirtualAddress;
... | 0 |
#include <pthread.h>
int hungers[8];
int produced[8];
int indices[8];
int produced_total = 0;
int goods_in_shop = 0;
pthread_mutex_t produce_mutex, shop_mutex, consume_mutex;
pthread_cond_t place_in_shop, anything_in_shop;
void random_delay() {
struct timespec wait_time;
wait_time.tv_... | 1 |
#include <pthread.h>
int main(int argc, char **argv)
{
if (argc != 2 )
{
printf("Passing arguments does not match with the iPDC inputs! Try Again?\\n");
exit(0);
}
int id,i,port,ret;
char *ptr1,buff[20];
char *l1,*d1,*d2,*d3,*d4;
FILE *fp;
size_t l2=0;
ssize_t result;
id = a... | 0 |
#include <pthread.h>
char buf[10];
int occupied;
int nextin;
int nextout;
pthread_mutex_t mutex;
pthread_cond_t more;
pthread_cond_t less;
} buffer_t;
buffer_t buffer;
void producer(buffer_t *b, char item)
{
pthread_mutex_lock(&b->mutex);
while (b->occupied... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int sum = 0;
void print_vector(char name, int *v, int size) {
printf("%c = ", name);
int i;
for (i = 0; i < size; i++) {
printf("%i", v[i]);
if (i == size - 1) {
printf(" \\n");
} else {
prin... | 0 |
#include <pthread.h>
pthread_t thread[3];
pthread_mutex_t mut;
int k = 1;
int *a;
void thread1(void* arg){
int num = *(int*)arg;
for(; k<11; k){
pthread_mutex_lock(&mut);
if( k<11 ) printf("thread %d: k = %-2d\\t\\tthread id: %lu\\n", num, k++, pthread_self());
pthread_mutex_unlock(... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t scan_ready = PTHREAD_COND_INITIALIZER;
void *read_serial(void * arg)
{
int serial_fd = open("/dev/ttyAMA0", O_RDONLY);
struct read_serial_out * out = (struct read_serial_out *)arg;
int16_t * ranges =... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
static int asmMutex = 1;
int g = 0;
int correct = 0;
int violations = 0;
int number_threads = 10;
int number_access = 10;
int is_locked = 0;
int is_assembly = 0;
void do_something_clever(int i);
void test_lock(void * i);
void compare_result(int expec... | 1 |
#include <pthread.h>
enum Colour
{
blue = 0,
red = 1,
yellow = 2,
Invalid = 3
};
const char* ColourName[] = {"blue", "red", "yellow"};
const int STACK_SIZE = 32*1024;
const BOOL TRUE = 1;
const BOOL FALSE = 0;
int CreatureID = 0;
enum Colour doCompliment(enum Colour c1, enum Colo... | 0 |
#include <pthread.h>
int sum = 0;
int count = 0;
int rcv_count = 0;
pthread_mutex_t mutex;
key_t key = 4567;
int queue[100];
struct msgbuf {
long mtype;
int mnum;
};
void *tfn(void)
{
pthread_mutex_lock(&mutex);
int msgid;
if ((msgid=msgget(key+count, IPC_CREAT|0666))<0) {
... | 1 |
#include <pthread.h>
int num=0;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
void* thread_func(void *arg)
{
int i = (int)arg;
int ret;
sleep(5-i);
pthread_mutex_lock(&mylock);
while(i != num)
{
printf("thread %d warting\\n",i... | 0 |
#include <pthread.h>
char y, x;
} pos_t;
char fim, humano, num;
int tempo;
} player_t;
int max_y, max_x;
pos_t ele[4] = { {3, 10}, {15,15}, {12,40}, {19,45}};
pthread_mutex_t key;
void* move_jogador( void *dados){
player_t *j;
int ch;
pos_t d;
j = (player_t*) dados... | 1 |
#include <pthread.h>
void* robotRetrait(void* arg)
{
char MessageAfficher[200];
struct convoyeur* myConvoyeur = arg;
sprintf(MessageAfficher,"[Robot de Retrait] : Prêt");
affichageConsole(LigneRobotRetrait,MessageAfficher);
while(1)
{
pthread_mutex_lock(&mutex_RobotRetrait);
... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("preparing locks...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent unlocking locks...\\n"... | 1 |
#include <pthread.h>
static unsigned long mt[624];
static int mti=624 +1;
pthread_mutex_t bowl;
struct philo_Struct {
pthread_cond_t condp;
int state;
int blocktime;
} people[5];
void init_genrand(unsigned long s)
{
mt[0]= s & 0xffffffffUL;
for (mti=1; mti<624; mti++) {
mt[mti]... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.