text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t lock;
{
sem_t sem;
unsigned int id;
int money;
} bankAccount;
{
bankAccount *src;
bankAccount *target;
int numberOfMoney;
} moneyTransfer;
{
bankAccount *target;
int numberOfMoney;
} addMoney;
bankAccount *createAccount(int id, int money... | 1 |
#include <pthread.h>
sem_t forks[5];
pthread_mutex_t mutex;
struct philosophor_struct{
char philosophor_name[100];
int philosophor_id;
};
void eat();
void think();
void get_forks();
void put_forks();
void *doit();
void think(struct philosophor_struct *p){
int sleep_time = rand() % 2... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
unsigned long long main_counter,counter[3];
void* thread_work(void* );
int main(int argc, const char *argv[])
{
int rtn,ch;
pthread_t pthread_id[3] = {0};
pthread_mutex_init(&mutex... | 1 |
#include <pthread.h>
pthread_mutex_t lock_bd = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_cont = PTHREAD_MUTEX_INITIALIZER;
int leitores_cont = 0;
void * leitores (void * arg){
int i = *((int*)arg);
while(1){
printf("Leitor %d - Vai ler dados\\n",i);
pthread_... | 0 |
#include <pthread.h>
int done;
int totalbytes;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lockbytes = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t byteschanged = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t isbyteschanged = PTHREAD_COND_INITIALIZER;
int copyfile(int infd, in... | 1 |
#include <pthread.h>
pthread_mutex_t Poll_Work;
sem_t Poll_IN;
sem_t Poll_OUT;
void* thread0(void *param)
{
while(1){
int rv = 0;
for(int i = 0; i < 5; ++ i)
while((rv = sem_wait(&Poll_IN)) != 0 && (errno == EINTR))
;
pthread_mutex_lock(&P... | 0 |
#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 i... | 1 |
#include <pthread.h>
struct data {
int tid;
char buffer[100];
} tdata1, tdata2;
pthread_mutex_t lock;
pthread_cond_t startCond;
int start = 0;
int totalMessageLength = 0;
void *worker(void *tdata) {
struct data *d = (struct data*) tdata;
printf("thread %d says %s\\n", d->tid, d-... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex;
static pthread_once_t once;
extern char **environ;
static int has_environ_malloced;
size_t cur_items;
size_t max_items;
void *block_signal (sigset_t *oldmask)
{
sigset_t newmask;
sigfillset(&newmask);
pthread_sigmask(SIG_BLOCK, &newma... | 1 |
#include <pthread.h>
pthread_mutex_t mutexes[5];
pthread_cond_t conditionVars[5];
int permits[5];
pthread_t tids[5];
int data = 0;
void * Philosopher(void * arg){
int i;
i = (int)arg;
pthread_mutex_lock(&mutexes[i%5]);
while (permits[i%5] == 0) {
pthread_cond_wait(&conditionVars... | 0 |
#include <pthread.h>
static int *solution[9];
static int duplicate = 0;
pthread_mutex_t lock;
ROW,
COLUMN,
BLOCK
} chk_t;
void *runner(void *para);
int main(int argc, const char *argv[]) {
int i, j, k, l;
int status;
pthread_t workers[27];
if (argc < 2) {
printf("no input\... | 1 |
#include <pthread.h>
struct {
pthread_cond_t cond;
pthread_mutex_t mutex;
int num;
} sync = {
.cond = PTHREAD_COND_INITIALIZER,
.mutex = PTHREAD_MUTEX_INITIALIZER,
.num = 0,
};
void * pthread_signal(void * arg)
{
for ( ; ; ) {
pthread_mutex_lock(&sync.mutex);
if (0 == sync.num) {
fp... | 0 |
#include <pthread.h>
pthread_mutex_t semafor = PTHREAD_MUTEX_INITIALIZER;
struct wiadomosc
{
char tresc[50];
};
struct buforCykliczny
{
struct wiadomosc tablica[256];
int licznik;
int we;
int wy;
};
int czytaj (struct buforCykliczny *bufor, struct wiadomosc *wiadCel);
int zapisz ... | 1 |
#include <pthread.h>
char searchWords[10000][KEYWORD_SIZE];
bool result[10000];
int searchWordCount = 0;
FILE * keywordsFile = 0;
FILE * searchWordsFile = 0;
pthread_mutex_t search_mutex;
bool readKeyWordsNBuildBST()
{
char word[KEYWORD_SIZE];
while (fgets(word, sizeof(word), keywordsF... | 0 |
#include <pthread.h>
static int pixel_mode = 0;
static struct console_font_op orig_font;
static unsigned char orig_font_data[65536];
struct winsize size;
static unsigned char *color_map;
static pthread_mutex_t print_lock = PTHREAD_MUTEX_INITIALIZER;
int tb_screen_init(int pixel_size)
{
struct c... | 1 |
#include <pthread.h>
struct {
pthread_mutex_t mutex;
int buff[10];
int nitems;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
void* produce(void* arg) {
for (;;) {
pthread_mutex_lock(&shared.mutex);
if (shared.nitems >= 1000000) {
pthread_mutex_unloc... | 0 |
#include <pthread.h>
int available[3];
int maximum[5][3];
int allocation[5][3];
int need[5][3];
pthread_mutex_t mutexavail;
pthread_mutex_t mutexalloc;
pthread_mutex_t mutexneed;
int request_resources(int customer_num, int request[]);
int release_resources(int customer_num, int request[]);... | 1 |
#include <pthread.h>
struct task {
char msg[64];
};
struct task *tp;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
void delay(int secs) {
time_t t;
for (t=time(0); t+secs>time(0); )
;
}
void *process_task(void *arg) {
pthr... | 0 |
#include <pthread.h>
static int isPing = 0;
static pthread_mutex_t count_mutex;
static pthread_cond_t count_thresholder_cv;
void *functionA(void *t)
{
int counter = 0;
pthread_mutex_lock(&count_mutex);
while(!isPing)
{
pthread_cond_signal(&count_thresholder_cv);
if (counter == 1000)
{... | 1 |
#include <pthread.h>
int _debug = -77;
void debug(char *fmt, ...)
{
if(_debug == -77) {
char *buf = getenv("EZTRACE_DEBUG");
if(buf == 0) _debug = 0;
else _debug = atoi(buf);
}
if(_debug >= 0) {
va_list va;
__builtin_va_start((va));
vfprintf(stdout, fmt, va);
;
}
}
... | 0 |
#include <pthread.h>
static pthread_cond_t response_cond = PTHREAD_COND_INITIALIZER;
bool
send_request(struct server_data* server, const char* request, int request_length)
{
int socket_fd = get_client_socket_fd();
char ip_address_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &server->a... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thread_func1(void *p)
{
long int i=0;
while(i<1000000)
{
i++;
pthread_mutex_lock(&mutex);
(*(long int*)p)++;
pthread_mutex_unlock(&mutex);
}
pthread_exit((void*)i);
}
void *thread_func2(void *p)
{
long int i=0;
while(i<1000000)... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond_variable;
int count;
int count_limit;
void * increment ()
{
printf ("Increment thread Starts\\n");
while (1)
{
pthread_mutex_lock (&lock);
count++;
if (count == count_limit)
{
pthread_c... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int* vet;
} Vector;
Vector V;
void merge(int *vet, int left, int middle, int right);
void* threadedMergeSort(int* args);
int main(int argc, char** argv) {
int i, n;
int args[2];
if (argc != 2) {
fprintf (stderr, "Wrong number of argumen... | 0 |
#include <pthread.h>
struct prodcons
{
int buffer[16];
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... | 1 |
#include <pthread.h>
{
unsigned int init;
char name[20];
unsigned int dt;
unsigned int deadline;
char prior;
}trace;
pthread_t threadID[100];
struct arg_struct {
int delay;
int id;
};
trace processTable[100];
pthread_mutex_t *mutex;
void showPT(trace processTable[], int size);... | 0 |
#include <pthread.h>
static bool music_playing = 0;
static pthread_mutex_t music_playing_mutex = PTHREAD_MUTEX_INITIALIZER;
static int musicnum = 0;
static pthread_mutex_t musicnum_mutex = PTHREAD_MUTEX_INITIALIZER;
bool
get_music_playing (void)
{
bool value;
pthread_mutex_lock (&music_play... | 1 |
#include <pthread.h>
extern int service_quit;
static pthread_mutex_t active_pic_update_mutex = PTHREAD_MUTEX_INITIALIZER;
struct picture_s *active_pic = 0;
static int active_pic_update = 0;
static int pic_shift_event_handler(int event_id, struct event_id_s event_id_table, struct picture_s *p_p... | 0 |
#include <pthread.h>
unsigned int COUNTER;
pthread_mutex_t LOCK;
pthread_mutex_t START;
pthread_cond_t CONDITION;
void* threads (void* unused)
{
pthread_mutex_lock(&START);
pthread_mutex_unlock(&START);
pthread_mutex_lock(&LOCK);
if (COUNTER > 0) {
... | 1 |
#include <pthread.h>
sem_t fillCount;
sem_t emptyCount;
pthread_mutex_t thread_flag_mutex;
void putInWarehouse(int item, int size, int* wh, int* itemCount);
int produceItem();
void consumeItem(int size, int* wh);
void initialize_flag ()
{
pthread_mutex_init (&thread_flag_mutex, 0);
}
str... | 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_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thrd_func(void *arg);
int main()
{
pthread_t thread[3];
int no;
void *tret;
srand((int)time(0));
pthread_mutex_init(&mutex,0);
for(no=0;no<3;no++)
{
if(pthread_create(&thread[no],0,thrd_func,(void*)no)!=0)
{
printf("create thr... | 0 |
#include <pthread.h>
int GbStop = 0;
void sigaction_handle_fun(int signo, siginfo_t * siginfo, void * sigcontext)
{
printf("sigaction_handle_fun signo:%d\\n", signo);
char* strsig = strsignal(signo);
if(strsig != 0)
{
printf("strsig:%s\\n", strsig);
}
GbStop = 1;
}
void atexit... | 1 |
#include <pthread.h>
int mediafirefs_statfs(const char *path, struct statvfs *buf)
{
printf("FUNCTION: statfs. path: %s\\n", path);
static char space_total[128];
static char space_used[128];
static uintmax_t bytes_total = 0;
static uintmax_t bytes_used = 0;
static u... | 0 |
#include <pthread.h>
int g_counter = 0;
int g_stop_it = 0;
pthread_mutex_t mutex_stop = PTHREAD_MUTEX_INITIALIZER;
int sockaddrInit(const char *host, int port, struct sockaddr_in *peer)
{
int code;
memset(peer, '\\0', sizeof(struct sockaddr_in));
peer->sin_family = AF_INET;
peer->... | 1 |
#include <pthread.h>
int flag = 1;
void uartfunction();
void txmsgfunction();
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t empty;
struct buffer
{
int state;
char send_buf[1024];
char recv_buf[1024];
}data_buf;
int main(){
data_buf.state = 1;
pthread_t mythre... | 0 |
#include <pthread.h>
char *test_UID = "DRFTBHN6XXUUVM6KWTE1";
static int __start_rdt_daemon = 0;
struct stRDTcnnt
{
char target_uid[20];
int action;
int iotc_sid;
int rdt_id;
int tx_counter;
int cnnt_state;
struct st_SInfo Sinfo;
};
pthread_mutex_t mutex_rdt_cnnt_array;
struct ... | 1 |
#include <pthread.h>
int n = 1, xcond = 0, zcond = 0;
pthread_mutex_t the_mutex;
pthread_cond_t condx, condz;
void x(void *argp)
{
pthread_mutex_lock(&the_mutex);
n = n * 16;
xcond = 1;
pthread_cond_signal(&condx);
pthread_mutex_unlock(&the_mutex);
}
void y(void *argp)
{
... | 0 |
#include <pthread.h>
enum {
kMaxNumThreads = 5
};
void create_and_join_threads(ThreadCallback *callbacks, int n) {
int i;
pthread_t t[kMaxNumThreads];
int ids[kMaxNumThreads];
assert(n <= kMaxNumThreads);
for (i = 0; i < n; i++) {
ids[i] = i;
pthread_create(&t[i], 0, cal... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
unsigned long long switches=0;
void* thread1(void *arg)
{
unsigned long long temp;
while(1){
pthread_mutex_lock(&mutex);
sw... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0, 1, 2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t) {
int i;
long my_id = (long)t;
for(i = 0; i < 10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if(count =... | 1 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0, 1, 2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i = 0; i < 10; i++)
{
pthread_mutex_lock(&count_mu... | 0 |
#include <pthread.h>
int nitems;
struct
{
pthread_mutex_t mutex;
int buff[10000000];
int nput;
int nval;
int ccount;
}shared={PTHREAD_MUTEX_INITIALIZER};
void *produce(void *);
void *consume(void *);
void printbuff()
{
int i;
printf("\\t");
for(i=0;i<nitems;i++)
printf("%4d",shared.buff[i]);
}
ma... | 1 |
#include <pthread.h>
char* data;
struct Node* next;
} Node_t;
Node_t *head;
Node_t *tail;
int size;
} Queue_t;
pthread_mutex_t linkQueueMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t linkQueueEmpty = PTHREAD_COND_INITIALIZER;
pthread_cond_t linkQueueFill = PTHREAD_COND_INITIALIZER;
int qu... | 0 |
#include <pthread.h>
int stack_size;
char pile[5];
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
void* Producteur(void* arg) {
int c;
int *num=(int*)arg;
while ((c = getchar()) != EOF) {
Push(c,*num);
}
}
void* Consommm... | 1 |
#include <pthread.h>
void _check_dir(const char *pathname)
{
int i, len;
char dirname[NESSDB_PATH_SIZE];
strcpy(dirname, pathname);
i = strlen(dirname);
len = i;
if (dirname[len-1] != '/')
strcat(dirname, "/");
len = strlen(dirname);
for (i = 1; i < len; i++) {
if (dirname[i]... | 0 |
#include <pthread.h>
int item =0;
int sum_r=0,sum_w=0;
struct sbuf_t{
int buff[10];
int write_h;
int read_h;
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
};
struct sbuf_t shared;
void* producer(){
for(int i=0;i<10;i++){
sem_wait(&shared.empty);
pthread_mutex_lock(&shared.mutex);... | 1 |
#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... | 0 |
#include <pthread.h>
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=0;
q->amount=0;
}
int empty(QType * q)
{
... | 1 |
#include <pthread.h>
void chassis_term ();
unsigned char convert_temperature (float temperature);
unsigned char convert_pressure (float pressure);
unsigned char convert_current (float current);
unsigned char convert_voltage (float voltage);
void * chassis (void * arg)
{
pthread_setcancels... | 0 |
#include <pthread.h>
pthread_mutex_t baglock;
int numWorkers;
int numArrived = 0;
int row;
struct ret{int sum; int max; int min; int mini; int minj; int maxi; int maxj;};
double read_timer() {
static bool initialized = 0;
static struct timeval start;
struct timeval end;
if( !initializ... | 1 |
#include <pthread.h>
int number_phils;
int phil_id[10];
int phil_status[10];
pthread_mutex_t chopsticks[10];
int chopstick_status[10];
pthread_mutex_t display;
int randomwait(int bound) {
int wait = rand() % bound;
sleep(wait);
return wait;
}
void visualRepresentation() {
pt... | 0 |
#include <pthread.h>
pthread_mutex_t a;
pthread_mutex_t b;
pthread_mutex_t c;
int k;
int j;
void* fn1(void * args){
pthread_mutex_lock(&a);;
if( k == 25 ){
pthread_mutex_lock(&b);;
if( j )
printf("hola\\n");
else
printf("adios\\n");
} else {
pthread_mutex_lock(&c);;
}... | 1 |
#include <pthread.h>
struct fsm_queue create_fsm_queue() {
struct fsm_queue queue = {
.first = 0,
.last = 0,
.mutex = 0,
.cond = 0,
};
check(pthread_mutex_init(&queue.mutex, 0) == 0, "ERROR DURING MUTEX INIT");
check(pthread_cond... | 0 |
#include <pthread.h>
pthread_mutex_t qlock;
pthread_cond_t qempty;
pthread_cond_t qfull;
int queue[1000];
int head;
int n;
int insertions, extractions;
void *consumer(void *cdata) {
int extracted;
int inx = *((int *)cdata);
while (1) {
extracted = 0;
pthread_mutex_lock(&qlock);
whil... | 1 |
#include <pthread.h>
void crut_barrier(int *counter)
{
static pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t my_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_lock(&my_mutex);
--(*counter);
if (*counter <= 0) {
if (*counter < 0) {
... | 0 |
#include <pthread.h>
void *(*process)(void *arg);
void *arg;
struct worker *next;
} CThread_worker;
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker *queue_head;
int shutdown;
pthread_t *threadid;
int max_thread_num;
int cur_queue_size... | 1 |
#include <pthread.h>
pthread_mutex_t lock_it = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t write_it = PTHREAD_COND_INITIALIZER;
{
char buffer[5];
int how_many;
}BUFFER;
BUFFER share = {"", 0};
boolean finished = FALSE;
void *read_some(void *p)
{
int ch;
printf("R %2d: Start... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
long my_id = (long)t;
while(1){
pthread_mutex_lock(&count_mutex);
count++;
printf("(%ld) count = %d\\n", my_id, count... | 1 |
#include <pthread.h>
int do_debug = 0;
int do_thread = 0;
int do_stdin = 0;
int do_sleep = 0;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t rand_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t dice_mutexes[7] = {
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIAL... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
sem_t sem;
SharedInt* sip;
void functionInsideCriticalSection() {
pthread_mutex_unlock(&(sip->lock));
printf("Value is currently: %i\\n", sip->value);
pthread_mutex_lock(&(sip->lock));
}
void *functionWithCrit... | 1 |
#include <pthread.h>
pthread_t ThreadId[4];
pthread_mutex_t Mutex;
int Available = 10;
int Goal[4]= {6,5,4,7};
int Hold[4] = {0,0,0,0};
int Need[4];
int Request;
int cusflag;
int Left;
int Finish[4];
void init()
{
cusflag = -1;
int i,j;
for(j=0; j<4; ++j)
Finish[j] = 1;
Left = Availabl... | 0 |
#include <pthread.h>
void func1();
void func2();
pthread_cond_t cond;
pthread_mutex_t mutex;
int food=0;
int main()
{
pthread_t thread[2];
pthread_mutex_init(&mutex,0);
pthread_cond_init(&cond,0);
int i=0;
int *status;
void (*funcptr[2])();
funcptr[0]=func1;
funcptr[1]=func2;
for (i=0;i<2;i++... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int counter=1;
int matriz[100][10];
int somaColuna[10];
void imprime_matriz(){
int i, j;
for(j=0;j<10;j++){
printf( "Soma da coluna %d (thread %d) = %d\\n", j, j, somaColuna[j]);
}
printf("\\n");
}
void* inicializa_matriz(void *p){
int i,... | 0 |
#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);
pthread_mutex_init... | 1 |
#include <pthread.h>
static volatile int g_account;
static pthread_mutex_t lock;
void *
Deposit(int amount)
{
int balance;
pthread_mutex_lock(&lock);
balance = g_account;
pthread_mutex_unlock(&lock);
pthread_mutex_lock(&lock);
g_account = balance + amount;
pthread_mutex_unlock(&lock);
... | 0 |
#include <pthread.h>
{
char name[256];
int life;
} POKEMON;
static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static int waiting[5];
static POKEMON waitingPkmn[5][6];
static pthread_cond_t clients_waiting, client_wakeup[5];
static int client_id = 1;
static int machine_id = 1;
stati... | 1 |
#include <pthread.h>
int sum_prim=0;
int sum_par=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void *PrintM (void *argv)
{
int nr= (int) argv;
pthread_mutex_lock(&mutex);
if (nr % 2 == 0 ) {
printf("Nr %d e par!\\n",nr);
sum_par=sum_par+nr;
}
else{
... | 0 |
#include <pthread.h>
const int MAX_KEY = 65535;
struct list_node_s {
int data;
struct list_node_s* next;
};
struct list_node_s* head = 0;
int thread_count;
int total_ops;
double insert_percent;
double search_percent;
double delete_percent;
int member_total=0, insert_total=0, delete_total=0... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cv1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cv2 = PTHREAD_COND_INITIALIZER;
int cola = 0;
int t_prod;
int t_cons;
int max;
int tam_cola;
int cont_p = 0;
int done = 0;
void *producir(void *arg) {
while (1) {
if (!done) {
... | 0 |
#include <pthread.h>
void *Worker(void *);
void InitializeGrids();
void Barrier();
struct tms buffer;
clock_t start, finish;
pthread_mutex_t barrier;
pthread_cond_t go;
int numArrived = 0;
int gridSize, numWorkers, numIters, stripSize;
double maxDiff[20];
double grid1[10000][10000];
double ... | 1 |
#include <pthread.h>
{
void *(*routine)(void *arg);
void *arg;
uint64_t id;
pthread_t tid;
} worker_task;
uint64_t bitmap;
worker_task tasks[64];
uint64_t tear_down;
} thread_pool;
int g_flag;
static thread_pool tp;
static thread_pool *pool = &tp;
pthread_mutex_t ... | 0 |
#include <pthread.h>
volatile struct __ptable_entry __process_table[MAX_PROCESSES];
pthread_mutex_t __process_mutex = PTHREAD_MUTEX_INITIALIZER;
volatile int __ptable_initted = 0;
void __init_ptable()
{
int i;
for(i = 0;i < MAX_PROCESSES;i++)
__process_table[i].in_use = 0;
__ptable_initted... | 1 |
#include <pthread.h>
int *arr;
long sum=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *gausswasbetteratthis(void *threadid) {
long start = (long)threadid*10000;
long end = start+10000 -1;
pthread_mutex_lock(&mutex);
for (long i=start; i<=end ; i++){
sum += a... | 0 |
#include <pthread.h>
long thread_count;
int a[32768];
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
struct Thread_params {
long thread;
int level;
};
void *Reduce(void* rank);
int main(int argc, char** argv)
{
long thread;
pthread_t* thread_handles;
int i;
thread_count = 3... | 1 |
#include <pthread.h>
static void process_message(struct shfs *fs, struct shfs_message *m,
const char *phost, int pport)
{
struct shfs_file_op op_alloc;
struct shfs_file_op *op = &op_alloc;
memset(op, 0, sizeof(*op));
strcpy(op->host, phost);
op->port = pport;
if (m->type & MESSAGE_ISDI... | 0 |
#include <pthread.h>
char Keypress=0;
char Id[10];
char ServerIp[15];
char ServerPort[7];
char g_Pass[20];
char HTTPS_IP[20];
char recvbuf[(1024)];
char Sendbuf[(1024)];
struct sockaddr_in cloudaddr;
struct in_addr addrKA;
static char Request[700] ;
extern char lat[];
extern char lon[];
extern ch... | 1 |
#include <pthread.h>
int mediafirefs_truncate(const char *path, off_t length)
{
printf("FUNCTION: truncate. path: %s, length: %zd\\n",
path, (size_t)length);
int retval;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pth... | 0 |
#include <pthread.h>
static int count = 0;
pthread_mutex_t lock;
int M;
int *up;
int *down;
int left;
int right;
} scalar_ctx_t;
void initialization(int *up, int N, int a, int b) {
srand(time(0));
for(int i = 0; i < N; i++) {
up[i] = rand() % (b - a + 1) + a;... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_t... | 0 |
#include <pthread.h>
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
int p1_msg;
int p2_msg;
sem_t p1_has_product;
sem_t p2_has_product;
sem_t p1_is_empty;
sem_t p2_is_empty;
int cmp(int a, int b)
{
if (a == b)
return 0;
if (a - b == 1 || a - b == -2)
return 1;
return -1;
}
int j... | 1 |
#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...... | 0 |
#include <pthread.h>
int thread_count;
int n;
double* A;
double min,max;
pthread_mutex_t mutex;
void Usage(char* prog_name);
void Gen_array(double A[], int n);
void *Find_MinMax(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
if (argc !=... | 1 |
#include <pthread.h>
int somma_voti;
int votanti;
} Film;
struct Film arrayFilm[10];
int arrayUtenti[6];
sem_t semUtenti[10];
int listaUtenti[10];
sem_t barriera;
sem_t download;
sem_t evento;
pthread_mutex_t mutex_threads[10];
int completati=0, bestfilm, userdownloading=0;
float vot... | 0 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t threshold_condv = PTHREAD_COND_INITIALIZER;
void *inc_counter(void *thread_id)
{
long th_id = (long) thread_id;
for (int ii = 0; ii < 10; ii++) {
pthread_mutex_lock... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double sum;
void *runner(void *param);
int main(int argc, char *argv[])
{
if (argc != 3) {
fprintf(stderr,"usage: <int : sumsqrt N > <int : thread count> \\n");
return (-1);
}
if (atoi(argv[1]) < 0) {
fprintf(stde... | 0 |
#include <pthread.h>
pthread_mutex_t glock1;
pthread_mutex_t glock2;
int A;
int B;
int B1;
int X;
void* thread_a(void *args) {
pthread_mutex_lock(&glock1);
printf("a locked glock 1\\n");
X = 0;
sleep(1);
pthread_mutex_lock(&glock2);
printf("a locked glock 2\\n");
sleep(... | 1 |
#include <pthread.h>
pthread_mutex_t cargMutex[5];
pthread_cond_t cargCv[5];
int cargas[5];
double ventas[5][31];
double totalsucursal[5];
double totalgeneral = 0;
void *cargoVentas(void *p) {
int tId = (int) p;
int dia = 0;
printf("Start cargoVentas[%d]\\n",tId);
for(d... | 0 |
#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;
while(1)
{
err = sigwait(&mask, &signo);
if(err != 0)
{
... | 1 |
#include <pthread.h>
pthread_mutex_t mutx_k;
pthread_mutex_t mutx_p;
pthread_mutex_t mutx_i;
pthread_cond_t cond_k = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_p = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_i = PTHREAD_COND_INITIALIZER;
int kosiky = 3;
int pokladne = 2;
int i;
void *zakaz... | 0 |
#include <pthread.h>
void codec_queue_init(struct codec_t* codec)
{
codec->queue_head = 0;
codec->queue_tail = 0;
codec->queue_count = 0;
codec->is_running = 1;
codec->PTS = -1;
pthread_mutex_init(&codec->queue_mutex,0);
pthread_cond_init(&codec->queue_count_cv,0);
pthread_cond_i... | 1 |
#include <pthread.h>
char slots[3][22];
const int LUT[3][3] = { { 1, 2 , 1}, { 2, 0 , 0}, { 1, 0 , 1}};
int w= 0;
int r= 1;
int l= 2;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void
reader_thread ()
{
while(1)
{
pthread_mutex_lock(&mutex);
if(l != r){
r = l;
pthread_mu... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int x = 0;
void *thread1(void *arg){
while(1){
printf("thread1 will change ans!\\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
x += 1;
pthread_mutex_unlock(&mute... | 1 |
#include <pthread.h>
sem_t ready_to_ask;
pthread_mutex_t mymutex, reporter_count;
pthread_cond_t cond, capacity_cond;
int question_asked;
int reporter_id, capacity, reporters_in, number_of_reporters;
void EnterConferenceRoom(int reporter_id){
pthread_mutex_lock(&mymutex);
while (reporters_in... | 0 |
#include <pthread.h>
int *all_buffers;
int num_producers;
int num_consumers;
int num_buffers;
int num_items;
int num_producer_iterations;
int actual_num_produced;
pthread_mutex_t should_continue_producing_lock;
pthread_mutex_t buffer_printer_lock;
sem_t *total_empty;
sem_t *total_full;
sem_t *... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condizione = PTHREAD_COND_INITIALIZER;
int **matrice;
int minimo=1000;
int n=0;
int *array=0;
int numT=0;
int i =0;
void stampa (int **m,int r){
for (int i=0;i<r;i++){
for (int j=0;j<r;j++){
printf("%d\\t",m[i]... | 0 |
#include <pthread.h>
const char rtems_test_name[] = "PSXCLEANUP";
pthread_t ThreadIds[2];
pthread_mutex_t lock;
pthread_cond_t rcond;
pthread_cond_t wcond;
int lock_count;
int waiting_writers;
} lock_t;
volatile bool reader_cleanup_ran;
volatile bool release_read_lock_ran;
volatile... | 1 |
#include <pthread.h>
static pthread_mutex_t getnetby_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
convert (struct netent *ret, struct netent *result,
char *buf, int buflen)
{
int len, i;
if (!buf) return -1;
*result = *ret;
result->n_name = (char *) buf;
len = strlen (ret-... | 0 |
#include <pthread.h>
struct prodcons
{
int buffer[3];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
pthread_cond_t wait_emergency;
int size;
};
void init(struct prodcons *b)
{
pthread_mutex_init(&b->lock, 0);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int shutdown = 0;
int flag = 0;
struct people
{
char name[10];
char sex;
struct people *next;
};
struct people *head = 0;
void *thread_pro(void *argv)
{
int i = 0;
for (;;)
{
struct people hum;
if (i%2 == 0)
{
str... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.