text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static void initRocket(struct rocket *);
static void animateRocket(struct rocket *);
void setRocketsToDead(struct rocket * rockets) {
int i;
for (i = 0; i < MAX_ROCKETS; i++)
rockets[i].isAlive = 0;
}
void *setupRocket(void *arg) {
struct rocket *r = arg;
ini... | 1 |
#include <pthread.h>
static int vp9_lf_block_cpu(struct task *tsk,
struct task_step *step) {
struct lf_blk_param *param = tsk->priv;
int mi_row, mi_col;
for (mi_row = param->start_mi_row;
mi_row < param->end_mi_row;
mi_row += param->step_length) {
... | 0 |
#include <pthread.h>
{
int key;
struct __node_t *next;
} node_t;
{
node_t *head;
pthread_mutex_t lock;
} list_t;
void list_init(list_t *l)
{
l->head = 0;
pthread_mutex_init(&l->lock, 0);
}
int list_insert(list_t *l, int key)
{
node_t *new = malloc(sizeof *new);
... | 1 |
#include <pthread.h>
struct foo {
int id;
int refs;
struct foo* next;
pthread_mutex_t mutex;
};
int hash(int id) {
return id % 10;
}
struct foo* map[10];
pthread_mutex_t hash_lock;
struct foo* alloc(int id) {
struct foo* p;
if ((p = (struct foo*)malloc(sizeof(struct foo))) != 0) ... | 0 |
#include <pthread.h>
int main()
{
printf("Do not support this kind of process lock\\n");
return 0;
int pid = 0;
int shm_id = 0;
int ret = 0;
struct shmid_ds buf;
int* x = 0;
char* shmaddr = 0;
char* addnum = "myadd";
void* ptr = 0;
pthread_mutex_t mutex;
pthread_mutexattr_t ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t transferCond;
{
unsigned int id;
int money;
bool isFree;
pthread_cond_t cond;
} bankAccount;
{
bankAccount* src;
bankAccount* target;
int numberOfMoney;
} moneyTransfer;
{
bankAccount* target;
int nu... | 0 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
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 ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char s[10000];
int flag;
void *producer (void *a)
{
int i, j;
flag = 0;
pthread_mutex_lock (&mutex);
for (i = 0; i < 10000; i++)
{
s[i] = 'p';
for (j = 0; j < 10000; j++);
}
pthread_mutex_unlo... | 0 |
#include <pthread.h>
int n;
int squares;
struct
{
int i, j;
} moves[] = {{0, -3}, {0, 3}, {-3, 0}, {3, 0},
{-2, -2}, {-2, 2}, {2, -2}, {2, 2}};
int num_moves = sizeof(moves)/sizeof(moves[0]);
pthread_mutex_t sol_lock;
int solutions = 0;
int max_depth = 0;
unsigned long total_iter = 0;
int... | 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(stru... | 0 |
#include <pthread.h>
struct dist_tab_entry {
char * name;
int len;
struct timespec expiration;
int hops;
};
struct dist_table
{
int size;
struct bitmap * valid;
pthread_mutex_t table_lock;
struct dist_tab_entry * table;
};
struct dist_table g_dist_tab;
int dt... | 1 |
#include <pthread.h>
int
pthread_setcancelstate (int state, int *oldstate)
{
struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
int newflags;
pthread_init();
switch (state)
{
default:
return EINVAL;
case PTHREAD_CANCEL_ENABLE:
case PTHREAD_CANC... | 0 |
#include <pthread.h>
static int cmp_by_addr(const void * d1,const void *d2)
{
struct conn * c1=(struct conn *) d1;
struct conn * c2=(struct conn *) d2;
return sock_cmpaddr((struct sockaddr*)&c1->addr,(struct sockaddr*)&c2->addr,1);
}
static int cmp_by_session_id(const void *d1, cons... | 1 |
#include <pthread.h>
struct list_node {
long value;
struct list_node *next;
};
static struct list_node **list_head;
static struct list_node **free_head;
static pthread_mutex_t *mutex;
void print_list(void) {
struct list_node *curr = *list_head;
while (curr != 0) {
pr... | 0 |
#include <pthread.h>
void *cgi_thread_handler(void *arg)
{
char buf[MAXCMDLEN];
int led_flag;
int beep_flag;
while (1)
{
pthread_mutex_lock(&SHM->cgi_mutex_start);
while (0 == SHM->cgi_emit_start)
{
pthread_cond_wait(&SHM->cgi_cond_start, &SHM->cgi_mutex_start);
}
if (0 < SHM... | 1 |
#include <pthread.h>
int ticketcount=11;
pthread_mutex_t lock;
void *salewinds1(void *args)
{
while(1)
{
pthread_mutex_lock(&lock);
if(ticketcount >0)
{
printf("windows1 start sales!the ticket is:%d\\n",ticketcount);
sleep(2);
tick... | 0 |
#include <pthread.h>
extern int startWifiSet(void);
static pthread_mutex_t wifi_mutex;
static pthread_t thdWifi = 0;
static int wifiRunFlag = 0;
static volatile int curWifiMode = WIFI_NULL_MODE;
static int bkWifiMode = WIFI_NULL_MODE;
static volatile int needHttpServer = 0;
int getWifiState(void... | 1 |
#include <pthread.h>
pthread_cond_t VC[5];
pthread_mutex_t M = PTHREAD_MUTEX_INITIALIZER;
int estado[5];
int actualiza (int i) {
if ((estado[(i - 1) % 5] != 3) &&
(estado[i] == 2) &&
(estado[(i + 1) % 5] != 3)) {
estado[i] = 3;
pthread_cond_signal(&VC[i... | 0 |
#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... | 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;
int threadcount = 0;
struct sockets {
int local;
FILE *in, *out;
};
struct sockets... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
struct serverParm{
int connectionDesc;
};
char* concat(const char* s1, const char* s2){
char* result = malloc(strlen(s1)+strlen(s2)+1);
strcpy(result, s1);
strcat(result, s2);
return result;
}
static int callback(void *data, in... | 1 |
#include <pthread.h>
void *ocurrencias (void *arg);
void imprimir();
pthread_mutex_t mutex;
int *numOcurrencias;
char **palabrasABuscar;
int nPalabrasABuscar;
int contador=0;
int main(int argc, char **argv) {
char *ruta = argv[1];
int nHilos = atoi(argv[2]);
nPalabrasABuscar = ar... | 0 |
#include <pthread.h>
pthread_t tid[28], tid_read;
char shared_var;
pthread_mutex_t cond_var_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
int sequence, orig_sequence;
FILE *fp;
void *thread_write(void *arg)
{
pthread_mutex_lock(&cond_var_lock);
i... | 1 |
#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;
se... | 0 |
#include <pthread.h>
int NO_READERS;
int NO_WRITERS;
int NO_READERS_READING = 0;
bool VERBOSE;
pthread_mutex_t resourceMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t readerMutex = PTHREAD_MUTEX_INITIALIZER;
void *readerJob(void *arg) {
while (1) {
pthread_mutex_lock(&readerMutex)... | 1 |
#include <pthread.h>static char *rcs_file_verson = "$Id: pgen.c,v 1.3 2013/12/02 19:16:57 chuck Exp $";
uint64_t LastP;
int DeltaP;
PgenInit( Threads )
int Threads;
{
int i,j;
uint64_t *P;
primegen_init(&PG);
if (Threads < 1 || Threads > (MAXTHREADS-1)) return (-1);
... | 0 |
#include <pthread.h>
int sala_espera = 0;
int elfos_dudosos = 0;
pthread_mutex_t santa_duerme = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t santa_libre = PTHREAD_COND_INITIALIZER;
pthread_cond_t sala_espera_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t sala_espera_m = PTHREAD_MUTEX_INITIA... | 1 |
#include <pthread.h>
int pile[2];
int stack_size = -1;
pthread_mutex_t mutex_stack = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_pop = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_push = PTHREAD_COND_INITIALIZER;
void push(int car)
{
pthread_mutex_lock(&mutex_stack);
while ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int total = 0;
int arrayA[16];
int arrayB[16];
void generate_values(){
for (int i = 0; i < 16; ++i){
arrayA[i] = rand() % 10;
arrayB[i] = rand() % 10;
}
}
void print(int *array, char * name, int array_size){
print... | 1 |
#include <pthread.h>
void *do_work_one();
void *do_work_two();
pthread_mutex_t first_mutex;
pthread_mutex_t second_mutex;
main()
{
pthread_t tid;
int return_val;
pthread_mutex_init(&first_mutex, 0);
pthread_mutex_init(&second_mutex, 0);
pthread_create(&tid, (pthread... | 0 |
#include <pthread.h>
pthread_mutexattr_t mutex_shared_attr;
pthread_condattr_t cond_shared_attr;
pthread_mutex_t *lock;
pthread_cond_t *cond;
int *bufferFull;
struct timespec *start;
int main(int argc, char **argv){
int size;
if(argc < 2 || argc > 3){
fprintf(stderr, "Usage %s <buffersiz... | 1 |
#include <pthread.h>
int *nbFichierRestant, *nbFichierMax;
pthread_t* tabThread;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *funcThread(void *arg){
int *t = 0;
t = malloc(sizeof(int));
char ** arguments = (char**)arg;
pthread_mutex_lock(&mutex);
while (*nbFichierRest... | 0 |
#include <pthread.h>
short isfst_oprd;
short * isfst_done;
char oprt;
char * expr;
int * rst;
}expr_data;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int parse_expr( char expr[] );
void critical_section( expr_data * arg, int rst);
void * thread_calc( void * arg );
void * thr... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
sem_t sem;
SharedInt* sip;
int foo = 0;
void *functionWithCriticalSection(int* v2) {
pthread_mutex_lock(&(sip->lock));
sip->value = sip->value + *v2;
int currvalue = sip->value;
pthread_mutex_unlock(... | 0 |
#include <pthread.h>
pthread_mutex_t fifo_mut;
pthread_cond_t fifo_cond;
void fifo_lock() {
pthread_mutex_lock (&fifo_mut);
}
void fifo_unlock() {
pthread_mutex_unlock (&fifo_mut);
}
void fifo_wait() {
pthread_cond_wait (&fifo_cond, &fifo_mut);
}
void fifo_unlock_and_notify() {
pthr... | 1 |
#include <pthread.h>
int Buffer_Index_Value = 0;
char *Buffer_Queue;
pthread_mutex_t mutex_variable = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t Buffer_Queue_Not_Full = PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Queue_Not_Empty = PTHREAD_COND_INITIALIZER;
void *ping()
{
while(1)
... | 0 |
#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;
... | 1 |
#include <pthread.h>
int q[3];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 3)
... | 0 |
#include <pthread.h>
pthread_mutex_t rec_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
void thr1_fun(void) {
int rc;
printf("start thr1_fun\\n");
rc = pthread_mutex_lock(&rec_mutex);
if(rc) {
perror("thr1_fun, pthread_mutex_lock");
pthread_exit(0);
}
printf("thr1_fun executing\\n");
... | 1 |
#include <pthread.h>
struct person_info {
int sex;
char name[32 +1];
int age;
};
pthread_mutex_t mutex;
void *write_thread_routine(void * arg)
{
int i;
char buf[1024];
struct person_info *pInfo = (struct person_info *)arg;
printf("I'm sub thread,my thread ID is:0x%x\\n", (int)pthr... | 0 |
#include <pthread.h>
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void *conversion_func(void *arg) {
char *nomF=(char*)(arg);
int c;
FILE* fp1, *fp2;
c=1;
pthread_mutex_lock(&mutex);
fp1= fopen (nomF, "r");
fp2= fopen (nomF, "r+");
if ((fp1== 0) || (fp2== 0)) {
perror (... | 1 |
#include <pthread.h>
int cnt ;
{
int g_i ;
pthread_mutex_t lock;
}NODE, *pNODE ;
void* thd_handle(void* arg)
{
pNODE p = (pNODE)arg ;
int tmp ;
while(1)
{
pthread_mutex_lock( &p ->lock);
if(p ->g_i <= 0)
{
pthread_mutex_unlock(&p ->lock);
sleep(rand() % 5 + 1);
continue ;
... | 0 |
#include <pthread.h>
pthread_mutex_t locki[32];
int inode[32];
pthread_mutex_t lockb[26];
int busy[26];
void *thread(void* arg)
{
int i = (*(int*) arg) % 32;
pthread_mutex_lock(locki + i);
if (inode[i] == 0) {
int b = (i * 2) % 26;
while (1) {
pthread... | 1 |
#include <pthread.h>
static char envbuf[200];
char ** envrion;
int pthread_exec_count;
int g_index;
pthread_mutex_t env_mutex;
pthread_once_t init_done = PTHREAD_ONCE_INIT;
void thread_init(void);
int safe_getenv(const char * name, char * buf, int buflen) {
int i, len, olen;
pthread_o... | 0 |
#include <pthread.h>
pthread_t tid[4];
pthread_mutex_t mutex;
int *array;
int length = 100;
int count = 0;
int double_count = 0;
int t = 4;
int max_threads = 0;
struct padded_int
{
int value;
char padding[60];
};
struct padded_int private_count[4];
void *count3s_thread(void *arg) {
int... | 1 |
#include <pthread.h>
static pthread_mutex_t g_tmp_mutex = PTHREAD_MUTEX_INITIALIZER;
int run_command(const char *cmd)
{
int status;
char *tmp = (char *) calloc(strlen(cmd)+50, sizeof(char));
sprintf(tmp, "%s > /dev/null 2>&1", cmd);
if(-1 == (status=system(tmp))) {
prin... | 0 |
#include <pthread.h>
int dato = 5;
int n_lect = 0;
void *Lector(void *arg);
void *Escritor(void *arg);
int main(int argc, char *argv[]) {
pthread_t th1, th2, th3, th4;
pthread_create(&th1, 0, Lector, 0);
pthread_create(&th2, 0, Escritor, 0);
pthread_create(&th3, 0, Lector, 0);
... | 1 |
#include <pthread.h>
void* produzir(void *p) {
while(1){
pthread_mutex_lock(&mutex);
while (buffer == tamanho_buffer) {
printf("PRODUTOR %d: Buffer CHEIO. Indo dormir\\n",(int)(size_t)p);
pthread_cond_wait(&condp, &mutex);
}
buffer += 1;
printf("PRODUTOR %d: Acordado! Produzind... | 0 |
#include <pthread.h>
struct buffer
{
int b[10];
pthread_mutex_t monitor;
pthread_cond_t empty;
pthread_cond_t full;
int in,out;
int fullEntries;
} buf;
void *producer() {
int i=1;
while (1) {
int item;
item=rand()%100;
pthread_mutex_l... | 1 |
#include <pthread.h>
static pthread_mutex_t gethostby_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
convert (struct hostent *host, struct hostent *result,
char *buf, int buflen, int *h_errnop)
{
int len, i;
if (!buf || !h_errnop) return -1;
*h_errnop = h_errno;
*result = *hos... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
struct foo *
foo_alloc(int id)
{
struct foo *fp;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
fp->f_id = id;
if (pthread_mutex_init(&fp->f_lock, 0) != 0) {
free(fp);
return(0... | 1 |
#include <pthread.h>
{
struct msg *m_next;
}msg;
msg *workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
void process_msg(void)
{
msg *mp = 0;
while(1)
{
pthread_mutex_lock(&qlock);
while(workq == 0)... | 0 |
#include <pthread.h>
double distance(double x, double y);
void *Op (void *threadD);
int *in_circle;
pthread_mutex_t *in_circle_lock;
int threadID;
long long num_tosses;
}thread_data;
int main (int argc, char *argv[]){
double pi;
int i;
int points;
int numthreads;
int in_c... | 1 |
#include <pthread.h>
pthread_mutex_t mymutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t mycond = PTHREAD_COND_INITIALIZER;
void *mythread1(void *param)
{
printf("begin mythread1.\\n");
pthread_mutex_lock(&mymutex1);
printf("wait in mythread1.\\n");
pthread_cond_wait(&mycond,&mymutex1);
pthr... | 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 == 12) {... | 1 |
#include <pthread.h>
struct autosync_cfg {
struct jfs *fs;
pthread_t tid;
time_t max_sec;
size_t max_bytes;
sig_atomic_t must_die;
pthread_cond_t cond;
pthread_mutex_t mutex;
};
static void *autosync_thread(void *arg)
{
int rv;
void *had_errors;
struct timespec ts;... | 0 |
#include <pthread.h>
int NUMBER_OF_WORKER_THREADS = 10;
pthread_mutex_t StartWorkMutex;
pthread_cond_t StartWorkCondition;
Bool WorkOn = FALSE;
unsigned int Round = 0;
pthread_mutex_t CompleteMutex;
pthread_cond_t CompleteCondition;
Bool MainThreadWaiting = FALSE;
unsigned int TheComplete... | 1 |
#include <pthread.h>
unsigned char uart = 0;
pthread_mutex_t rt_mutex;
void* pthreat_recv_data(void* para)
{
int i = 0;
int res = 0;
unsigned long recv_count = 0;
char recv_buf[254] = {0};
if ((uart == 1) || (uart == 2) || (uart == 3))
{
while (1)
{
pthread_mutex_lock(&r... | 0 |
#include <pthread.h>
static pthread_cond_t cond_not_empty = PTHREAD_COND_INITIALIZER;
static pthread_cond_t cond_not_full = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int j_produced = 0, j_consumed = 0, nbuf = 24, nmax = 200;
volatile int j_active = 0;... | 1 |
#include <pthread.h>
pthread_mutex_t buffer_mutex, bounded_queue_mutex;
int buffer_consumed = 0;
int fill = 0, pages_downloaded = 0;
char buffer[100][50];
char *fetch(char *link) {
pthread_mutex_lock(&bounded_queue_mutex);
if(pages_downloaded == 1)
{
pthread_mutex_unlock(&bounded_queue_... | 0 |
#include <pthread.h>
int *partial_list_ptr;
int partial_list_size;
int a[32*32];
pthread_mutex_t min_val_lock;
int min_val = 32767;
int num_threads;
void *
find_min (void *list_ptr)
{
int start, end, my_min, i, j;
my_min = 32767;
partial_list_ptr = (int *) list_ptr;
start = (*partial_... | 1 |
#include <pthread.h>
static FILE* __fp = 0;
static int __tracer_start = 0;
static uintptr_t __func_entry = 0;
static pthread_mutex_t _fmutex = PTHREAD_MUTEX_INITIALIZER;
void __cyg_profile_func_enter(void* this, void* callsite)
;
void __cyg_profile_func_exit(void* thi... | 0 |
#include <pthread.h>
int curr[5][3];
int max_need[5][3];
int finish[5];
int max_res[3];
int avail[3];
pthread_mutex_t mutex;
void* Banker(void*);
void Print_state();
int main(){
pthread_t tid[5];
pthread_attr_t attr;
int i, j;
for (i=0;i<5;i++){
finish[i] = 0;
... | 1 |
#include <pthread.h>
char sourceFilename[ 500 ], destinationFilename[ 500 ], nonFlatSourceFilename[ 500 ], nonFlatDestinationFilename[ 500 ];
off_t offset = 0;
pthread_mutex_t offsetMutex = PTHREAD_MUTEX_INITIALIZER;
int copyingDone = 0;
void *copyWorker()
{
char buf[ 4096 ];
time_t starte... | 0 |
#include <pthread.h>
const int debug_variable = 0;
void callback(int op, int arg1, int arg2)
{
if (op == 1) printf("Setting/getting address %d, to %d\\n", op, arg1);
}
const int
PAGE_SIZE = 4,
MEM_SIZE = 5,
ADDR_SPACE_SIZE = 10,
MAX_CONCURRENT_OPERATIONS = 4,
WRITING_CYCLES = 10,
... | 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_mutex);
count++;
if (count == 12) {
pthr... | 0 |
#include <pthread.h>
int min(int a, int b) {
if (a < b) {
return a;
} else {
return b;
}
}
struct data_to_thread {
unsigned char * src;
unsigned char * dst;
int xsize, ysize, start_y, end_y, radius;
pthread_barrier_t* barrier;
pthread_mutex_t* lock;
int* sum;
} data_to_thread;
sta... | 1 |
#include <pthread.h>
int udpclient(struct argv_and_list *myinput, int my_socket, struct sockaddr_in myaddr, int serverlen ) {
int value_to_exit = 1;
char buf[BUFSIZE];
pthread_mutex_lock(&myinput->useQueue);
while ( 0 == ListCount( (struct List*) myinput->G_list) )
{
... | 0 |
#include <pthread.h>
pthread_mutex_t *mutexes;
int think(int id, int total, unsigned int *state){
int time = randomGaussian_r(11,7, state);
if(time < 0 ) time = 0;
printf("Philo %d thinking for %d seconds. (Total = %d)\\n", id, time, total);
sleep(time);
return time;
}
int eat(... | 1 |
#include <pthread.h>
int num_threads;
pthread_t p_threads[65536];
pthread_attr_t attr;
pthread_mutex_t lock_barrier;
int list[200000000];
int list_size;
int prefix_sum_list[200000000];
int mylist_sum[65536];
void *prefix_sum (void *s) {
int j, sum, offset;
int thread_id = (int) s;
... | 0 |
#include <pthread.h>
static struct Queue queue;
static pthread_mutex_t mutex;
static pthread_mutex_t empty_mutex;
static void *QSpoolData(void *args);
void QInit(){
pthread_mutex_init(&mutex, 0);
pthread_mutex_init(&empty_mutex, 0);
pthread_mutex_lock(&empty_mutex);
queue.head = 0;
qu... | 1 |
#include <pthread.h>
void print_values(struct filtered_data filteredData){
int i;
long sec_elapsed;
int ms_elapsed;
int us_elapsed;
double filtered_channel[4];
double raw_channel[4];
sec_elapsed = filteredData.sec_elapsed;
ms_elapsed = filteredData.ms_elapsed;
... | 0 |
#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;
tsp->tv_nsec = tv.tv_... | 1 |
#include <pthread.h>
int g_count = 0;
{
int numID;
}threadID;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void * consume(void *arg)
{
int inum = 0;
inum = (int)arg;
while (1)
{
pthread_mutex_lock(&mutex);
while (g_count <= 0)
{... | 0 |
#include <pthread.h>
int fd;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void analyse_psu_info(unsigned int msg_data)
{
info.data = msg_data;
if (PSU != data_id) return;
if (PLUG_IN == data_info) {
printf("PSU change: psu%d plugged in\\n", data_no);
} else if (PLU... | 1 |
#include <pthread.h>
struct connections_chunk
{
void *data;
int id;
};
struct connections_buffer
{
struct connections_chunk *chunks;
int chunks_count;
pthread_mutex_t mutex;
};
static int connections_get_index(struct connections_buffer *buffer, int id)
{
int lower = 0, upper = buffer->... | 0 |
#include <pthread.h>
static pthread_mutex_t s_state_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t s_state_cond = PTHREAD_COND_INITIALIZER;
static int s_port = -1;
static const char * s_device_path = 0;
static int s_device_socket = 0;
static int s_closed = 0;
static void usage(char ... | 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_mutex);
count++;
if (count == 12) {... | 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;
printf("Starting inc_count(): thread %ld\\n", my_id);
for (i=0; i<10; i++) {
pthrea... | 1 |
#include <pthread.h>
static pthread_mutex_t *lockarray;
static void lock_callback(int mode, int type, char *file, int line)
{
(void)file;
(void)line;
if (mode & CRYPTO_LOCK) {
pthread_mutex_lock(&(lockarray[type]));
}
else {
pthread_mutex_unlock(&(lockarray[type]));
}
}
sta... | 0 |
#include <pthread.h>
int global_value = 0;
pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER;
void *race( void *ptr ) {
if(!0) {
pthread_mutex_lock( &global_mutex );
}
int *id = (int *) ptr;
global_value = *id;
usleep(1);
printf("%d=%d\\n", *id, global_value);
... | 1 |
#include <pthread.h>
void initLog(void);
int pushLog(int,int);
int popLog(int);
void printLog(void);
void freeLog(void);
void* func_producer(void*);
void* func_consumer(void*);
struct THREAD_PARAMETERES{
int pid;
};
pthread_attr_t attr;
pthread_mutex_t mutex;
sem_t sem_empty;
sem_t sem_full;
... | 0 |
#include <pthread.h>
int tickets=10;
pthread_mutex_t mutex;
pthread_cond_t cond;
void* s_func( void* p)
{
long i=(long)p;
while( 1)
{
pthread_mutex_lock( &mutex);
if(tickets>0)
{
printf("i am windows %ld,tickets is %d\\n" ,i,tickets);
tickets--;
if( tickets==0)... | 1 |
#include <pthread.h>
pthread_t pr[4];
pthread_mutex_t se[4];
pthread_mutex_t seEnd[4];
pthread_mutex_t seIndex;
int pIndex = 0;
int fIndex = 0;
int mIndex = 15;
int files[15] = {1,2,3,1,2,3,1,2,3,1,2,3,1,2,3};
int lockTimes[4] = {0,3,4,5};
int file;
int z = 0;
void * print(void *arg){
pt... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int test_array [3][5];
int col_sums [3];
void* create_array(void*);
void* sum_columns(void*);
void print_array(void);
int main(){
int sum_thread = 3;
int total_sum = 0;
pthread_t gen_thread;
pthread_t sum_threads [... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int variableCompartidaSuma = 0;
int elementosPitagoricos[4] = {1, 2, 3, 4};
void* sumarValor (void* parametro)
{
int posArray;
posArray = (intptr_t) parametro;
printf("Sumando posicion = %d \\n", posArray);
pthread_mutex_lock(&lock);
... | 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))) !... | 1 |
#include <pthread.h>
unsigned long long main_counter, counter[3];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_worker(void*);
int main(int argc,char* argv[])
{
int i, rtn, ch;
pthread_t pthread_id[3] = {0};
int a = 0,b=1,c=2;
pthread_create(&pthread_id[0]... | 0 |
#include <pthread.h>
void wait(int);
void down_forks(int, int);
void *philosopher(void*);
int food_on_table();
void get_fork(int, int, char*);
pthread_mutex_t forks[5];
pthread_t phils[5];
pthread_mutex_t foodlock;
int sleep_seconds = 0;
int
main(int argn, char **argv) {
int i;
if ... | 1 |
#include <pthread.h>
pthread_barrier_t barrier;
pthread_mutex_t consoleMutex;
struct CalculateExpArgs
{
double value;
unsigned int numberOfOperations;
double result;
};
void* CalculateExp(void* args)
{
struct CalculateExpArgs* expArgs = (struct CalculateExpArgs*)args;
pthread... | 0 |
#include <pthread.h>
struct calltrace_rec {
uint64_t type;
uint64_t this_fn;
uint64_t call_site;
uint64_t timestamp;
uint64_t pid;
uint64_t tid;
};
static int enable = 1;
static FILE *fptr = 0;
static uint64_t nrecords = 0;
static pthread_mutex_t loglock = PTHREA... | 1 |
#include <pthread.h>
int
pthread_kill_siginfo_np (pthread_t tid, siginfo_t si)
{
int sig = si.si_signo;
if (sig < 0 || sig >= NSIG)
return EINVAL;
if (sig == 0)
return 0;
struct signal_state *ss = &__pthread_getid (tid)->ss;
pthread_mutex_lock (&sig_lock);
pthread_mutex_loc... | 0 |
#include <pthread.h>
int gi = 1;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond;
void *rabota(void *num){
long t_num;
t_num = (long) num;
pthread_mutex_lock(&mut);
gi++;
pthread_mutex_unlock(&mut);
sleep (gi);
printf("Поток %ld, выполнил полезную работу\\n"... | 1 |
#include <pthread.h>
int _mode = 0;
int nReaders = 0;
sem_t _accessQueue;
pthread_mutex_t _mutex;
void readLock(){
pthread_mutex_lock(&_mutex);
if(_mode == 0){
nReaders++;
}else{
sem_wait(&_accessQueue);
}
pthread_mutex_unlock(&_mutex);
}
void readUnLock(){
pthread_mutex_l... | 0 |
#include <pthread.h>
static unsigned char bitmap[536870912];
static unsigned long *bstart;
static unsigned long mapblocksize;
static unsigned long root2;
static int gnum_threads, sievebit = 2;
static pthread_mutex_t sievemutex;
static pthread_mutex_t *blockmutex;
static unsigned long ... | 1 |
#include <pthread.h>
pthread_mutex_t log_mutex = PTHREAD_MUTEX_INITIALIZER;
FILE * flog = 0;
int def_priv=0;
const char * priorities[3]=
{
"FATAL",
"ERROR",
"WARNING"
};
int Log_init(int priority, const char * file_name)
{
pthread_mutex_lock(&log_mutex);
def_priv=prio... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int cliSock;
void serverSalir(){
close(cliSock);
exit(0);
}
int isValidIpAddress(char *ipAddress)
{
struct sockaddr_in sa;
int result = inet_pton(AF_INET, ipAddress, &(sa.sin_addr));
if(result==0){
puts("Error.... | 1 |
#include <pthread.h>
char name[20];
char comment[50];
char type[10];
int dimension;
char wtype[10];
} InstanceData;
void printTour(int*);
void printMatrix();
double** readEuc2D(char*);
double tourCost(int*);
int* nearestNeighbour();
void swap();
void* SimulatedAnnealing();
InstanceDat... | 0 |
#include <pthread.h>
buffer_t buffer[5];
int buffer_index;
pthread_mutex_t buffer_mutex;
sem_t full_sem;
sem_t empty_sem;
void insertbuffer(buffer_t value) {
if (buffer_index < 5) {
buffer[buffer_index++] = value;
} else {
printf("Buffer overflow\\n");
}
}
buff... | 1 |
#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 ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.