text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int sval;
int fval;
} Args;
long unsigned int thread_count;
pthread_mutex_t * mutex;
int *vet, nbins;
double max, min, h, *val;
double min_val(double * vet,int nval) {
int i;
double min;
min = FLT_MAX;
for(i=0;i<nval;i++) {
if(vet[i] < min)
min = vet[i];... | 1 |
#include <pthread.h>
struct params
{
size_t start;
size_t size;
char data[10000];
};
size_t size;
size_t current_position = 0;
FILE* fp;
FILE* write_fp;
char cnt = 1;
short count = 0;
pthread_t threads[20];
int id_threads[20];
params_t problems[20];
char buff[10000];
pthread_cond_t cond_st... | 0 |
#include <pthread.h>
int card_channel[100];
char channelstr[CHANNEL_NUMBER][3]= {
"1","2","3","4","5","6","7",
"8","9","10","11","12","13"};
static int current_channel = 0;
static void *process_function(void *);
static void process_function_actual(int job_type);
static int process_judege(... | 1 |
#include <pthread.h>
struct job {
struct job* next;
};
struct job* job_queue;
extern void process_job (struct job*);
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
void initialize_job_queue ()
{
job_queue = 0;
sem_init (&job_queue_co... | 0 |
#include <pthread.h>
struct app_txn_array app_admin_confirm_array;
struct app_txn_array app_admin_request_array;
struct app_txn_array app_best_sellers_array;
struct app_txn_array app_buy_confirm_array;
struct app_txn_array app_buy_request_array;
struct app_txn_array app_home_array;
struct app... | 1 |
#include <pthread.h>
pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;
struct arg_struct{
int tI;
char* host;
int portNum;
FILE * file;
int inc;
};
void* client(void* n){
struct arg_struct *args = n;
int client_fd;
int rec;
char rec_buf[1024];
struct s... | 0 |
#include <pthread.h>
char mybuf[25];
pthread_mutex_t my_lock;
sem_t s_signal;
void first(void *firstarg ) {
sleep(1);
fprintf(stderr, "First thread executing\\n");
pthread_mutex_lock(&my_lock);
sprintf(&mybuf[0], "Hi CSC 615\\n");
pthread_mutex_unlock(&my_lock);
sem_post(&s_signal);
}
... | 1 |
#include <pthread.h>
int pid;
int state;
int rounds;
int num_philos;
int handedness;
pthread_mutex_t** forks;
} Philosopher;
void doActivity(int activity,Philosopher* p,unsigned* seed)
{
p->state = activity;
double v = ((double)rand_r(seed)) / 32767 * 5.0;
... | 0 |
#include <pthread.h>
struct Nodo *siguiente;
struct Nodo *anterior;
char valor;
}Elemento;
int tamano;
Elemento *inicio;
Elemento *fin;
}Lista;
Lista *list;
int insercion(Lista *lista, char dato);
int supresion(Lista *lista, int pos);
void *consumidor(void *arg);
void *productor(void *a... | 1 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void clock_gettime(int id, struct timespec *tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
... | 0 |
#include <pthread.h>
struct Request;
struct Msg;
struct Request
{
int pid;
};
struct Msg
{
int pid;
char data[512];
};
char *servername = "server1";
char *famfifo = "server1";
int ffd;
int semid;
int numclients = 0;
int ifd,ofd;
int cfd[10][2];
struct pollfd pfd[10];
pthread_t tid;
pthread_mu... | 1 |
#include <pthread.h>
int VALEUR;
pthread_mutex_t mutex;
void traitementLong() {
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 10;
nanosleep(&ts, 0);
}
void* f0(void* _p) {
int i;
for(i = 0; i < 1000; i++) {
pthread_mutex_lock(&mutex);
int x = VALEU... | 0 |
#include <pthread.h>
pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t game_thread, time_thread;
int game_return, time_return;
struct socketThread {
pthread_t thread;
int inUse;
};
struct socketThread socketThreads[5];
void waitFor (unsigned int secs) {
unsigned int retTime ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int iter = 1;
int odd = 1;
static void *third_thread_func()
{
while(iter <= 100)
{
if(!odd)
{
pthread_mutex_lock(&mutex);
printf("Thread three: %d\\n", iter++);
odd = 1;
pthread_mutex_unlock(&mutex);
}
}
pthread_exit(0);
}
static ... | 0 |
#include <pthread.h>
static pthread_mutex_t mtx;
static pthread_cond_t cv;
static uint8_t cur_count = 0;
static uint8_t total_count = 0;
static const uint8_t TOTAL_COUNT_THRESHOLD = 100;
static void *
consumer_fn(void *ctx)
{
uint8_t id = (uint8_t) ctx;
printf("%s: starting thread... | 1 |
#include <pthread.h>
struct tmfs_worker {
struct tmfs_worker *prev;
struct tmfs_worker *next;
pthread_t thread_id;
size_t bufsize;
char *buf;
struct tmfs_mt *mt;
};
struct tmfs_mt {
pthread_mutex_t lock;
int numworker;
int numavail;
struct tmfs_session *se;
struct tmfs_chan *prevch... | 0 |
#include <pthread.h>
sem_t empty_pot,full_pot;
static pthread_mutex_t servings_mutex;
static pthread_mutex_t print_mutex;
static int servings=15;
void *Savage(void *id)
{
int savage_id=*(int *)id;
while(1)
{
pthread_mutex_lock(&servings_mutex);
if(servings==0)
{
sem_post(&empty_pot)... | 1 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * thread1(void *);
void * thread2(void *);
volatile int i;
int main(int argc ,char *argv[])
{
pthread_t tid1 , tid2;
pthread_create(&tid1 , 0 , thread1 , 0);
pthr... | 0 |
#include <pthread.h>
void error(const char * message)
{
fprintf(stderr, "%s\\n", message);
exit(1);
}
static const struct stream_defn * const stream_defns[] = {
&mem_stream,
&pipe_stream,
&tcp_stream,
&unix_stream,
};
struct xfer_data {
struct timespec tstamp;
unsigned int canary;
cha... | 1 |
#include <pthread.h>
int somma_voti;
int votanti;
} Film;
struct Film arrayFilm[10];
pthread_mutex_t mutex_threads[10];
void *ThreadCode(void *t) {
long tid;
long result = 1;
int i;
int voto;
tid = (int)t;
for (i = 0; i < 10; i++) {
pthread_mutex_lock(&mutex_threads[i]);
... | 0 |
#include <pthread.h>
extern pthread_mutex_t rand_lock;
extern int MIN_PROGRAMMING_TIME;
extern int MAX_PROGRAMMING_TIME;
extern int MIN_HELPING_TIME;
extern int MAX_HELPING_TIME;
int generateSomeTime(int caller_type, unsigned int* seed)
{
if (caller_type)
{
pthread_mutex_lo... | 1 |
#include <pthread.h>
struct thread_data{
char * chunk;
int *ch_size;
unsigned int *histo;
pthread_mutex_t * mutex;
pthread_cond_t * cond_cons;
pthread_cond_t * cond_prod;
int id;
};
void processing(char * chunk, unsigned int* histogram, const int sajz){
... | 0 |
#include <pthread.h>
void *serverClient(void *ptrFile);
char achFileList[5][10] = {"12.mp3","file2","file1.c","file4.c","file2.c"};
int iLenght;
struct sockaddr_in caddr;
pthread_t clientThread[1];
pthread_mutex_t mutexLock;
int iSocketDis;
int main()
{
int iIndex;
for (iIndex = 1; iIndex ... | 1 |
#include <pthread.h>
char thread_msg[] ="Hello Thread!";
volatile int counter = 0;
pthread_mutex_t myMutex;
void *demo_mutex(void *param)
{
int i;
for(i = 0; i < 5; i++) {
pthread_mutex_lock(&myMutex);
counter++;
usleep(1);
... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(800)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_to... | 1 |
#include <pthread.h>
int numofPlayer,itr;
pthread_mutex_t mutex;
int playIds[4],listenIds[4];
int broadcast(char *sendtext,int length){
for(itr=0;itr<numofPlayer;itr++){
if(write(listenIds[itr],sendtext,length)<0){
printf("listener connection shutdown\\n");
return 0;
}
}
return 1;
}... | 0 |
#include <pthread.h>
void *b[(8)];
int in = 0, out = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
sem_t countsem, spacesem;
void init()
{
sem_init(&countsem, 0, 0);
sem_init(&spacesem, 0, (8));
}
void enqueue(void *value)
{
sem_wait( &spacesem );
pthread_mutex_lock(&lo... | 1 |
#include <pthread.h>
pthread_mutex_t * create_mutex()
{
pthread_mutex_t *mutex = mmap(0, sizeof(pthread_mutex_t), (PROT_READ | PROT_WRITE), (MAP_SHARED | MAP_ANON), -1, 0);
if (mutex == MAP_FAILED)
{
perror("create_mutex:mmap");
return 0;
}
pthread_mutexattr_t attr;
pthread_... | 0 |
#include <pthread.h>
char* buf[5];
int pos;
pthread_mutex_t mutex;
void* fuck(void* shit){
pthread_mutex_lock(&mutex);
buf[pos] = shit;
sleep(1);
pos++;
pthread_mutex_unlock(&mutex);
}
int main(){
pthread_mutex_init(&mutex,0);
pthread_t tid1;
pthread_create(&tid1,0,fuck,"zhang... | 1 |
#include <pthread.h>
pthread_t threads[100];
pthread_mutex_t mutex;
int a[100], b[100];
int sum, tamanho;
void printArray()
{
int cont =0;
printf("\\nA = ");
while (cont < 100)
{
printf("%d, ", a[cont]);
cont++;
}
cont = 0;
printf("\\nB = "... | 0 |
#include <pthread.h>
int estado [(5)];
pthread_mutex_t mutex;
pthread_mutex_t mux_filo [(5)];
pthread_t jantar[(5)];
void * filosofo ( void * param );
void pegar_hashi ( int id_filosofo );
void devolver_hashi ( int id_filosofo );
void intencao ( int id_filosofo );
void comer ( int id_filosofo );
... | 1 |
#include <pthread.h>
pthread_mutex_t m1,m2,m3;
void* thread_capital(void *p)
{
char ch;
for(ch = 'A' ; ch <= 'Z' ; ++ch)
{
pthread_mutex_lock(&m1);
printf("%c\\t",ch);
fflush(stdout);
sleep(1);
pthread_mutex_unlock(&m2);
}
}
void* thread_small(void *p)
{
char ch;
for(ch = 'a' ; ch... | 0 |
#include <pthread.h>
pthread_mutex_t w_mutex;
char w_area[1024];
int time_to_exit = 0;
void *thread_func()
{
sleep(1);
pthread_mutex_lock(&w_mutex);
while(strncmp("end", w_area, 3) != 0)
{
printf("You input %d characters\\n", strlen(w_area) -1);
w_area[0] = '\\0';
pthread_mutex_unlock(... | 1 |
#include <pthread.h>
void *picture_thread(void *arg) {
int ret = -1;
struct path_t *jpeg_filepath = 0;
enum main_notify_target notify = NOTIFY_NONE;
for (;;) {
pthread_mutex_lock(&global.client.thread_attr.picture_mutex);
while (global.client.picture_target ==... | 0 |
#include <pthread.h>
sem_t clientes, foiChamado;
pthread_mutex_t mutex;
pthread_cond_t atendentes;
int proximoCliente;
void *Atendentes(void *arg){
int i, pid = * (int *) arg;
while(1){
sem_wait(&clientes);
printf("Tem clientes na padaria!\\n");
pthread_mutex_lock(&mutex);
prin... | 1 |
#include <pthread.h>
const char * thread_outgoing_writer_tslogid = "outgoing_writer";
void * thread_outgoing_writer (void * arg)
{
tslog(0, thread_outgoing_writer_tslogid, "Started.");
struct thread_outgoing_synchroblock * synchroblock = arg;
int code;
do
{
tslog(0, thread_outgoing_writ... | 0 |
#include <pthread.h>
char phil_state[5] = {'T','T', 'T', 'T','T'};
pthread_mutex_t canEat;
sem_t amt;
const char* semaphore_name = "/amt";
void* dining_table(void* param);
void waiter(int phil_num, int request);
void check_on_table(int bites);
int main() {
pthread_t philosophers[5... | 1 |
#include <pthread.h>
int buffer[3];
int add = 0;
int rem = 0;
int num = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_cons = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_prod = PTHREAD_COND_INITIALIZER;
void *productor (void *param);
void *consumidor (void *param);
int main... | 0 |
#include <pthread.h>
void *find_words(void*);
int map_reduce(int number_threads, char *string, struct list *list);
int main(void) {
char *string;
int cur_time, i, j;
struct list *list;
struct stat *buf;
buf = (struct stat *) malloc(sizeof(struct stat));
stat("./Don_Quixo... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct sigevent event2;
volatile unsigned counter;
volatile int timeCounter = 0;
struct _pulse pulse;
int czasy[4] = {100, 200, 500, 3500};
int thread_chid;
{
short type;
}my_msg;
void *dummy(void *arg) {
... | 0 |
#include <pthread.h>extern void __VERIFIER_assume(int);
extern void __VERIFIER_error() ;
void __VERIFIER_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
const int SIGMA = 3;
int *array;
int array_index=-1;
pthread_mutex_t mutexes[SIGMA];
pthread_mutex_t mu... | 1 |
#include <pthread.h>
long THREAD_NUMBER = 0;
int isCanceled = 0;
pthread_t *thread;
pthread_barrier_t barrier;
pthread_mutex_t farestAccess;
int farestThread = 0;
int thread_id;
int threads_count;
} thread_attributes;
void sigint_handler( int sig ) {
if (sig == SIGINT) {
isCanceled = 1;
... | 0 |
#include <pthread.h>
int fib(int n)
{
if(n == 0) return 1;
if(n == 1) return 1;
return fib(n-2) + fib(n-1);
}
{
int fib_arg;
int* pfree_threads;
pthread_mutex_t* pconsole_mutex;
pthread_mutex_t* pstart_mutex;
} fib_data;
void* thread_main(void* param)
{
fib_data data = *(fib_data*)param;
free(pa... | 1 |
#include <pthread.h>
void * sumRow(void * arg);
pthread_t threads[4];
int sum = 0;
pthread_mutex_t mutex;
int main(int argc, char *argv[]) {
int array[4][10], i, j;
srand(time(0));
for (i = 0; i < 4; i++) {
for (j = 0; j < 10; j++) {
array[i][j] = rand() % 10;
... | 0 |
#include <pthread.h>
static pthread_mutex_t sslock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t sscond = PTHREAD_COND_INITIALIZER;
static bool sender_active;
static int sender_sock;
static FILE *sender_fout;
static void fail_sender(int sock, int priority, const char *fmt, ...)
{
char ... | 1 |
#include <pthread.h>
void* consumme(void* param)
{
struct consommateur_param* consommateurParam=(struct consommateur_param*)param;
int size = SIZE;
struct facteurPremier* local = (struct facteurPremier*) malloc(sizeof(*local)*size);
int i;
for(i=0;i<size;i++)
{
local[i].nombre=0;
local[i... | 0 |
#include <pthread.h>
void serial_init(int fd)
{
struct termios options;
tcgetattr(fd, &options);
options.c_cflag |= ( CLOCAL | CREAD );
options.c_cflag &= ~CSIZE;
options.c_cflag &= ~CRTSCTS;
options.c_cflag |= CS8;
options.c_cflag &= ~CSTOPB;
options.c_iflag |= IGNPAR;
options.c_iflag &=... | 1 |
#include <pthread.h>
extern int nthreads, verbose;
extern char * outfile_name;
static FILE * outfile;
static int* data;
static int nitems;
static int capacity;
int start_merge = 0;
int start;
int end;
int size;
}node_t;
int q_count, m_count, q_in, m_in, q_out, m_out;
pthread_cond_t ... | 0 |
#include <pthread.h>
struct thread_data {
int min_fd;
volatile int max_fd;
const char * mails_outdir;
};
static pthread_mutex_t max_fd_mutex = PTHREAD_MUTEX_INITIALIZER;
static bool has_trailing_slash(const char * dirname) {
assert(dirname);
size_t len_dirname = strlen(dirname);
asse... | 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 *idp)
{
int j,i;
double result=0.0;
int *my_id = idp;
for (i=0; i < 10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
... | 0 |
#include <pthread.h>
int size,borad[32][32],sum = 0,next[32];
pthread_mutex_t sumLock;
int dijiyobu(int id, int position) {
for(int i = 0; i < next[id]; i++) {
if(borad[id][i] == position || abs(borad[id][i] - position) == next[id] - i) return 0;
}
return 1;
}
void queen(int id) {
if(next[id... | 1 |
#include <pthread.h>
struct divide{
int start,end;
};
struct timeval startread,startcalc,readtime,finish,calctime,overalltime;
char buf1[1000000][50],buf[1000000];
int count,idx;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
void *thread_fun(void *bkm){
struct divide *d=((struct divide*)b... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
float gen_time;
float clock_ticks;
int id = 0;
int ger_fd;
int tick = 0;
int id;
float p_time;
char fifo[15];
float initTick;
int ticks;
Direction dir;
} Vehicle;
void write_log(Vehicle *vehicle, int state){
char des... | 1 |
#include <pthread.h>
static pthread_mutex_t input_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t op_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t display_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
static sem_t semitems;
static sem_t semslots;
static sem_t seminpu... | 0 |
#include <pthread.h>
int read_count = 1;
pthread_mutex_t read_count_mutex;
sem_t sem_write_access;
void initialize()
{
sem_init(&sem_write_access,0,1);
pthread_mutex_init(&read_count_mutex,0);
}
int shared_data = 0;
void* reader(void *data)
{
pthread_mutex_lock(&read_count_mutex)... | 1 |
#include <pthread.h>
pthread_t tp_pthread_create(void*(*main_entry_point)(void *),void *res,pthread_cond_t *condition){
int result;
pthread_t thread_id;
pthread_attr_t thread_attr;
result = pthread_attr_init(&thread_attr);
if (result != 0) {
assert(result);
}
... | 0 |
#include <pthread.h>
static int g_temp_cute_leak_check = 0;
pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct cute_mmap_ctx *get_cute_mmap_ctx_tail(struct cute_mmap_ctx *mmap) {
struct cute_mmap_ctx *p;
if (mmap == 0) {
return 0;
}
for (p = mm... | 1 |
#include <pthread.h>
struct prodcons{
int buf[16];
pthread_mutex_t lock;
int readpos,writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
}prodcons;
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_mutex_t g_mutex;
pthread_cond_t g_cond;
pthread_t g_thread[2 + 2];
int nready = 0;
void *consume(void* arg) {
int num = (int) arg;
while(1) {
pthread_mutex_lock(&g_mutex);
{
while (0 == nready) {
printf("%d begin wai... | 1 |
#include <pthread.h>
unsigned int number[10];
pthread_mutex_t lock;
void print_sched_attr(int num){
int policy, rtn;
struct sched_param param;
rtn = pthread_getschedparam(pthread_self(), &policy, ¶m);
if(rtn != 0) perror("Unable to retrieve pthread sched param: ");
printf("Scheduler... | 0 |
#include <pthread.h>
void init_crasher()
{
srand(time(0));
long crash_sleep = 1+(int) (50.0*rand()/(32767 +1.0));
crash_now = 0;
pthread_mutex_init(&(crash_mutex), 0);
if (pthread_create(&(crash_thread), 0, crash_return,
(void *)(crash_sleep)) != 0) {
fprintf(stderr,"Didn't init cr... | 1 |
#include <pthread.h>
int in_use[PID_MAX + 1];
pthread_mutex_t test_mutex;
void *allocator(void *param)
{
int i, pid;
for (i = 0; i < 10; i++) {
sleep((int)(random() % 5));
pid = allocate_pid();
printf("allocated %d\\n",pid);
if (pid == -1)
printf("No pid available\\n");... | 0 |
#include <pthread.h>
int a;
pthread_mutex_t mutex;
pthread_cond_t cv;
int thread_index;
} thread_param;
void *Thread_A(void *arg) {
thread_param *params = (thread_param *) arg;
printf("thread %d is created\\n", params->thread_index);
pthread_mutex_lock(&mutex);
if (a < 5) {
printf("Thr... | 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>
struct node *head_gv;
char work_set[30][1024 * 32];
struct thread_arg{
int start_row ;
int n_sentence;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int printWordCount(char *sentence)
{
int ret = 0;
int letter = 0;
int word_count = 0;
char word_b... | 1 |
#include <pthread.h>
pthread_cond_t cv;
pthread_mutex_t mutex;
int length;
int queue[200];
void *producer(void *param){
for(int i=0;i<200;i++){
pthread_mutex_lock(&mutex);
queue[length++]=i;
pthread_cond_signal(&cv);
pthread_mutex_unlock(&mutex);
}
}
void *producer(void * param){
... | 0 |
#include <pthread.h>
pthread_t philosopher[5];
pthread_mutex_t forks[5];
void *funmutex(int n);
void *funmutex(int n) {
printf("\\nPhilosopher %d is thinking \\n",n);
pthread_mutex_lock(&forks[n]);
pthread_mutex_lock(&forks[(n+1)%5]);
printf("\\nPhilosopher %d is eating \\n",n);... | 1 |
#include <pthread.h>
struct keyset {
const char **set;
int set_size;
int next_idx;
pthread_mutex_t lock;
};
struct keyset *
keyset_init(int num, const char *prefix)
{
struct keyset *ks;
char buf[128];
int i;
ks = malloc(sizeof(*ks));
memset(ks, 0, sizeof(*ks));
pthread_mutex_... | 0 |
#include <pthread.h>
int tlog_mask = 31;
static int t_init = 0;
static char tproc[PROC_NAME_SIZE];
static pthread_mutex_t mask_mutex = PTHREAD_MUTEX_INITIALIZER;
static void signal2_callback(char *proc, int value1, int value2)
{
switch (value1) {
case 1:
if ((value2 < 0) || (value2 > 8))
... | 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 qMutex;
pthread_cond_t qCond;
int loggerrunning = 1;
char* message;
int length;
struct queue *next;
} Queue;
Queue *pendingLogs;
int queueEmpty() {
return pendingLogs == 0;
}
int logpop(char* msg, int buffersize) {
pthread_mutex_lock(&qMutex);
... | 1 |
#include <pthread.h>
pthread_t threads[3];
pthread_mutex_t mutex;
pthread_cond_t event;
int cpt_global=0;
void rdva()
{
if(cpt_global==3*10)
{
pthread_mutex_lock(&mutex);
pthread_cond_broadcast(&event);
pthread_mutex_unlock(&mutex);
}
else
{
drawrec (300... | 0 |
#include <pthread.h>
int flag;
pthread_cond_t cond;
pthread_mutex_t mutex;
void init()
{
pthread_mutex_init(&mutex, 0);
pthread_cond_init(&cond, 0);
flag = 0;
}
void *consume_wait(void *pid)
{
int id = *(int *)pid;
while (1)
{
pthread_mutex_lock(&mutex);
while (!flag)
{
... | 1 |
#include <pthread.h>
{
FILE *file;
char *fileName;
char *filePath;
int isDebug;
size_t maxSize;
size_t actSize;
pthread_mutex_t mutex;
} *log_t;
static const unsigned long dftFileSize = (1 * 0x400 * 0x100000L);
static pthread_mutex_t logMutex = PTHREAD_MUTEX_INITIAL... | 0 |
#include <pthread.h>
static int glob = 0;
static pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx3 = PTHREAD_MUTEX_INITIALIZER;
static void *
threadFunc1(void *arg)
{
pthread_mutex_lock(&mtx1);
if(glob%2==0){... | 1 |
#include <pthread.h>
char stol[10] = {' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
int pozicia_na_umiestnenie = 0;
int pozicia_na_zobratie = 0;
int stoj = 0;
int pocetVygenerovanych = 0, pocetTestovanych = 0;
pthread_mutex_t mutexSynchronizacia = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c... | 0 |
#include <pthread.h>
pthread_t philosopher[50];
pthread_mutex_t chopstick[50];
int p=5;
int meal=5;
void *func(int n)
{
pthread_mutex_lock(&chopstick[n]);
pthread_mutex_lock(&chopstick[(n+1)%p]);
printf ("Philosopher %d is eating\\n\\n",n);
usleep(500000);
pthread_mutex_unlock(&chopstick[n... | 1 |
#include <pthread.h>
int quit_flag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void thread_f(void* arg) {
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0) {
err_exit(e... | 0 |
#include <pthread.h>
struct connection_pool* new_connection_pool() {
struct connection_pool* pool = malloc(sizeof(struct connection_pool));
pool->head = 0;
pool->tail = 0;
pthread_mutex_init(&(pool->mutex), 0);
return pool;
}
void delete_connection_pool(struct connection_pool* pool) {
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_stoj = PTHREAD_MUTEX_INITIALIZER;
int stoj = 0;
pthread_mutex_t mutex_tazko_chori = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_lahko_chori = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_vysetrenie = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t evento;
int n_elementos=0;
int buffer[3];
int indProd = 0;
int indCons = 0;
int n_prod = 0;
void * Productor(void * arg) {
int dato;
while (1) {
dato = rand()%100;
sleep(rand()%3);
pthread_mutex_lock(&mutex);
whi... | 1 |
#include <pthread.h>
pthread_t thread;
pthread_cond_t can_eat;
int id;
int tid;
} philosopher;
static philosopher diners[5];
static int stop=0;
static pthread_mutex_t chopstick[5];
static unsigned long user_progress[5];
static unsigned long user_time[5];
static unsigned long sys_progress[... | 0 |
#include <pthread.h>
int initStop()
{
printf("stared initializing");
fflush(stdout);
pthread_mutex_lock(&acqStop_mutex);
acqStop = 1;
pthread_mutex_unlock(&acqStop_mutex);
pthread_mutex_lock(©Stop_mutex);
copyStop = 1;
pthread_mutex_unlock(©Stop_mutex);
pthrea... | 1 |
#include <pthread.h>
static void *run(void *);
static void good_session(int, FILE *);
static void bad_session(int, FILE *);
struct account {
double balance;
pthread_mutex_t mutex;
};
static account *myacct;
static int version = 0;
void deposit(struct account *acct, double amount)
{... | 0 |
#include <pthread.h>
int collect = 1;
void sighandler(int signum){ collect = 0;}
void main(int argc, char* argv[])
{
FILE * fp = (FILE*) 0;
struct emg_driver* emg_config = (struct emg_driver*) 0;
int i, j;
struct emg_data data;
struct filtered_data filteredData;
struc... | 1 |
#include <pthread.h>
pthread_mutex_t lock_fork;
pthread_mutexattr_t lock_fork_attr;
sem_t lock_fork_req;
sem_t lock_fork_wait;
int lock_fork_forkers_count;
int lock_fork_blockers_count;
int lock_fork_waiting_count;
void scp_lock_init(void)
{
pthread_mutexattr_init(&lock_fork_attr);
pthread_mu... | 0 |
#include <pthread.h>
pthread_mutex_t esc, lei, prot;
int pilha = 0;
void *leitor(void *argumento){
pthread_mutex_lock(&lei);
pilha++;
if(pilha == 1) pthread_mutex_lock(&esc);
pthread_mutex_unlock(&lei);
int* n = (int*) argumento;
char nome[] = "teste.txt";
FILE *fp = fopen(nome,"r... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void* thr_fn(void *arg){
int err,signo;
for(;;){
err = sigwait(&mask,&signo);
if(err != 0)
err_exit(err,"sigwait falied ");
sw... | 0 |
#include <pthread.h>
{
KEYPAD_NUM1 = 1,
KEYPAD_NUM2,
KEYPAD_NUM3,
KEYPAD_NUM4,
KEYPAD_NUM5,
KEYPAD_NUM6,
KEYPAD_NUM7,
KEYPAD_NUM8,
KEYPAD_NUM9,
KEYPAD_NUM10,
KEYPAD_NUM11,
KEYPAD_NUM12,
KEYPAD_NUM13,
KEYPAD_NUM14,
KEYPAD_NUM15,
KEYP... | 1 |
#include <pthread.h>
struct Message { long type; char option; int time; char text[128]; };
pthread_mutex_t statusMutex;
pthread_cond_t statusCond;
pthread_mutex_t notificationMutex;
pthread_cond_t notificationCond;
int exitLoop = 0;
int showingNotification = 0;
int updateScript = 0;
int status... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t e1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t e2 = PTHREAD_COND_INITIALIZER;
void* behav1 (void *args)
{
pthread_mutex_lock (&mutex1);
pthread_cond_b... | 1 |
#include <pthread.h>
void executeNextTask(struct Reader *r){
struct Task *temp;
int sleepTime = 200;
usleep(50000 + (int) ((double)rand() * (long)50000 / ((double) 32767 +1)));
while(run == TRUE){
int prio = r->tq->NumPriorities-1;
pthread_mutex_lock(&mutex);
temp = popTaskQueu... | 0 |
#include <pthread.h>
void* sub(void *arg);
int highRet, highRetId;
pthread_mutex_t m1;
int main(int argc, char *argv[])
{
alarm(60);
int is[4], rc;
int numThreads = atoi(argv[1]);
int section = 100/numThreads;
int* size;
pthread_t thrdid[4];
pthread_mutex_init(&m1, 0);
int y = 0;... | 1 |
#include <pthread.h>
double time_diff(const struct timespec *first, const struct timespec *second,
struct timespec *diff)
{
struct timespec tmp;
const struct timespec *tmp_ptr;
if (first->tv_sec > second->tv_sec
|| (first->tv_sec == second->tv_sec
&& first->tv_nsec > second->tv_nsec)... | 0 |
#include <pthread.h>
struct Philosopher {
int courses_left;
};
struct State {
struct Philosopher *philo;
pthread_mutex_t locks[3];
pthread_cond_t conds[3];
bool *forks;
int id;
int num;
};
void *PrintHello(struct State *state) {
int id;
id = state->id;
while (state->philo->c... | 1 |
#include <pthread.h>
int fd[2];
struct timespec start, end;
int numMaxCli;
FILE *file;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t nlock = PTHREAD_MUTEX_INITIALIZER;
int number;
char currGender = '\\0';
int clientCount = 0;
int pedF = 0, pedM = 0, rejF = 0, rejM = 0, serF =... | 0 |
#include <pthread.h>
int total_num=0;
int lenght = 0 ;
pthread_mutex_t mutex ;
int n1 = 1000 , n2 = 1000;
char * s1,*s2;
void * Str_Function(void* startpos) ;
int match (char *a,char *b,int pos);
int main(int argc, char *argv[])
{
pthread_mutex_init (&mutex, 0) ;
FILE *fp = fopen("strin... | 1 |
#include <pthread.h>
void ui_helpline__pop(void)
{
}
char ui_helpline__current[512];
void ui_helpline__push(const char *msg)
{
const size_t sz = sizeof(ui_helpline__current);
SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
SLsmg_set_color(0);
SLsmg_write_nstring((char *)msg, SLtt_Screen_Cols);
SLs... | 0 |
#include <pthread.h>
{
int v1;
int v2;
int v3;
} laStruct;
laStruct maStruct;
pthread_mutex_t monMutex = PTHREAD_MUTEX_INITIALIZER;
void *fonctionThreadMultiple(void *arg[])
{
int *tabArg = (int *)arg;
printf("Le pid du thread : %d\\nJ'affecte la variable\\n", getpid());
... | 1 |
#include <pthread.h>
struct entry {
int key;
int value;
struct entry *next;
};
struct entry *table[5];
int keys[100000];
int nthread = 1;
volatile int done;
pthread_mutex_t _locks[5];
double
now()
{
struct timeval tv;
gettimeofday(&tv, 0);
return tv.tv_sec + tv.tv_usec / 1000000.... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.