text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int students = 0;
int inRoom = 0;
int capacity = 0;
int globalID = 0;
int pflag = 0;
pthread_mutex_t roomlock, capslock, idlock, proflock;
pthread_cond_t profcond;
void QuestionDone();
void QuestionStart();
void AnswerStart();
void AnswerDone();
void LeaveOffice();
void Enter... | 1 |
#include <pthread.h>
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER ;
pthread_t pth1,pth2;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
int count=0;
void * even()
{
while(1)
{
pthread_mutex_lock(&lock);
if(count % 2 == 0)
{
printf("count %d\\n",count);
... | 0 |
#include <pthread.h>
int memory[(2*320+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*320+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx ... | 1 |
#include <pthread.h>
char *smackfs_mnt = 0;
int smackfs_mnt_dirfd = -1;
static pthread_mutex_t smackfs_mnt_lock = PTHREAD_MUTEX_INITIALIZER;
static int verify_smackfs_mnt(const char *mnt);
static int smackfs_exists(void);
int init_smackfs_mnt(void)
{
char *buf = 0;
char *startp;
char *e... | 0 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void fillBuffer(int *bufferIn, int TID, int *laststate, int *pages,
int *wrTOP, int *wrLOW, int *last, long *readIdx, int *reading)
{
int totalWritten = 0,lToken;
while(*laststate > 0 && *pages > 0 && totalWritt... | 1 |
#include <pthread.h>
static int iTThreads = 9;
static int iRThreads = 1;
static int data1Value = 0;
static int data2Value = 0;
pthread_mutex_t data1Lock;
pthread_mutex_t data2Lock;
void lock(pthread_mutex_t *);
void unlock(pthread_mutex_t *);
void *funcA(void *param) {
pthread_mutex_lock(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t space_available = PTHREAD_COND_INITIALIZER;
pthread_cond_t data_available = PTHREAD_COND_INITIALIZER;
int b[10];
int size = 0;
int front = 0, rear = 0;
void add_buffer(int i) {
b[rear] = i;
rear = (rea... | 1 |
#include <pthread.h>
void Qaullib_Topo_LL_Add (union olsr_ip_addr *src_ip, union olsr_ip_addr *dest_ip, float lq)
{
struct qaul_topo_LL_item *new_item;
new_item = (struct qaul_topo_LL_item *)malloc(sizeof(struct qaul_topo_LL_item));
if(QAUL_DEBUG)
printf("Qaullib_Topo_LL_Add\\n");
... | 0 |
#include <pthread.h>
int bb_buf[2];
int count=0;
int in, out;
int waiting;
pthread_mutex_t bbmutex;
pthread_cond_t bbcond;
pthread_barrier_t pbarrier;
void bb_init()
{
int i;
pthread_mutex_init(&bbmutex, 0);
pthread_cond_init(&bbcond, 0);
in=0;
out=0;
waiting=0;
for(i=0;i<=2 -1... | 1 |
#include <pthread.h>
pthread_mutex_t mutex, mutex2, w_or_r;
int writer_is_waiting = 0;
int reader_count = 0;
int flag_sigint = 0;
pthread_cond_t cond;
void writer() {
pthread_mutex_lock(&mutex2);
writer_is_waiting = 1;
pthread_mutex_unlock(&mutex2);
pthread_mutex_lock(&w_or_r);... | 0 |
#include <pthread.h>
void * serverthread(void * parm);
void sendFile(int sock, char *filename);
pthread_mutex_t mut;
int visits = 0;
int main (int argc, char *argv[])
{
struct protoent *ptrp;
struct sockaddr_in sad;
struct sockaddr_in cad;
int sd, sd2;
int port;... | 1 |
#include <pthread.h>
struct timespec ts_checkAt;
void check_in() {
clock_gettime(CLOCK_REALTIME, &ts_checkAt);
}
long check_out() {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
long nGap = ( ts.tv_sec - ts_checkAt.tv_sec ) * 1000000000 + ( ts.tv_nsec - ts_checkAt.tv_nsec );
p... | 0 |
#include <pthread.h>
int a;
int *b;
}Dong;
pthread_mutex_t mutex;
void func(Dong *i){
for(int j = 0; j < 20; ++j){
pthread_mutex_lock(&mutex);
++i->a;
++*i->b;
printf("%d %d\\n", i->a, *i->b);
pthread_mutex_unlock(&mutex);
}
}
int main(void)
{
pthread_mutexattr_t mutex_shared... | 1 |
#include <pthread.h>
void * handle_clnt(void * arg);
void error_handling(char *buf);
char buf[100];
pthread_mutex_t mutx;
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
int clnt_adr_sz;
pthread_t t_id;
if(argc!=2) {
printf("Usage : %s... | 0 |
#include <pthread.h>
int (*blkin_init_new_trace)(struct blkin_trace *new_trace, char *name,
struct blkin_endpoint *endpoint);
int (*blkin_init_child)(struct blkin_trace *child, struct blkin_trace *parent,
struct blkin_endpoint *endpoint, char *child_name);
int (*blkin_init_child_info)... | 1 |
#include <pthread.h>
int nitems;
struct {
pthread_mutex_t mutex;
int buff[10000000];
int nput;
int nval;
} shared={
PTHREAD_MUTEX_INITIALIZER
};
struct{
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
}ready={PTHREAD_MUTEX_INITIALIZER,
PTHREAD_COND_INITIALIZER
};
void consume_... | 0 |
#include <pthread.h>
char *value;
} Line;
int size;
int start;
int count;
Line *items;
} Buffer;
void bufInit(Buffer *b, int maxSize);
bool bufIsFull(Buffer *b);
bool bufIsEmpty(Buffer *b);
void bufWrite(Buffer *b, Line *l);
Line *bufRead(Buffer *b, int pos);
void ... | 1 |
#include <pthread.h>
{
int* dataPoint;
int index;
}
DataInfo;
pthread_mutex_t g_Mutex;
pthread_cond_t g_Condition;
int* Datas;
int Sums[(1024)];
void* ThreadFunction(void* Data);
int main(int argc, char** argv)
{
int ThreadResult = (0);
Datas = malloc(sizeof(int) * (1... | 0 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t counter_mutex;
void *thread_foo(void *args)
{
int i = 0;
for(i = 0; i < 5; i++)
{
pthread_mutex_lock(&counter_mutex);
{
counter = counter + 1;
printf("foo: counter is %d\\n", counter);
... | 1 |
#include <pthread.h>
int mediafirefs_readlink(const char *path, char *buf, size_t bufsize)
{
printf("FUNCTION: readlink. path: %s\\n", path);
(void)path;
(void)buf;
(void)bufsize;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pt... | 0 |
#include <pthread.h>
int global_counter = 0;
pthread_mutex_t lock;
void* inc(void* pid){
pthread_mutex_lock(&lock);
for(int i = 0; i < 100; i++){
global_counter++;
}
pthread_mutex_unlock(&lock);
}
int main(int argc, const char* argv[]){
int nt;
sscanf(argv[1],"%d",&nt);
pthread_t threa... | 1 |
#include <pthread.h>
static pthread_t task1_thread;
static pthread_mutex_t task1_mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t task1_cond = PTHREAD_COND_INITIALIZER;
static int task1_running;
static int task1_exit;
static int task1(void)
{
int i;
sigset_t mask;
sigempt... | 0 |
#include <pthread.h>
int pbs_stagein(
int c,
char *jobid,
char *location,
char *extend)
{
int rc;
int local_errno = 0;
struct batch_reply *reply;
int sock;
struct tcp_chan *chan = 0;
if ((jobid == (char *)0) || (*jobid == '\\0'))
return (PBSE_IVALREQ);
if (locati... | 1 |
#include <pthread.h>
int total_words;
pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
void count_words(char *f);
main(int argc, char *argv[])
{
pthread_t t1, t2;
if (argc != 3)
{
printf("usage:%s file file2\\n", argv[0]);
exit(1);
}
total_words = 0;
... | 0 |
#include <pthread.h>
NEW,
PROCESSING,
DONE
} statuses;
int time;
int id;
statuses status;
pthread_t worker;
} task_t;
pthread_mutex_t lock;
task_t tasks[100];
static int sum = 0;
void* work(void* x) {
int done_tasks = 0, i;
int j;
while(!j){
j = 1;
for (i = 0; i < 100; i++) {
... | 1 |
#include <pthread.h>
struct reg {
int *inicio;
int *fim;
int *vet;
int n;
};
int somatorio[4];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * function (void *arg) {
int soma;
struct reg *valor;
valor = (struct reg*) arg;
printf("inicio %d\\n",valor->i... | 0 |
#include <pthread.h>
int tid;
double stuff;
} thread_data_t;
char temp;
pthread_mutex_t lock_x;
char buf[30*4096];
void *thr_func_1(void *arg) {
thread_data_t *data = (thread_data_t *)arg;
char *buf = 0;
int i = 0;
printf("hello from thr_func, thread id: %d\\n", data->t... | 1 |
#include <pthread.h>
int hasEaten[5] = {0};
struct timeval te,tf;
int totalTime =0;
int philCount =0;
int peakTime = 0;
void *function(int n);
pthread_t philosophers[5];
pthread_mutex_t forks[5];
pthread_mutex_t total = PTHREAD_MUTEX_INITIALIZER;
int main(){
int i,k;
for(i=0;i<5;i... | 0 |
#include <pthread.h>
int npos;
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t vmut=PTHREAD_MUTEX_INITIALIZER;
int buf[10000000], pos=0, val=0, ver=0;
void *fill(void *nr) {
while (1) {
pthread_mutex_lock(&mut);
if (pos >= npos) {
pthread_mutex_unlock(&mut);
... | 1 |
#include <pthread.h>
char buffer[7];
int nextin = 0, nextout = 0;
int count = 0;
pthread_cond_t notfull = PTHREAD_COND_INITIALIZER;
pthread_cond_t notempty = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void produce_char(void **argument){
char produced... | 0 |
#include <pthread.h>
char* dir;
struct Item* next;
} Item;
int fd, numDir[4];
Item* head;
pthread_mutex_t mep, mec, mef;
sem_t *full;
struct timespec ts;
void* exploreDirectory(void* arg);
Item* get(void);
void put(char* item);
int main(int argc, char** argv) {
char *directory, *filename... | 1 |
#include <pthread.h>
int count = 0, 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 == 12) {
... | 0 |
#include <pthread.h>
int fd;
int thrdzCnt;
int bufSize;
int dl;
char *str;
pthread_t* thrdz;
pthread_attr_t thrdzAttrs;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t kanselejszynMooteks = PTHREAD_MUTEX_INITIALIZER;
struct thrdInfo{
char* buf;
int idx;
};
void* searchForT... | 1 |
#include <pthread.h>
int cpt = 0;
pthread_mutex_t mut;
pthread_cond_t cond;
void* increm1(void* arg){
int i = 0;
for ( i = 0; i < 4; i++){
pthread_mutex_lock(&mut);
cpt++;
printf("compteur : %d\\n", cpt);
if (cpt == 3)
pthread_cond_signal(&cond);
sleep(3);
pthread_mutex_... | 0 |
#include <pthread.h>
pthread_mutex_t m;
void *thread3 (void *arg)
{
int i;
for (i = 0; i < 2; i++)
{
pthread_mutex_lock (&m);
pthread_mutex_unlock (&m);
}
return 0;
}
void *thread2 (void *arg)
{
long i = (long) arg;
printf ("u: running, i %ld!\\n", i);
re... | 1 |
#include <pthread.h>
extern int tiempo_actual;
extern int tiempo_respuesta;
extern int inventario;
extern pthread_mutex_t mutex;
extern FILE *LOG;
int numeroRn;
extern int ips[MAX_SERVERS];
extern int cuotas [MAX_SERVERS];
extern unsigned char *retos[MAX_SERVERS];
char **pedir_gasolina_1_sv... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err, signo;
for(;;){
printf("\\n\\ncan give siangl on terminal\\n\\n");
err = sigwait(&mask, &signo);
if(err !... | 1 |
#include <pthread.h>
void *produce(void *arg);
void *consume(void *arg);
struct {
pthread_mutex_t mutex;
int buf[1000000];
int nput;
int nval;
int nitems;
} shared = {
PTHREAD_MUTEX_DEFAULT
};
int main(int argc, char *argv[])
{
int i, errcode, nitems, nthread, count[100];
pthread_t th... | 0 |
#include <pthread.h>
void *page_fault_func(void *t);
void *tlb_thrashing_func(void *t);
static int exec_size;
static sigjmp_buf senv[4];
static volatile int jump_ok[4];
static volatile int total = 0;
static void *exec_mem[4];
static pthread_t create_thread[4];
static pthread_t destroy_thread[4];... | 1 |
#include <pthread.h>
pthread_mutex_t chopstick[6] ;
void *eat_think(void *arg)
{
int i;
char phi = *(char *)arg;
int left,right;
switch (phi){
case 'A':
left = 5;
right = 1;
break;
... | 0 |
#include <pthread.h>
struct ppball the_ball;
struct obstacle the_obstacle[MAXMSG];
void set_up();
void init_ball();
void add_boundary();
void add_road();
void ball_move();
void within_boundary(struct ppball*);
int set_up_obs(struct obstacle the_obstacle[]);
void *animate();
pthread_mutex_t mx ... | 1 |
#include <pthread.h>
buffer_item buffer[6];
int index_counter = 0;
void *thread_Insert(void *arg);
void *thread_Remove(void *arg);
sem_t bin_sem;
pthread_mutex_t mutx;
char thread1[]="Thread A";
char thread2[]="Thread B";
char thread3[]="Thread C";
int main(int argc, char **argv)
{
pthre... | 0 |
#include <pthread.h>
char name[100];
char search[100];
pthread_t tid;
int *cont;
int nt;
} mystruct;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t sig;
void* sfun(void *arg){
mystruct *sfile= (mystruct *) arg;
int fd=open... | 1 |
#include <pthread.h>
static char *page;
static int page_nr = 10;
static int page_len;
static pthread_mutex_t _syscall_mtx;
void usage(const char *argv0)
{
fprintf(stderr, "usage:%s ip port num_page\\n", argv0);
exit(1);
}
static void recover(void)
{
printf("hello: recovered fr... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void* ptr;
} reaction_struct;
static reaction_struct x;
static reaction_struct y;
static bool even = 1;
static bool mutex_even = 0;
INIT_REACTION()
{
pthread_mutex_init(&x.mutex, 0);
pthread_mutex_init(&y.mutex, 0);
pthread_mutex_lock(&... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc,condp;
int buffer=0;
int total=0;
void *producer(void *ptr)
{
int i=1;
while(total<50)
{
pthread_mutex_lock(&the_mutex);
printf("生产者%lu第%d次使用缓冲区\\n",pthread_self(),i);
while(buffer==10&&tota... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_barrier_t barrier1;
int SharedVariable = 0;
void *SimpleThread(void *args)
{
int num,val;
int which = (int)args;
for(num = 0; num < 20; num++) {
pthread_mutex_lock(&mutex1);
val = Sh... | 1 |
#include <pthread.h>
pthread_mutex_t stats = PTHREAD_MUTEX_INITIALIZER;
unsigned int reqCount = 0, reqAccepted = 0, reqRefused = 0,localReqReplied = 0, externReqReplied = 0;
struct tm startTime;
struct tm lastUpdateTime;
int fd;
void exit_stats()
{
printf("Exited stats manager, %d\\n",getpid... | 0 |
#include <pthread.h>
int * px = 0;
int * py = 0;
pthread_mutex_t mutex_px = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_py = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_fin12 = PTHREAD_COND_INITIALIZER;
void * mon_thread1 (void * arg){
int i;
printf("[Thread1] Deb\\n");
for (i=0... | 1 |
#include <pthread.h>
static pthread_mutex_t _parcAtomicInteger_PthreadMutex = PTHREAD_MUTEX_INITIALIZER;
uint32_t
parcAtomicInteger_Uint32IncrementPthread(uint32_t *value)
{
pthread_mutex_lock(&_parcAtomicInteger_PthreadMutex);
*value = *value + 1;
uint32_t result = *value;
pthrea... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t isEmpty;
char val;
struct Node *next;
struct Node *prev;
}Elemento;
{
Elemento *inicio;
Elemento *fin;
int tamanho;
}LL;
Lista T;
void init(Lista * lista);
int insercion(Lista * lista, char *dato);
char supresion(Lista ... | 1 |
#include <pthread.h>
inline void worker_queue_lock(struct worker_queue *worker_queue) {
pthread_mutex_lock(&worker_queue->mutex);
}
inline void worker_queue_unlock(struct worker_queue *worker_queue) {
pthread_mutex_unlock(&worker_queue->mutex);
}
inline void worker_queue_wakeup_all(struct worke... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("prepareing locks...... \\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent unlo... | 1 |
#include <pthread.h>
void * whattodo( void * arg );
void critical_section( int time );
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main()
{
pthread_t tid[ 8 ];
int i, rc;
int * t;
for ( i = 0 ; i < 8; i++ )
{
t = (int *)malloc( sizeof( int ) );
*t = 2 + i *... | 0 |
#include <pthread.h>
static pthread_mutex_t getpw_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
convert (struct passwd *ret, struct passwd *result,
char *buf, int buflen)
{
int len;
if (!buf) return -1;
*result = *ret;
result->pw_name = (char *) buf;
len = strlen (ret->pw_na... | 1 |
#include <pthread.h>
int recordSize = 1024;
int threadsNr;
char *fileName;
int fd;
int numOfRecords;
int creatingFinished = 0;
char *word;
int rc;
int someonefound = 0;
int detachedNr = 0;
pthread_key_t key;
pthread_t *threads;
int *wasJoin;
pthread_mutex_t mutexForRecords = PTHREAD_MUTEX_INI... | 0 |
#include <pthread.h>
long* a;
long sum;
int veclen;
} CommonData;
CommonData data;
pthread_t threads[4];
pthread_mutex_t mutex;
void* calc(void* arg);
int main (int argc, char *argv[]){
long i, sum = 0;
void* status;
long* a = (long*) malloc (4*100*sizeof(long));... | 1 |
#include <pthread.h>
pthread_mutex_t exclusion;
int sum = 0;
void *computeThread(void *arg) {
int nr = *(int *) arg;
printf("Receiving: %d\\n", nr);
pthread_mutex_lock(&exclusion);
sum += nr;
pthread_mutex_unlock(&exclusion);
free(arg);
}
int main(int argc, char *argv[]) {
pthread_t th... | 0 |
#include <pthread.h>
void join_threads(pthread_t *, int);
void spawn_threads(pthread_t *, int);
void initialize(int *, int, char *[]);
void * collatz(void *);
int compute_stopping_time(unsigned int);
void generate_csv();
int HISTOGRAM[1000];
int COUNTER = 2;
int ... | 1 |
#include <pthread.h>
{
int buf[10];
int in;
int out;
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
} sbuf_t;
sbuf_t shared;
void *Producer(void *arg)
{
int i, item, index;
index = (int)arg;
for (i=0; i < 6; i++)
{
item = i;
sem_w... | 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);
printf("==>there is lock1\\n");
p... | 1 |
#include <pthread.h>
struct readerArgs
{
int fd;
size_t number;
};
ssize_t pgetLine(int fd, char *str, size_t maxLength, off_t offset);
void getCurrentTime(char *str, size_t maxLength);
void* readerFunc(readerArgs *args);
void* writerFunc(void *fd);
void clearResources(int fd);
pthread_mu... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t notfull = PTHREAD_COND_INITIALIZER;
pthread_cond_t notempty = PTHREAD_COND_INITIALIZER;
int top = 0;
int bottom = 0;
void *produce(void *arg) {
int i;
for (i = 0; i < 5 * 2; i++) {
pthread_mutex_lock... | 1 |
#include <pthread.h>
int j;
int tab[10];
}soma;
soma *soma_init(int ide){
soma *p;
p = malloc(sizeof(soma));
p->j=ide;
p->tab[p->j]=ide;
return p;
}
soma *modifier(soma*p1,soma*p2){
p1->tab[p2->j]=p2->j;
return p1;
}
int tabu(soma*p1,int l){
int i;
int s;
for (i=0;i<l+1;... | 0 |
#include <pthread.h>
pthread_mutex_t turn = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cons, prod;
int itens = 100;
void* consumidor() {
while(1) {
pthread_mutex_lock(&turn);
if (itens == 0) pthread_cond_broadcast(&prod);
itens--;
if (itens < 100) pth... | 1 |
#include <pthread.h>
struct unit_s
{
pthread_mutex_t rarex;
unsigned int value[1];
};
struct unit_s unit_arr[4];
clock_t time_usage[4];
void *
accessor(void *data)
{
int i;
unsigned int norand = lrand48();
unsigned int value[1];
int thread_number = *(int *)data;
ti... | 0 |
#include <pthread.h>
int entradasAbtas=0;
int valvulasAbtas=0;
int abrirentrada=0;
int cerrarentrada=0;
pthread_mutex_t me;
pthread_mutex_t mv;
pthread_cond_t abrirE;
pthread_cond_t cerrarE;
pthread_cond_t vValvula;
void * valvula (void *n){
while(1) {
pthread_mutex_lock(&mv);
... | 1 |
#include <pthread.h>
_dataType data;
struct _node* next;
}node,*nodep,**nodepp;
nodep head = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
nodep buyNode(_dataType val)
{
nodep tmp = (nodep)malloc(sizeof(node));
if(tmp!= 0)
{
tmp->data = val;
tmp->next = 0;
return tmp;
}
ret... | 0 |
#include <pthread.h>
pthread_mutex_t mutex[8];
void unit_work(void)
{
volatile int i;
volatile int f,f1,f2;
f1 =12441331;
f2 = 3245235;
for (i = 47880000; i > 0; i--) {
f *= f1;
f1 *= f2;
f1 *= f2;
f2 *= f;
... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail... | 0 |
#include <pthread.h>
{
int buffer[8];
pthread_mutex_t mutex;
pthread_cond_t notfull;
pthread_cond_t notempty;
int write_pos;
int read_pos;
}pc_st;
pc_st pc;
int init_pc(pc_st *pt, pc_st *attr)
{
if(0 != attr)
{
printf("attr is error value!\\n");
... | 1 |
#include <pthread.h>
{
char user[5];
char process;
int arrival;
int duration;
struct node *next;
}node;
{
node *R,*F;
}Q;
struct display
{
char user[5];
int timeLastCalculated;
struct display *next;
} *frontDisplay, *tempDisplay, *rearDisplay;
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIAL... | 0 |
#include <pthread.h>
int *input;
int *pOutput;
int *sOutput;
int *bias;
int *partials;
int n;
int numProc;
int thread_count=0;
int chunk;
pthread_mutex_t sync_mutex;
pthread_cond_t sync_cv, main_cv;
pthread_attr_t attr;
void sequential( int *, int , int * );
void* parallel( void * );
void pri... | 1 |
#include <pthread.h>
struct pParam {
int tid, tsize;
int bound;
int mrank, msize;
int *primecount;
pthread_mutex_t *lock;
};
void *findPrime(void *param)
{
int i, j, test, start, increment, runningcount = 0;
struct pParam *p = (struct pParam *)param;
start = (((p->tid * p->msize) + p->... | 0 |
#include <pthread.h>
int quit,sum;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc =PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int i = *(int *)arg;
printf("thr_fn\\n");
if (i==0){
printf("the transfer the param success\\n");
while(i<=100){
... | 1 |
#include <pthread.h>
static inline int sht21_temp_ticks_to_millicelsius(int ticks){
ticks &= ~0x0003;
return ((21965 * ticks) >> 13) - 46850;
}
inline int sht21_rh_ticks_to_per_cent_mille(int ticks){
ticks &= ~0x0003;
return ((15625 * ticks) >> 13) - 6000;
}
int sht21_function... | 0 |
#include <pthread.h>
int auti_na_mostu = 0, proslo = 0;
int smjer_most = 2;
int *smjer_auta;
int cekaju[2] = {0};
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t uvjet_lijevi = PTHREAD_COND_INITIALIZER;
pthread_cond_t uvjet_desni = PTHREAD_COND_INITIALIZER;
void popniSeNaMost (... | 1 |
#include <pthread.h>
static int fd;
pthread_t tid1,tid2;
struct task task1,task2;
pthread_mutex_t mutex;
struct task tt;
void my_signal_fun(int signum)
{
struct task t;
int ret;
t.pid=getpid();
ret=ioctl(fd,IO_READ_TASK,&t);
if(ret!=0)
return ;
pthread_mutex_lock(&mutex);
tt=t;
... | 0 |
#include <pthread.h>
extern int makepthread(void *(*)(void*), void *);
struct to_info{
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void *timeout_helper(void*arg)
{
struct to_info *tip;
tip = (struct to_info*)arg;
nanosleep(&tip->to_wait, 0);
(*tip->to_fn)(tip->to_a... | 1 |
#include <pthread.h>
extern struct protoent_data _protoent_data;
struct protoent *
getprotobynumber(int proto)
{
struct protoent *p;
pthread_mutex_lock(&_protoent_mutex);
p = getprotobynumber_r(proto, &_protoent_data.proto, &_protoent_data);
pthread_mutex_unlock(&_protoent_mutex);
retur... | 0 |
#include <pthread.h>
int A[1000][1000],
B[1000][1000],
noOfOnes,
countOperation = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t operation = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t opcond = PTHREAD_COND_INITIALIZER;
{
int threadID;
}thread_data;
int Coun... | 1 |
#include <pthread.h>
int __po_hi_transport_need_receiver_task();
void __po_hi_initialize_transport ();
pthread_cond_t cond_init;
pthread_mutex_t mutex_init;
int initialized_tasks;
int nb_tasks_to_init;
int __po_hi_initialize ()
{
if (pthread_mutex_init (&mutex_init, 0) != 0 )
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mutexPoolLista = PTHREAD_MUTEX_INITIALIZER;
struct Poolstruct * listaPools [1000];
int listaPoolTop;
struct Poolstruct * listaPool_newPool (){
pthread_mutex_lock( &mutexPoolLista );
int listaPoolTopActual = listaPoolTop... | 1 |
#include <pthread.h>
static pthread_mutex_t stream_mutex[STREAM_SEM_NUM];
int Sem_Creat( int index )
{
if( index < 0 || index >= STREAM_SEM_NUM)
{
fprintf(stderr, "Error: " "Sem_Creat index faill!!\\n");
return -1;
}
if( pthread_mutex_init(&stream_mutex[index], 0) != 0 )
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thrd_func(void *arg)
{
int thrd_num = (int)arg;
int delay_time = 0, count = 0;
int res;
res = pthread_mutex_lock(&mutex);
if (res)
{
printf("Thread %d lock failed\\n", thrd_num);
pthread_exit(0);
}
printf("Thread %d is starting... | 1 |
#include <pthread.h>
char * tasks[200];
int consumerIndex = 0;
int producerIndex = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t fill = PTHREAD_COND_INITIALIZER;
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
void put(char inputBuffer[80]) {
pthread_mutex_lock(&mute... | 0 |
#include <pthread.h>
{
char car[5];
char direction;
int arrival;
struct node *next;
}node;
{
node *R,*F;
}Q;
struct display
{
char car[5];
char direction;
struct display *next;
} *northDisplay, *tempDisplay, *southDisplay;
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t ... | 1 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo* foo_alloc(void) {
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(... | 0 |
#include <pthread.h>
static pthread_mutex_t ntx = PTHREAD_MUTEX_INITIALIZER;
struct _zhead;
struct list_hdr list;
struct _zhead *head;
int nr;
} znode_t;
struct list_hdr list;
struct _znode *curr;
} zhead_t;
static struct list_hdr free_node = {&free_node, &free_node};
static zhead_t nh... | 1 |
#include <pthread.h>
char buffer[100];
pthread_t ctid[10];
pthread_t ptid[5];
FILE *fpprod,*fpcons;
pthread_mutex_t mutex;
sem_t full,empty;
int counter,flag;
void *prod(void *arg);
void *cons(void *arg);
void initialize();
void insert_item();
void delete_item();
char switchBuffer();
... | 0 |
#include <pthread.h>
int SharedVariable = 0;
pthread_mutex_t mutex;
pthread_barrier_t barr;
void SimpleThread(int which) {
int num, val;
for(num = 0; num < 20; num++) {
if (random() > 32767 / 2){
usleep(10);
}
pthread_mutex_lock(&mutex);
val = SharedVariable;
... | 1 |
#include <pthread.h>
int shared_var = 0;
int readcount = 0;
sem_t sem_readers_done;
sem_t sem_access;
pthread_mutex_t mutex_readcount;
void initialize()
{
sem_init(&sem_readers_done,0,1);
sem_init(&sem_access,0,1);
pthread_mutex_init(&mutex_readcount,0);
}
void* reader(void *data)... | 0 |
#include <pthread.h>
char *nombre, *pareja;
int listo;
struct nodo *prox;
} Nodo;
void bailar_con(char * pareja){}
void alimentarse(){}
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
Nodo *mujeres;
Nodo *hombres;
void emparejar(char sexo,... | 1 |
#include <pthread.h>
data_t input_vec[4];
data_t ***SV;
int NUM_EL[4];
int MAX_EL = 800;
pthread_t thread[4 - 1];
pthread_barrier_t barr;
pthread_mutex_t lock;
float GLOB_SUM = 0;
void get_data(int rank, data_t** SV)
{
char filename[256] = {"input_svm/model_"};
int base_fname_lengt... | 0 |
#include <pthread.h>
pthread_mutex_t order_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *functionorder1();
void *functionorder2();
int order = 1;
main()
{
pthread_t thread1, thre... | 1 |
#include <pthread.h>
int host_handler(int sig){
printf("SIGUSR2 catched\\n");
return 0;
}
void hostPlSend(struct sthread* ptr){
msg_send(ptr->desc, MSG_HOST_PL, sizeof(int), &team_arr[ptr->team_id].pl_cnt);
}
void hoStatSend(struct sthread* ptr){
}
void team_gameplay(struct sthread... | 0 |
#include <pthread.h>
void* thread_task(void* param);
static const unsigned g_UNSIGNED_NBITS = sizeof(unsigned) * CHAR_BIT;
static const unsigned g_PID_ARR_LENGTH =
((5000 - 300) + sizeof(unsigned)*CHAR_BIT - 1)/(sizeof(unsigned)*CHAR_BIT);
static unsigned* g_pid_table;
static pthread_mu... | 1 |
#include <pthread.h>
struct threadSafeList* threadList;
struct threadSafeList* SHList;
struct threadSafeList * listCreate() {
struct threadSafeList *list = (struct threadSafeList *) malloc(sizeof(struct threadSafeList));
list->count = 0;
list->head = 0;
list->tail = 0;
pthread_mutex_init(... | 0 |
#include <pthread.h>
pthread_mutex_t locki[26];
pthread_mutex_t lockb[26];
int busy[26];
int inode[32];
pthread_t tids[26];
void *thread_routine(void * arg)
{
int i,b;
int tid;
tid = (int)arg;
i = tid % 32;
pthread_mutex_lock( &locki[i] );
if( inode[i]==0 )
{
b = ... | 1 |
#include <pthread.h>
void __VERIFIER_error() { abort(); };
int __VERIFIER_nondet_int() {int n; return n;}
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;
}
vo... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.