text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
union recv_msgs
{
struct reg_msg client_msg;
struct _pulse pulse;
uint16_t type;
} recv_buf;
int save_rcvid = 0;
int save_scoid = 0;
struct sigevent save_event;
int notify_count = 0;
pthread_mutex_t save_data_mutex;
void * notify_thread( void * ignore);
... | 1 |
#include <pthread.h>
long *items;
long num_items;
long next_item;
pthread_mutex_t mutex;
} tasks_t;
long next(tasks_t *tasks) {
long ret = -1;
pthread_mutex_lock(&tasks->mutex);
if(tasks->next_item < tasks->num_items) {
ret = tasks->items[tasks->next_item];
... | 0 |
#include <pthread.h>
int count = 0;
void __VERIFIER_atomic_inc()
{
__atomic_begin();
count++;
__atomic_end();
}
void __VERIFIER_atomic_dec()
{
__atomic_begin();
count--;
__atomic_end();
}
pthread_mutex_t mutexa,mutexb;
void my_thread1() {
pthread_mutex_lock(&mutexa);
__VERIFI... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int sum = 0;
void *inc(void *arg) {
int i = (*(int *)arg);
pthread_mutex_lock(&mutex);
sum = sum + i;
pthread_mutex_unlock(&mutex);
return 0;
}
int main(int argc, char *argv[]) {
pthread_t pt[1... | 0 |
#include <pthread.h>
struct thread_args {
int tid;
int inc;
int loop;
};
int count = 0;
pthread_mutex_t count_mutex;
void *inc_count(void *arg)
{
int i,loc;
struct thread_args *my_args = (struct thread_args*) arg;
loc = 0;
for (i = 0; i < my_args->loop; i++) {
pt... | 1 |
#include <pthread.h>
int thID;
int min;
int max;
} arg;
int **a;
int c = 0;
int N, M, T;
pthread_mutex_t mx;
void tres (arg *args) {
int i, j;
for (i=args->min; i<args->max; i++) {
for (j=0; j<M; j++) {
if (a[i][j] == 3) {
pthread_mutex_lock(&mx);
c++;
... | 0 |
#include <pthread.h>
int check_path(char *path);
int check_path(char *path) {
int ptr;
size_t pathlen;
int depth;
pathlen = strlen(path);
depth = -1;
for (ptr = 0; ptr < pathlen; ++ptr) {
if (path[ptr] == '\\\\')
path[ptr] = '/';
if (path[ptr] == '/') {
++depth;
} else... | 1 |
#include <pthread.h>
void *packer_function(void *ptr){
const char *COLORS[] = {"AliceBlue","AntiqueWhite","Aqua","Aquamarine","Azure","Beige","Bisque","Black","BlanchedAlmond","Blue","BlueViolet","Brown","BurlyWood","CadetBlue","Chartreuse","Chocolate","Coral","CornflowerBlue","Cornsilk","C... | 0 |
#include <pthread.h>
int ips[MAX_SERVERS];
int cuotas [MAX_SERVERS];
char *retos[MAX_SERVERS];
int inventario;
int capMax;
int tiempo_actual;
int suministro;
FILE *LOG;
pthread_mutex_t mutex;
int tiempo_respuesta;
void *llevar_tiempo(void *arg_tiempo){
int *tiempo= (int*) arg_tiempo;
... | 1 |
#include <pthread.h>
pthread_mutex_t ma[10];
pthread_mutex_t mi;
int i = 0;
void *counter()
{
int x;
for (x = 1; x < 10; x++)
{
pthread_mutex_lock(&mi);
i = x;
pthread_mutex_unlock(&mi);
}
return 0;
}
void *wa(void *aux)
{
long x = (long) aux;
pthread_mutex_lock(... | 0 |
#include <pthread.h>
void *producer (void *args);
void *consumer (void *args);
int buf[10];
long head, tail;
int full, empty;
pthread_mutex_t *mut;
pthread_cond_t *notFull, *notEmpty;
} queue;
queue *queueInit (void);
void queueDelete (queue *q);
void queueAdd (queue *q,... | 1 |
#include <pthread.h>
const unsigned char AD_LASER_A = 0x00;
const unsigned char AD_LASER_B = 0x01;
const unsigned char AD_LASER_C = 0x02;
const unsigned char AD_LASER_D = 0x03;
const unsigned char AD_LASER_SUM = 0x04;
const unsigned char AD_OSAP = 0x05;
const unsigned char AD_FICTION = 0x0... | 0 |
#include <pthread.h>
int count = 0;
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) {
printf("inc_count... | 1 |
#include <pthread.h>
void search_dir_recursively (char *pathname);
pthread_mutex_t scandir_mutex = PTHREAD_MUTEX_INITIALIZER,
printf_mutex = PTHREAD_MUTEX_INITIALIZER,
active_mutex = PTHREAD_MUTEX_INITIALIZER;
int num_threads_active = 1;
pthread_cond_t threa... | 0 |
#include <pthread.h>
int size, filehandle, c, sock2;
char buf[100];
struct stat obj;
pthread_mutex_t lock_ls;
pthread_mutex_t lock_cd;
pthread_t main_tid;
void* List(void *arg)
{
pthread_mutex_lock(&lock_ls);
system("ls >temps.txt");
stat("temps.txt",&obj);
size = obj.st_size;
sen... | 1 |
#include <pthread.h>
enum fstat {
FSTAT_EMPTY,
FSTAT_USED,
FSTAT_CLOSED,
FSTAT_NUM
};
struct fd_entry {
time_t access_time;
enum fstat fstat;
pthread_mutex_t lock;
};
extern int loglevel;
extern FILE *debugfp;
static inline void debug_log(const char *action, int fd)
{
if (loglevel > ... | 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++;
i... | 1 |
#include <pthread.h>
int arr[1000][1000];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void initArray()
{
int i = 0;
int j = 0;
for (i = 0; i < 1000; i++)
{
for (j = 0; j < 1000; j++)
{
srand(time(0));
arr[i][j] = rand() % 100;
... | 0 |
#include <pthread.h>
pthread_mutex_t lock_r;
pthread_mutex_t lock_s;
int sharedData;
} buffer;
int tot = 0;
buffer buf = { .sharedData = 0 };
int store(int item, buffer *pb){
pb->sharedData = item;
}
int retrieve(buffer *pb){
int item = pb->sharedData;
pb->sharedData = 0;
return it... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
main()
{
pthread_t thread1... | 0 |
#include <pthread.h>
static pthread_mutex_t fileMutex = PTHREAD_MUTEX_INITIALIZER;
void fileAccessor_enableI2cBus() {
pthread_mutex_lock(&fileMutex);
{
FILE *slots = fopen("/sys/devices/platform/bone_capemgr/slots", "w");
if(slots == 0) {
printf("Unable to open file (%s) for writing\\... | 1 |
#include <pthread.h>
int sharedVariable = 0;
pthread_mutex_t mymutex;
pthread_barrier_t barr;
void *SimpleThread(void *id){
int num, val;
int threadid = (int)id;
for(num = 0 ; num < 20 ; num++){
if(random() > 32767/2)
usleep(10);
val = sharedVariable;
printf("***thread %d see... | 0 |
#include <pthread.h>
pthread_mutex_t atomic64;
pthread_mutex_t atomic32;
int64_t atomicRead64(int64_t* i) {
pthread_mutex_lock(&atomic64);
int64_t r = *i;
pthread_mutex_unlock(&atomic64);
return r;
}
void atomicWrite64(int64_t* i, int64_t v) {
pthread_mutex_lock(&atomic64);
*i = v;
... | 1 |
#include <pthread.h>
static pthread_t alloc_mine;
static pthread_mutex_t * alloc_lock;
static pthread_cond_t * alloc_clear;
static unsigned int alloc_inuse;
static void enter_alloc(void)
{
if (pthread_equal(pthread_self(), alloc_mine))
return;
pthread_mutex_lock(alloc_lock);
alloc_inuse++;
... | 0 |
#include <pthread.h>
pthread_mutex_t memory_mutex = PTHREAD_MUTEX_INITIALIZER;
extern int mmcamera_stacktrace(intptr_t* addrs, size_t max_entries);
struct hdr_t {
struct hdr_t *prev;
struct hdr_t *next;
intptr_t bt[15];
int bt_depth;
};
static unsigned num;
static hdr_t *l... | 1 |
#include <pthread.h>
char buf[2][8*16*1024];
int buf_len[2] = {0, 0};
pthread_mutex_t b0mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t b1mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t b0cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t b1cond = PTHREAD_COND_INITIALIZER;
int done = 0;
... | 0 |
#include <pthread.h>
int x = 0;
pthread_mutex_t x_mutex;
pthread_cond_t x_cond;
void *B (void *t) {
int boba1, boba2;
printf("B: Comecei\\n");
boba1=10000; boba2=-10000; while (boba2 < boba1) boba2++;
printf("BYE BYE\\n");
pthread_mutex_lock(&x_mutex);
x++;
printf("B... | 1 |
#include <pthread.h>
struct responce_times {
struct timeval start_time;
struct timeval end_time;
int responce_time;
};
int atack_start = 0;
char *host = 0;
char *path = 0;
int *ilist = 0;
pthread_mutex_t mutex;
struct responce_times *responce_list = 0;
int responce_i = 0;
void *at... | 0 |
#include <pthread.h>
sem_t *empty = 0;
sem_t *full = 0;
pthread_mutex_t mutex;
void *producer(void *arg) {
int i;
int loops = 4;
for (i = 1; i < 4; i++) {
pthread_mutex_lock(&mutex);
sem_wait(empty);
put(i);
sem_post(full);
pthread_... | 1 |
#include <pthread.h>
int flag = 0;
pthread_mutex_t m;
pthread_cond_t c;
void * func(void *p)
{
while(1){
pthread_mutex_lock(&m);
if(!flag){
pthread_cond_wait(&c,&m);
}
pthread_mutex_unlock(&m);
write(STDOUT_FILENO,p,1);
sleep(1);
}
return 0;
}
int main()
... | 0 |
#include <pthread.h>extern void __VERIFIER_assume(int);
extern void __VERIFIER_error() ;
int block;
int busy;
int inode;
pthread_mutex_t m_inode;
pthread_mutex_t m_busy;
void *allocator(){
pthread_mutex_lock(&m_inode);
if(inode == 0){
pthread_mutex_lock(&m_busy);
busy = 1;
pthre... | 1 |
#include <pthread.h>
pthread_mutex_t mutexsum;
void display(char *str)
{
char *tmp;
for(tmp = str;*tmp;tmp++) {
write(1,tmp,1);
usleep(100);
}
}
void *run(void *param) {
int i;
for(i = 0; i < 10; i++) {
pthread_mutex_lock(&mutexsum);
displa... | 0 |
#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(struct foo))) != 0) {
f... | 1 |
#include <pthread.h>
void *functionA();
void *functionB();
int var_A, var_B = 0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
int main(){
pthread_t thread1, thread2;
int rc1, rc2;
printf("\\033[2J");
printf("Deadlock... | 0 |
#include <pthread.h>
pthread_mutex_t count_lock=PTHREAD_MUTEX_INITIALIZER;
int count=0;
void r1(char *fname, int x, char **bufp)
{
double temp;
int local_count=0;
int fd;
for (local_count = 0; local_count < 1000; local_count++) {
temp = sqrt(x);
fd = open(fname,O_CR... | 1 |
#include <pthread.h>
int mediafirefs_releasedir(const char *path, struct fuse_file_info *file_info)
{
printf("FUNCTION: releasedir. path: %s\\n", path);
(void)path;
(void)file_info;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pthread... | 0 |
#include <pthread.h>
long mtype;
char mtext[128];
} message_buf;
char file[][10]={"add 3 4","add 1 5","add 5 5","add 6 5","add 9 2","add 1 7"};
pthread_mutex_t lock;
int msqid,msqid1;
int flag[5];
void *send(void *name)
{
if ((msqid = msgget(123,IPC_CREAT|0666)) <... | 1 |
#include <pthread.h>
struct jc_mode_once {
pthread_mutex_t mutex;
int once;
};
static struct jc_mode_once global_once;
static int
jc_mode_once_init(
struct jc_comm *jcc
)
{
if (jcc->mode_type)
free(jcc->mode_type);
jcc->mode_type = strdup("once");
return JC_OK;
}
static int
jc_mode_o... | 0 |
#include <pthread.h>
int counter;
pthread_mutex_t mutexcounter;
void* updateCounter(void* t){
int i;
long tid;
tid = (long)t;
printf("Thread %ld starting...\\n",tid);
pthread_mutex_lock (&mutexcounter);
for (i=0; i<100000; i++){
counter++;
}
pthread_mutex_unlock (&mutexcounter);
printf... | 1 |
#include <pthread.h>
struct data{
int number;
int isPrime;
int come;
long which;
};
struct data *list;
int counter =0,until;
pthread_mutex_t mutex;
void *PrimeNumber(void *arg){
int i,a,count=0,num;
long id=(long)arg;
i=0;
pthread_mutex_lock (&mutex);
while(i<until-2){
if(list[i]... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void* another( void* arg )
{
printf( "in child thread, lock the mutex\\n" );
pthread_mutex_lock( &mutex );
sleep( 5 );
pthread_mutex_unlock( &mutex );
}
void prepare()
{
pthread_mutex_lock( &mutex );
}
void infork()
{
pthread_m... | 1 |
#include <pthread.h>
sem_t empty_num, product_num;
pthread_mutex_t mutex;
int buffer[4];
int begin = 0, end = 0, counter = 0, max = 4;
void *producer( void *arg )
{
printf("pthread producer id : %d run \\n", *(int *)arg );
srand(1);
while( 1 )
{
sem_wait( &empty_num );
pthread_mut... | 0 |
#include <pthread.h>
pthread_mutex_t flaglock;
int flag = 1;
void *hello(void *p)
{
while(1)
{
pthread_mutex_lock(&flaglock);
if(1 != flag)
{
pthread_mutex_unlock(&flaglock);
continue;
}
pthread_mutex_unlock(&flaglock);
printf("hello\\n");
pthread_mutex_lock(&flaglock);
... | 1 |
#include <pthread.h>
int nitems;
int buff[1000000];
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
int nput=0;
int nval=0;
int nready=0;
void *produce(void *), *consume(void *);
int
main(int argc, char **argv)
{
int i, nthreads, c... | 0 |
#include <pthread.h>
pthread_mutex_t bloqueo;
const int scalar = 2;
const int matrix[3][4]=
{
{1, 5, 6, 7},
{4, 4, 8, 0},
{2, 3, 4, 5}
};
int x=3,y=4;
int matrixsol[3][4];
int i,j=0;
int *mytid;
void *multiplicar(void *tid)
{
mytid=(int *) tid;
pthread_mutex_lock (&bloqueo);
for... | 1 |
#include <pthread.h>
sem_t sem;
int count = 0;
pthread_mutex_t mcount = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t msem = PTHREAD_MUTEX_INITIALIZER;
void init()
{
pthread_mutex_lock( &mcount );
count = 0;
pthread_mutex_lock( &msem );
pthread_mutex_unlock( &mcount );
}
void wa... | 0 |
#include <pthread.h>
static unsigned long MemoryPoolSize1=1024*1024*32;
static unsigned long MemoryPoolSize2=1024*1024*1;
static struct rb_root* g_table=0;
static pthread_mutex_t g_ipv4status_lock;
unsigned long get_ipv4_status(unsigned char*ip)
{
unsigned long flags;
unsigned long stat... | 1 |
#include <pthread.h>
FILE *io_m5;
static struct
{
pthread_t thread;
int (*handler)();
bool handler_started;
pthread_cond_t data_avail;
} trans = {.handler_started = 0, .data_avail = PTHREAD_COND_INITIALIZER};
void io_m5_init(char const *path)
{
io_m5 = fopen(path, "r+");
if (!io_m5... | 0 |
#include <pthread.h>
void
ports_resume_all_rpcs ()
{
pthread_mutex_lock (&_ports_lock);
assert_backtrace (_ports_flags & _PORTS_INHIBITED);
_ports_flags &= ~_PORTS_INHIBITED;
if (_ports_flags & _PORTS_BLOCKED)
{
_ports_flags &= ~_PORTS_BLOCKED;
pthread_cond_broadcast (&_por... | 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;
int f_id;
struct foo *f_next;
};
struct foo* foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struc... | 0 |
#include <pthread.h>
int32_t count = 0;
pthread_mutex_t lock;
pthread_cond_t cond_var;
void *IncrementFunction(void* arg)
{
pthread_mutex_lock(&lock);
if (count == 0)
{
printf("Count in inc: %d\\n", count);
pthread_cond_signal(&cond_var);
}
count += 1;
printf("In Increment thre... | 1 |
#include <pthread.h>
pthread_mutex_t mutexes[2];
pthread_cond_t conditionVars[2];
int permits[2];
pthread_t tids[2];
int data = 0;
void * Philosopher(void * arg){
int i;
i = (int)arg;
pthread_mutex_lock(&mutexes[i%2]);
while (permits[i%2] == 0) {
pthread_cond_wait(&conditionVars... | 0 |
#include <pthread.h>
void thinking_init(struct philosopher *ph)
{
int i;
for (i = 0; i < NR; i++) {
memset((ph + i)->hands, 0x00, sizeof((ph + i)->hands));
(ph + i)->status = THINKING;
(ph + i)->ith = i;
printf("%p = status %d %d\\n", (ph + i), (ph + i)->status,
(ph + i)-... | 1 |
#include <pthread.h>
pthread_mutex_t clock_mutex;
int stopsignal = 0;
double lastupdate = 0;
int clocks_cycle(int nextcycle){
int cnext = cpu_update(nextcycle);
int pnext = ppu_update(nextcycle/4)*4;
nextcycle = cnext > pnext ? pnext:cnext;
if(nextcycle == 0)
nextcyc... | 0 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_spinlock_t spinlock;
static void * my_func_pmutex( void *arg){
volatile mytype *p = (mytype *) arg;
for( int i = 0; i < 10000000 ; i++){
pthread_mutex_lock(&mut);
(*p)++;
pthread_mutex... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc,condp;
int buffer = 0;
int total_pro = 0;
int total_con = 0;
void *producer(void *ptr)
{
while (total_pro < 50){
pthread_mutex_lock(&the_mutex);
while (buffer == 10){
pthread_t tid = pthread_self();
... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
extern int __VERIFIER_nondet_int();
int idx=0;
int ctr1=1, ctr2=0;
int readerprogress1=0, readerprogress2=0;
pthread_mutex_t mutex;
void __VERIFIER_atomic_use1(int myidx) {
__VERIFIER_assume(myidx <= 0 && ctr1>0);
ctr1++;
}
void __V... | 1 |
#include <pthread.h>
static inline double timestamp(void) {
struct timeval tv;
gettimeofday(&tv, 0);
return tv.tv_sec + tv.tv_usec / 1000000.0;
}
pthread_mutex_t uber_locks[4];
double uber_times[4];
volatile double inside[4];
volatile double outside[4];
int in_use;
static inline doubl... | 0 |
#include <pthread.h>
static pthread_mutex_t accept_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t accept_condvar = PTHREAD_COND_INITIALIZER;
struct esync {
pthread_mutex_t e_mt;
pthread_cond_t e_cond;
};
static void
echoer_callback(int fd, enum ev_type type, void *param)
{
st... | 1 |
#include <pthread.h>
struct acdb_fts {
FILE *file_handles[100];
pthread_mutex_t lock;
};
static struct acdb_fts *fts_info;
static int process_open_request(struct ACPH_FTS_CMD_OPEN_FILE_req *open_req,
struct ACPH_FTS_CMD_OPEN_FILE_resp *resp,
... | 0 |
#include <pthread.h>
int saldo_inicial = 500;
pthread_mutex_t mutex;
int main5(void) {
pthread_mutex_init (&mutex, 0);
pthread_t h1, h2;
pthread_create(&h1, 0, compras_mensuales, "Julieta");
pthread_create(&h2, 0, compras_mensuales, "Leo");
pthread_join(h1, (void **) 0);
p... | 1 |
#include <pthread.h>
struct list* next;
int data;
}Node,*PNode;
Node* head;
pthread_cond_t procon=PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
void initlist(PNode* head)
{
*head=0;
}
void* consumer(void* val)
{
int i=1;
while(i)
{
Node* tmp=0;
pthread_mutex... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
void __VERIFIER_assert(int cond) { if (!(cond)) { ERROR: __VERIFIER_error(); } return; }
extern int __VERIFIER_nondet_int(void);
double a[1000];
int count ,num_threads,iterations;
double search_no ;
pthread_mutex_t count_mutex;
void *fin... | 1 |
#include <pthread.h>
int ringbuffer[(5)];
unsigned reader_unread = 0;
unsigned writer_next = 0;
pthread_mutex_t ringbuffer_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t ringbuffer_written_cond = PTHREAD_COND_INITIALIZER;
void process_code(int ch) {
int counter;
printf("Processing co... | 0 |
#include <pthread.h>
static void
worker_state_wait_for_transition(struct benchmark_worker *worker,
enum benchmark_worker_state state,
enum benchmark_worker_state new_state)
{
while (worker->state == state)
pthread_cond_wait(&worker->cond, &worker->lock);
assert(worker->state == new_sta... | 1 |
#include <pthread.h>
sem_t *empty = 0;
sem_t *full = 0;
pthread_mutex_t mutex;
void *producer(void *arg) {
int i;
int loops = 4;
for (i = -4; i <= -1; ++i) {
sem_wait(empty);
pthread_mutex_lock(&mutex);
put(i);
pthread_mutex_unlock(&mutex);
... | 0 |
#include <pthread.h>
unsigned int g_ulClkRunning = NS_FALSE;
unsigned int g_ulElapsedTick = 0;
unsigned short g_usFrameNo = MAX_FRM_RANGE-1;
unsigned char g_ucSubFrmNo = MAX_SUBFRM_RANGE-1;
pthread_t g_tidClk;
pthread_attr_t g_attrClk;
pthread_cond_t g_condClk;
pthread_condattr_t g_condAt... | 1 |
#include <pthread.h>
long buf[100];
int count = 0;
pthread_mutex_t lock;
pthread_cond_t notfull;
pthread_cond_t notempty;
int producer_index = 0;
int consumer_index = 0 ;
void init() {
pthread_mutex_init(&lock, 0);
pthread_cond_init(¬full, 0);
pthread_cond_init(¬empty, 0... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
sem_t sem;
SharedInt* sip;
void functionInsideCriticalSection();
void functionInsideCriticalSection() {
pthread_mutex_unlock(&(sip->lock));
printf("Value is currently: %i\\n", sip->value);
pthread_mutex_lock(&... | 1 |
#include <pthread.h>
void *whatsapp();
void *chat();
void *Producer();
void *Consumer();
int sock,cli;
pthread_cond_t Buffer_Not_Full=PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar=PTHREAD_MUTEX_INITIALIZER;
struct sockaddr_in server,cli... | 0 |
#include <pthread.h>
int npos;
int buf[10000000], pos=0, val=0;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
sem_t sem;
void *fill(void*);
void *verify(void*);
int main(int argc, char* argv[])
{
int k, nthr, count[100], total;
pthread_t tidf[100], tidv;
if (argc!=3) {
printf("... | 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>
pthread_mutex_t mutex;
struct _ti {
pthread_mutex_t exit;
int i;
};
int y;
void *inc_x(void *x_void_ptr)
{
ti *x_pt = (ti *)x_void_ptr;
while(y < 10000) {
pthread_mutex_lock(&mutex);
if(y < 10000) {
y++;
}
pthr... | 1 |
#include <pthread.h>
uint32_t bytes_tx;
uint32_t bytes_rx;
uint64_t total_bytes_tx;
uint64_t total_bytes_rx;
uint32_t tx_rate;
uint32_t rx_rate;
uint8_t interval;
struct timespec timer;
pthread_mutex_t lock;
pthread_t stats_thread;
} TXRXStats;
TXRXStats *stats_create(uint8_t ... | 0 |
#include <pthread.h>
extern FILE *fileout_dijkstra;
extern FILE *filein_dijkstra;
extern pthread_mutex_t mutex_print;
struct _NODE
{
int iDist;
int iPrev;
};
struct _QITEM
{
int iNode;
int iDist;
int iPrev;
};
QITEM static_queue[500];
int qBegin = -1;
int qTail = -1;
... | 1 |
#include <pthread.h>
FILE *fp1,*fp2;
int file_size;
char buf[100];
volatile char read_size=0;
volatile char buf_ready =0;
volatile char end_file =0;
pthread_mutex_t pthread_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t pthread_cond = PTHREAD_COND_INITIALIZER;
int buf_compare(cha... | 0 |
#include <pthread.h>
static int cant_hilos;
static int resto;
static pthread_mutex_t lock;
static int tarea = -1;
static int A[600][600], B[600][600], C[600][600];
struct indices
{ int i, j;
};
void cargarMatrices();
void realizarTarea(indice indiceGral);
void *mapearTarea(void *);
indice ge... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
int count;
} sema_t;
sema_t semaphore = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 1};
void cleanup_mutex(void *arg)
{
printf("\\tthread %lx: cleanup/unlock_mutex\\n", pthread_self());
pthread_mutex_un... | 0 |
#include <pthread.h>
static void *zero_thread_main(void *arg);
struct zero_threadpool_t *threadpool_init(int number_of_threads)
{
if (number_of_threads <= 0) {
log_err("number_of_threads must greater than 0");
return 0;
}
struct zero_threadpool_t *pool;
pool = (struct zero_threadpool_t*... | 1 |
#include <pthread.h>
struct global_info
{
int *X;
int *Y;
int Sum;
int Len;
} data;
pthread_mutex_t lock;
int thread;
void * dotprod (void *arg)
{
int i;
int sum = 0;
long tid = (long) arg;
for (i = tid; i < data.Len; i+=thread)
{
sum += (data.X[i] * data.Y[i]);
... | 0 |
#include <pthread.h>
pthread_mutex_t a;
pthread_mutex_t c;
pthread_mutex_t f;
pthread_mutex_t g;
int k;
int j;
void* fn1(void * args){
pthread_mutex_lock(&a);;
if( k == 25 ){
j = 1;
pthread_mutex_unlock(&f);;
pthread_mutex_lock(&g);;
if( j )
printf("hola\\n");
else
... | 1 |
#include <pthread.h>
pthread_mutex_t mux;
pthread_cond_t cond;
int is_locked;
int wait_count;
int usage_count;
} _EVENT;
int _tr50_event_create(void **handle) {
_EVENT *evt;
if (handle == 0) {
return ERR_TR50_BADHANDLE;
}
if ((*handle = _memory_malloc(sizeof(_EVENT))) == 0) {
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
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(&mutex,&attr);
pthread_mutexattr_... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int reacteur =0;
int nbH, nbO, nbE;
void* eau(void* arg){
int deltar = arg;
while(1 && nbO >= 0 && nbH >= 0){
pthread_mutex_lock(&lock);
fflush(stdout);
if(react... | 0 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
... | 1 |
#include <pthread.h>
static pthread_mutex_t *_newMutex(void);
pthread_mutex_t *Posix_CreateMutex(void) {
pthread_mutex_t *retval = _newMutex();
if(pthread_mutex_init(retval, 0) != 0) {
free(retval);
return 0;
}
return retval;
}
void Posix_DestroyMutex(pthread_mutex_t *mutex) {
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int avail = 0;
void *fun(void *arg)
{
int i;
int counter = atoi( arg);
for ( i=0; i< counter; i++){
pthread_mutex_lock(&mutex);
printf("%d\\n", i);
avail++;
pthread_mutex_unlock(&mutex);
}
return 0;
}
int mai... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
void execute_operations(void * arg)
{
FILE *fptr;
char error = 0;
char opened_in_read = 1;
char buf[12000];
char buf2[500];
int fd;
ssize_t ret_read, ret_write;
char * filename1 = "/mnt/trfs/bigDirectoryName/abracadabra.txt";
char * filename2 = "... | 0 |
#include <pthread.h>
void *foo10Secs(void *data)
{
assert(data == 0);
char *arr = malloc(sizeof(int)* (1024 * 60));
for(int i = 0; i < (1024 * 60); i++)
arr[i] = i;
for(int i = 0; i < (1024 * 60); i++)
for(int j = 0; j < (1024 * 60); j++)
if(arr[i] == 255)
printf("bug\\n");
fre... | 1 |
#include <pthread.h>
{
int _data;
struct listnode* _next;
}Node,*Node_p,**Node_pp;
Node_p _h = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int IsEmpty(Node_p _h)
{
return (_h->_next == 0)?1:0;
}
Node_p BuyNode(int data)
{
Node_p ... | 0 |
#include <pthread.h>
const int mul_a[7] = {2769, 4587, 8761, 9031, 6743, 7717, 9913};
const int add_b[7] = {767, 1657, 4057, 8111, 11149, 11027, 9901};
void *bloomThread(void *args)
{
struct sharedData* sd = (struct sharedData *)args;
int tid = sd->threadid;
struct Bloom* bloom = sd->b;
... | 1 |
#include <pthread.h>
pthread_t thread[6];
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
double result;
{
int n;
} calc_data;
int isOdd(int n)
{
if(n%2)
return 1;
else
return -1;
}
void* nilakantha_series(void* arg)
{
calc_data *c_data = (calc_data*) arg;
int n = c_da... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void* funcCnt1();
void* funcCnt2();
int count = 0;
int main()
{
pthread_t thread1, thread2;
pthread_create(&thread1, 0, funcCnt1, 0);
pthread_create(&thr... | 1 |
#include <pthread.h>
int buffer[10];
int imprimir=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condProd=PTHREAD_COND_INITIALIZER;
pthread_cond_t condCons=PTHREAD_COND_INITIALIZER;
void *codigo_productor(void *_id);
void *codigo_consumidor(void *_id);
void imprimir_vec... | 0 |
#include <pthread.h>
void* irTimeoutFunction(void* args){
struct ArgumentData *ad = (struct ArgumentData *)args;
struct ElevatorData *ed = ad->ed;
pthread_mutex_t *mutex = ad->mutex;
while(1){
long theTime = time(0);
pthread_mutex_lock(mutex);
if(ed->doorOpenFlag){
i... | 1 |
#include <pthread.h>
static pthread_mutex_t m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
char *ts="[??:??:??]";
struct tm * now;
time_t nw;
pthread_mutex_lock(&m_trace);
nw = time(0);
now = localt... | 0 |
#include <pthread.h>
static pthread_once_t g_init = PTHREAD_ONCE_INIT;
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
static struct light_state_t g_battery;
char const*const CHARGING_LED_FILE
= "/sys/class/leds/charging/brightness";
char const*const LCD_FILE
= "... | 1 |
#include <pthread.h>
void *addr;
int cnt;
char code;
} ac_ent;
static ac_ent ac_tlb[10] = {{0,0,0},};
static pthread_mutex_t mutex;
static void __init(void){
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_FAST_NP);
pthread_mutex... | 0 |
#include <pthread.h>
double sum = 0.0, a[1000000];
pthread_mutex_t sum_mutex;
void *do_work(void *tid)
{
int i, start, *mytid, end;
double mysum = 0.0;
mytid = (int *) tid;
start = (*mytid * 1000000/4);
end = start + 1000000/4;
printf("Thread %d doing iterations %d to %d\\n... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t bufferFullStatus = PTHREAD_COND_INITIALIZER;
pthread_cond_t bufferEmptyStatus = PTHREAD_COND_INITIALIZER;
int numConsumers;
int totalWorkUnits;
struct workUnit
{
char* data;
};
struct workQueue
{
int size;
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.