text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static pthread_mutex_t taskLock;
static pthread_mutex_t outputLock;
static sem_t taskSem;
static sem_t outputSem;
double compute(int x, int n);
void *WorkThread();
struct node {
int x;
int n;
double res;
pthread_t tid;
struct node *next;
} taskQHead, outputQHead, *tmpNo... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
unsigned long tmp_start;
unsigned long tmp_end;
struct pthread_args
{
unsigned long start, end, out, chunk_size, a, b;
};
void * check_is_prime(void *ptr) {
struct pthread_args *arg = ptr;
long N, j;
unsigned long sqrRoo... | 0 |
#include <pthread.h>
int stack[10][2];
int size = 0;
sem_t sem;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void provide_data(void)
{
int i;
for (i = 0; i < 10; i++) {
stack[i][0] = i;
stack[i][1] = i;
sem_post(&sem);
}
}
void handle_data1(void)
{
int i;
while (pthread_mutex_... | 1 |
#include <pthread.h>
struct item {
char stuff[31337 * 1024];
struct item * next;
};
struct cache_items {
struct item * head;
struct item * tail;
pthread_mutex_t lock;
} cache;
void hog_memory() {
struct item * thing = malloc(sizeof(struct item));
thing->next = 0;
... | 0 |
#include <pthread.h>
pthread_mutex_t g_mutex;
int g_a = 0;
int g_b = 0;
int g_c = 0;
double get_time_ms()
{
struct timeval tv;
gettimeofday(&tv,0);
return tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0;
}
void * use_mutex(void *arg)
{
double time1 = get_time_ms();
int count = *((int *)arg);
wh... | 1 |
#include <pthread.h>
pthread_t student_array[4];
pthread_t ta_thread;
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students = 0;
int thread_helped_counter[4];
unsigned int seed = 92;
int sleep_time;
int waiting_queue[2];
void * students(void * param);
void *... | 0 |
#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) {
struct reg *valor;
valor = (struct reg*) arg;
printf("in... | 1 |
#include <pthread.h>
pthread_mutex_t chops[5];
void pinit(int a, int *b,int *c)
{ *b=(a>0)?(a-1):5;
*c=a;
printf("Philosopher %d started",a+1);
return;
}
int check_spoon(int a,int b,int c)
{
int sum=0;
if(a&1)
{
( sum=(pthread_mutex_trylock(&chops[c])))==0 ? ... | 0 |
#include <pthread.h>
struct cleaner_entry {
struct cleaner_entry* next;
void (*func)(void*);
void* etc;
};
static struct cleaner {
struct cleaner_entry* head;
pthread_mutex_t mtx;
} cleaner;
void
ws_cleaner_init(void)
{
cleaner.head = 0;
pthread_mutex_init(&cleaner.... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t flag;
void* work(void* v) {
const char* id = (const char*) v;
printf("%s waiting for event\\n", id);
pthread_mutex_lock(&mutex);
pthread_cond_wait(&flag, &mutex);
printf("\\t%s proceeding after event\\n", id);
... | 0 |
#include <pthread.h>
pthread_mutex_t varLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t varCond = PTHREAD_COND_INITIALIZER;
int data[256][8192];
int remain = 16;
void *calc(void *param) {
int x, y, start = 16 * (int) param;
int end = start + 16;
for (x = start; x < end; x++)
... | 1 |
#include <pthread.h>
static int malloc_count = 0;
static int free_count = 0;
static long long int malloc_size = 0;
static long long int free_size = 0;
static pthread_mutex_t s_regptr_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct {
const void *ptr;
const char *file;
int line;
... | 0 |
#include <pthread.h>
int32_t comp_timeb(struct timeb *tpa, struct timeb *tpb)
{
return ((tpa->time - tpb->time) * 1000) + (tpa->millitm - tpb->millitm);
}
static int8_t is_leap(unsigned int y)
{
return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
}
time_t cs_timegm(struct tm *tm)
{
t... | 1 |
#include <pthread.h>
char buf[100] = {0};
int flag = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *func(void *arg)
{
sleep(1);
while(flag == 0)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("输入了%d个字符\\n", strlen(buf));
pthread_mutex_unlock(&mutex);
mem... | 0 |
#include <pthread.h>
int N ,T ;
int v_counter = 0;
int turn;
pthread_mutex_t c_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_threshold_cv = PTHREAD_COND_INITIALIZER ;
void *start_thread(void *thread_id)
{
int me,next,*ptrid, iter = 1;
ptrid =(int *)thread_id;
me = *ptrid;
... | 1 |
#include <pthread.h>
void Qaullib_Appevent_LL_Add (int event)
{
struct qaul_appevent_LL_item *new_item;
new_item = (struct qaul_appevent_LL_item *)malloc(sizeof(struct qaul_appevent_LL_item));
new_item->event = event;
new_item->next = 0;
pthread_mutex_lock( &qaullib_mutex_appeventL... | 0 |
#include <pthread.h>
struct pThreadKey
{
int inUse;
void (*destructor)(void*);
};
static struct pThreadKey pKeys[PTHREAD_KEYS_MAX];
static pthread_mutex_t pKeyMutex = PTHREAD_MUTEX_INITIALIZER;
struct pthread_descr
{
void** specific[((PTHREAD_KEYS_MAX + 32 - 1) / 32)];
};
struct pthre... | 1 |
#include <pthread.h>
struct aPhil
{
int philNum;
int total;
pthread_t * threads;
pthread_mutex_t * forks;
}typedef aPhil;
void * philosopher(void * arg);
void eatingBigMacs(int philNum);
void philosophizing(int philNum);
aPhil * createPhilosopher(int philNum);
int isLastPhilosop... | 0 |
#include <pthread.h>
struct control{
float period;
float integral;
float derivative;
float error;
float iMax;
float iMin;
float iState;
float goal;
};
struct control PID;
pthread_mutex_t mutex;
pthread_t uInput;
void SetUp(){
PID.period = 1.0;
PID.integral = 0.099;
PID.deriva... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
len ... | 0 |
#include <pthread.h>
static uint32_t nalloc_conn;
static uint32_t nfree_conn;
static struct conn_tqh free_connq;
static pthread_mutex_t queue_lock;
static pthread_mutex_t sum_lock;
void conn_init(void) {
ga_log(NOTICE, "conn size %d", sizeof(struct conn));
nfree_conn = 0;
nalloc_conn ... | 1 |
#include <pthread.h>
pthread_mutex_t help_mutex;
pthread_mutex_t count_mutex;
sem_t TA_sem;
sem_t student_sem;
int number_waiting;
int go_home;
long nsecSleep;
int numberOfIterations;
int studentNumber;
} sleepAndCount;
void* student(void* param);
void* tA(void* param);
int main(int argc, ... | 0 |
#include <pthread.h>
pthread_mutex_t p_lock;
void bt_print(void* args);
int s_test_1(){
printf("[+] Stress Test-1: START\\n");
struct threadpool_t *pool;
int tadded = 0;
if((pool = tpool_init(MAXTHREADS, MAXTASKS)) == 0){
printf(" [!] ERROR: POOL == NULL\\n");
return 1;
}
printf(" ... | 1 |
#include <pthread.h>
pthread_t thr_stud[25];
pthread_t thr_dean;
pthread_mutex_t stud_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t dean_mutex = PTHREAD_MUTEX_INITIALIZER;
int students_at_party;
int dean_in_room;
void test1(void);
void test2(void);
void break_party(void);
void enter... | 0 |
#include <pthread.h>
struct LinkedList *createLinkedList()
{
struct LinkedList *list = malloc(sizeof(struct LinkedList));
list->mutex = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(list->mutex, 0);
return list;
}
int contains(struct LinkedList *a, char *name)
{
pthread_mut... | 1 |
#include <pthread.h>
long GlobalSumValues = 0;
int GlobalX = 0;
pthread_mutex_t mutexsum;
void *Xpower2I(void *threadid)
{
int taskId;
taskId = (int)threadid;
long i=0, tmepvalue = 1;
int LocalPower=0;
for (i =0; i < taskId; i++)
{
tmepvalue *= GlobalX;
}
pthread_mutex_lock(&mutexs... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum, mutexlvl;
void *dotprod(void *thdarg)
{
pthread_mutex_lock (&mutexlvl);
printf("Sync to start level: %ld\\n", (long... | 1 |
#include <pthread.h>void updatePortStates(int currentIndex, unsigned char rPriority, unsigned char rExtension, unsigned char *rMac, unsigned int pathCost, unsigned short age, unsigned char bPriority, unsigned char bExtension){
pthread_mutex_lock(&ifaceMutex);
if(states[currentIndex] == ROOT){
if(compa... | 0 |
#include <pthread.h>
int reader_cnt = 0;
pthread_mutex_t rw_mutex, read_cnt_mutex, nread_mutex;
int cnt = 3;
void *write_handle(void *arg);
void *read_handle(void *arg);
int main(void)
{
int type;
pthread_t tid_r, tid_w;
srand(getpid());
pthread_mutex_init(&rw_mutex, 0);
pthread_mutex_init(... | 1 |
#include <pthread.h>
enum pt_state {
SETUP,
IDLE,
JOB,
DIE
};
int task;
int size;
enum pt_state state;
pthread_cond_t work_cond;
pthread_mutex_t work_mtx;
pthread_cond_t boss_cond;
pthread_mutex_t boss_mtx;
} pt_info;
pthread_t threads[3][2];
pt_info shared_info[3][2];
void *task... | 0 |
#include <pthread.h>
void * treatMsg(struct can_frame canFrame){
switch (canFrame.can_id){
case ANGLEVOLANTMESURE:
if (DEBUG){
printf("%s angle volant mesure= %d\\n",TH_NAME,canFrame.data[0]);
}
pthread_mutex_lock(&angleVolantMesure_mutex);
angleVolantMesure_c = (unsi... | 1 |
#include <pthread.h>
static void sig_catch(int);
static void register_signal(void);
static void buffer_idx_cntup(int *idx);
static int mStopLoop = 0;
static char mBuffer[2048];
static int mBufferReadIdx = 0;
static int mBufferWriteIdx = 0;
static FILE *mLogfd;
static pthread_mutex_t mMutex;
... | 0 |
#include <pthread.h>
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
int num = 1;
void *
thr_func(void *arg)
{
int i = (int)arg;
char ch = 'a' + i;
for (;;)
{
pthread_mutex_lock(&qlock);
while (num != i) {
pthread_cond_wait(&qready,... | 1 |
#include <pthread.h>
const size_t io_buffer_slot_size = 1024*16;
struct io_buffer * io_buffer_new()
{
const unsigned int slot_count = 1024*8;
size_t alloc_size = sizeof(struct io_buffer) + io_buffer_slot_size*slot_count;
LOG_DEBUG("Allocating %0.2f Mbytes for IO buffer", alloc_size / 104857... | 0 |
#include <pthread.h>
int main(int argc, char* argv[]) {
int i, nthreads, count[MAXTHREADS];
pthread_t tid_produce[MAXTHREADS], tid_consume;
if (argc != 3) {
return -1;
}
nitems = ((atoi(argv[1])) > (MAXITEMS) ? (MAXITEMS) : (atoi(argv[1])));
nthreads = ((atoi(argv[2])) > (MAXTHREAD... | 1 |
#include <pthread.h>
size_t result = 0;
pthread_mutex_t result_mutex;
void *busy_work(void *data)
{
int i;
size_t thread_num = (size_t)data;
printf("Hello world! It's me - thread %zd\\n", thread_num);
for (i = 0; i < 1000000; i++)
{
pthread_mutex_lock(&result_mute... | 0 |
#include <pthread.h>
static struct input_event keyqueue[2048];
static pthread_t t;
static pthread_mutex_t keymutex;
static pthread_mutex_t exitmutex;
static int stop_flag = 0;
static int sp = 0;
static void (*key_handler)(int keycode);
static void (*click_handler)(int x, int y);
static void (*to... | 1 |
#include <pthread.h>
struct rtpp_genuid_priv {
struct rtpp_genuid_obj pub;
uint64_t lastsuid;
pthread_mutex_t lastsuid_lock;
};
static void rtpp_genuid_gen(struct rtpp_genuid_obj *, uint64_t *vp);
static void rtpp_genuid_dtor(struct rtpp_genuid_obj *);
struct rtpp_genuid_obj *
rtp... | 0 |
#include <pthread.h>
void mir_lock_create(struct mir_lock_t* lock)
{
pthread_mutex_init(&lock->m, 0);
}
void mir_lock_destroy(struct mir_lock_t* lock)
{
pthread_mutex_destroy(&lock->m);
}
void mir_lock_set(struct mir_lock_t* lock)
{
pthread_mutex_lock(&lock->m);
}
... | 1 |
#include <pthread.h>
int thread_count;
double a,b;
int n;
double h;
double sum;
pthread_mutex_t sum_mutex;
double f(double x);
void* Trap(void* rank);
int main(int argc,char* argv[]) {
int i;
pthread_t* thread_handles = 0;
double beg,end;
thread_count = strtol(argv[1],0,10);
pr... | 0 |
#include <pthread.h>
pthread_key_t key;
pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void destructor(void *ptr) {
void** ptr_aux = (void**)ptr;
printf("%p\\n", ptr);
printf("%p\\t%p\\n", ptr_aux[0], ptr_aux[1]);
free(ptr_aux[0]... | 1 |
#include <pthread.h>
{
char* bound;
int index;
} FARMER;
int globaltime = 1;
int north, south;
sem_t sem;
int northturn = 0;
int southturn = 1;
void enter_bridge(char* bound, int index);
void exit_bridge(char* bound, int index);
void* n_pass_bridge(void* param);
void* s_pass_bridge(vo... | 0 |
#include <pthread.h>
int VT_mc13783_OC_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783_OC_cleanup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783... | 1 |
#include <pthread.h>
static pthread_cond_t bcond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t bmutex = PTHREAD_MUTEX_INITIALIZER;
static int count = 0;
static int barrier = 0;
static int limit[5];
int initbarriers(int n)
{
int error;
int i;
if (error = pthread_mutex_lock(&bmutex))
{
... | 0 |
#include <pthread.h>
int capacidade = 5;
sem_t sacola;
sem_t partiu_correio;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void* pombo (void* arg) {
int i;
time_t t;
printf("POMBO CRIADO.\\n"); fflush(stdout);
srand((unsigned) time(&t));
while(1) {
printf("POMBO: esperando sa... | 1 |
#include <pthread.h>
void clearscr();
static char terminf_entry[1024];
static char platz_fuer_termstrings[1024];
static char *p=platz_fuer_termstrings;
static char *Cl, *Cpos, *Scroll, *SetScrollRegion;
static int nrlines;
static int nrcols;
static int isinit;
static struct termios told;
sta... | 0 |
#include <pthread.h>
const int MAX_PRODUCER = 20;
const int MAX_CONSUMER = 20;
int head = 0;
int tail = 0;
int buffer[5];
pthread_mutex_t mutex;
sem_t emptyBuffers;
sem_t fullBuffer;
void initialize_locks()
{
pthread_mutex_init(&mutex,0);
sem_init(&emptyBuffers,0,5);
sem_init(&... | 1 |
#include <pthread.h>
static struct timeval start_tv;
static volatile struct timeval last_tv;
static volatile unsigned short is_record_on = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int strcmp_wrapper(const void * str_a, const void * str_b)
{
return strcmp(*(const char... | 0 |
#include <pthread.h>
static FILE *fp = 0;
static int _log_level = SOLOG_NONE;
static unsigned int log_counter = 0;
static unsigned int _log_max_line = DEFAULT_LOG_LINE_LIMIT;
int sopenlog(const char *filename, int log_level)
{
fp = fopen(filename, "a+");
if (!fp) return 1;
fprintf... | 1 |
#include <pthread.h>
int *array;
int start;
int end;
int tid;
} thread_info;
int limit_threads;
int shared_index;
pthread_mutex_t mutex;
void swap(int*, int*);
void bubble_sort(int*, int);
void merge_sort(int*, int, int);
void *split_thread(void*);
void split_main(int*, int, int);
int main(... | 0 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static void *thr_primer(void *p);
int main()
{
int err,i;
pthread_t tid[4];
for(i = 0 ; i < 4; i++)
{
err = pthread_create(tid+i,... | 1 |
#include <pthread.h>
pthread_cond_t prod = PTHREAD_COND_INITIALIZER,
cons = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int prod_pos = 0,
cons_pos = 0,
stock = 0,
dataProd = 0,
buffer[20];
void * producer (void * arg);
void... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t conds = PTHREAD_COND_INITIALIZER;
static pthread_cond_t condr = PTHREAD_COND_INITIALIZER;
void *tcons(void *param) {
struct thread_param *tparam = param;
cinit(param);
for (;;) {
bool do... | 1 |
#include <pthread.h>
pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t assert_mutex = PTHREAD_MUTEX_INITIALIZER;
int return_code = CORRECT;
const char *regression_test_name = "";
int ompt_initialized = 0;
static void
segv_handler(int signo)
{
stat... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full,empty;
buffer_item buffer[15];
int counter;
pthread_t tid[3];
pthread_attr_t attr;
void *prodcer(void *param);
int insert_item(buffer_item item);
int remove_item(buffer_item *item);
void *consumer(void *param);
void initializeData()
{
... | 1 |
#include <pthread.h>
int npos;
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
int buf[10000000], pos=0, val=0, v=0;
void *fill(void *);
void *verify(void *);
int main(int argc, char *argv[])
{
int k, nthr, total, count[100];
pthread_t tidf[10... | 0 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main(int argc, const char *argv[])
{
int res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if(res != 0... | 1 |
#include <pthread.h>
sem_t semaphore;
pthread_mutex_t mutex;
int value;
} my_struct_t;
my_struct_t data;
void *my_thread(void *);
int main(int argc, char **argv)
{
pthread_t thread_id;
data.value = 0;
sem_init(&data.semaphore, 0, 0);
pthread_mutex_init(&da... | 0 |
#include <pthread.h>
void *malloc(size_t size)
{
size_t total_size;
void *block;
struct header_t *header;
if (!size)
return 0;
pthread_mutex_lock(&global_malloc_lock);
header = get_free_block(size);
if (header) {
header->is_free = 0;
pthread_mutex_unlock(&global_malloc_lock);
return... | 1 |
#include <pthread.h>
pthread_mutex_t m;
int s = 0;
int l = 0;
void* thr1(void* arg)
{
pthread_mutex_lock (&m);
__VERIFIER_assert (l==0 || s==1);
s = 1;
l = 1;
pthread_mutex_unlock (&m);
return 0;
}
int main()
{
s = __VERIFIER_nondet_int(0, 1000);
pthread_t t[5];
pthr... | 0 |
#include <pthread.h>
int ta = 0;
int chairs[3] = {-1,-1,-1};
int chair0 = -1, chair1 = -1, chair2 = -1;
int students[10] = {2,2,2,2,2,2,2,2,2,2};
pthread_mutex_t mutex[10];
pthread_mutex_t ta_mutex;
pthread_mutex_t run;
pthread_t students_thread[10], ta_thread;
void student_state(int stdno);
void ... | 1 |
#include <pthread.h>
struct rfifo *rfifo_init(unsigned int size)
{
struct rfifo *fifo = 0;
fifo = (struct rfifo*)malloc(sizeof(struct rfifo));
if (!fifo)
return 0;
memset(fifo, 0,sizeof(struct rfifo));
fifo->buffer = (char *)malloc(size);
if (!fifo->buffer) {
... | 0 |
#include <pthread.h>
int v_counter = 0;
int turn = 0;
pthread_mutex_t c_mutex;
pthread_cond_t c_threshold_cv;
void yield (void)
{
}
void busy_wait (int me, int next)
{
while (1)
{
while (turn != me)
yield();
if (v_counter >= 20)
{
... | 1 |
#include <pthread.h>
pthread_t P1, P2, P3;
int t1 = 0, t2 = 0, t3 = 0;
pthread_mutex_t M;
int flag;
void *inc_t1(void *interval)
{
while(1) {
sleep(2);
t1 += (int)interval;
printf("Counter 1: %d----------------------------------------------\\n", t1);
}
}
void *inc_t2(void *interv... | 0 |
#include <pthread.h>
int TAM = 4;
int NUM_THREAD = 1;
int linha_processar = 0;
long long int **A;
long long int **B;
long long int **C;
pthread_mutex_t mutex;
void *runner(void *param);
void preenche_matriz(long long int **MAT);
void main(int argc, char* argv[]) {
int i,j, count... | 1 |
#include <pthread.h>
int fifo_mut_m_spinlock;
int fifo_mut_m_count;
int ProgressIndicatorsMutex_m_spinlock;
int ProgressIndicatorsMutex_m_count;
int TerminateFlagMutex_m_spinlock;
int TerminateFlagMutex_m_count;
int ProducerDoneMutex_m_spinlock;
int ProducerDoneMutex_m_count;
int producerDone =... | 0 |
#include <pthread.h>
clock_t start, finish;
double timeOut;
int is_data_ready = 0;
int serversock, clientsock;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* streamServer(void* arg);
void quit(char* msg, int retval);
char attitude[3];
char attitudeBack[3];
int main(int argc, ch... | 1 |
#include <pthread.h>
gf_lock_t lock;
uintptr_t xl_up;
uint32_t xl_up_cout;
} share_data_t;
void ec_mask_to_char_array (uintptr_t mask, unsigned char *array,
int numsubvols)
{
int i = 0;
for (i = 0; i < numsubvols; i++)
... | 0 |
#include <pthread.h>
char *ID;
int N;
int global_i;
int procs;
int Norm;
volatile float A[5000][5000], B[5000], X[5000];
pthread_mutex_t global_i_lock;
int NTHREADS = 4;
void gauss();
unsigned int time_seed() {
struct timeval t;
struct timezone tzdummy;
gettimeof... | 1 |
#include <pthread.h>
struct sockaddr_in addr;
int connfd;
int uid;
char name[32];
}client_t;
void handle_client(void *client);
void handle_send(void *client);
char *dequeue();
char *encrypt(char *msg);
void queue(char *msg);
void queue_add(client_t *cl);
void queue_delete(i... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t not_empty, not_full;
int cokes = 5;
void* thread_function(void* function);
void refill_coke(void);
void consume_coke(void);
int main(int argc, const char * argv[]) {
int i;
pthread_t producers[10];
pthread_t consumers... | 1 |
#include <pthread.h>
{
ElemType elem[(5 + 1)];
int head, tail;
}Queue;
Queue the_queue, *p_queue;
pthread_mutex_t queue_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t producer_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t consumer_cond = PTHREAD_COND_INITIALIZER;
int ERROR_COD... | 0 |
#include <pthread.h>
int thread_flag;
pthread_mutex_t thread_flag_mutex;
void initialize_flag() {
pthread_mutex_init(&thread_flag_mutex, 0);
thread_flag = 0;
}
void do_work()
{
printf("Thread func...\\nWe do something very important!\\n");
}
void* thread_function(void* thread_arg)
{
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t display;
int oxygen = 0;
int hydrogen = 0;
pthread_barrier_t barrier;
sem_t oxyQueue;
sem_t hydroQueue;
int water = 0;
int building = 0;
void bond(int i){
building = 1; sleep (1);
}
void* oxygen_thread (void *v) {
pthread_m... | 0 |
#include <pthread.h>
int count;
int pending_posts;
} sem_t;
pthread_mutex_t mut = {0,0};
pthread_mutex_t mutp = {0,0};
void sem_init(sem_t *sem, int pshared, unsigned int value) {
sem->count = value;
sem->pending_posts = 0;
}
void sem_post(sem_t *sem) {
pthread_mutex_loc... | 1 |
#include <pthread.h>
pthread_t *threads;
pthread_mutex_t mutex_variable;
pthread_cond_t cond_wakeup_writers;
pthread_cond_t cond_wakeup_readers;
int nb_readers;
int nb_potential_writers;
int current_writing;
}struct_priority_writer;
void init_priority_writer(struct_priority_write... | 0 |
#include <pthread.h>
int shared_variable=15;
int count=0;
int num;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t rea = PTHREAD_COND_INITIALIZER;
pthread_cond_t writ = PTHREAD_COND_INITIALIZER;
void *writePhase (void *writearg);
void *readPhase (void *readarg);
int main(int... | 1 |
#include <pthread.h>
int num_threads = 30;
int N = 100000;
float result;
pthread_mutex_t mutex;
struct ThreadInput {
float dx;
int id;
float result;
};
float f(float x) {
return sin(x);
}
void * thread_func1(void * arg_ptr);
void * thread_func2(void * arg_ptr);
main() {
... | 0 |
#include <pthread.h>
char *readline(FILE *rfile) {
char buf[1000];
int len;
char *result = 0;
char *line = fgets(buf, 1000, rfile);
if (line) {
len = strnlen(buf, 1000);
result = strncpy(malloc(len+1),buf,len+1);
}
return result;
}
FILE *rfile;
pthread_mutex_t solock;
... | 1 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t mutex;
pthread_cond_t condvar;
void *tf(void *param){
int i = 0;
while (counter < 5000000) {
pthread_mutex_lock(&mutex);
if (counter == 5000000)
pthread_cond_signal(&condvar);
else
counter++;
pthread_mutex_unlock(&mutex);
... | 0 |
#include <pthread.h>
int i = 0;
pthread_mutex_t mutex;
void* thread_function(void* j){
if (*((int*)j) == 0){
for (int k = 0; k < 1000000; k++){
pthread_mutex_lock(&mutex);
i++;
pthread_mutex_unlock(&mutex);
}
}
else if (*((int*)j) == 1){
for (int k = 0; k < 1000000; ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void enter_shared_track(void)
{
pthread_mutex_lock(&mutex);
}
void exit_shared_track(void)
{
pthread_mutex_unlock(&mutex);
}
void using_shared_track_section(char* name)
{
int trip_duration = rand() % 6 +1;
... | 0 |
#include <pthread.h>
struct args {
pthread_cond_t cond_var;
pthread_mutex_t cond_lock;
};
void *
lazy_thread(void *arg ) {
printf("thread!\\n");
struct args *t_args = (struct args *)arg;
pthread_mutex_lock(&(t_args->cond_lock));
pthread_cond_wait(&(t_args->cond_var), ... | 1 |
#include <pthread.h>
int end = 0;
int sockfd = 0;
pthread_mutex_t lock;
FILE * log_file;
pthread_t threads[MAX_THREADS];
int threadStatus = 0;
void *logPacket(void *arg)
{
int msg = 0;
char buff[MAX_MSG_BUFF] = {0};
while(1)
{
if((msg = recvfrom(sockfd, buff, MAX_MSG_BUFF, 0, 0, 0)) !=... | 0 |
#include <pthread.h>
pthread_mutex_t* curl_locks = 0;
void seafile_curl_locking_callback(int mode, int n, const char* file, int line)
{
if (mode & CRYPTO_LOCK) {
pthread_mutex_lock (&curl_locks[n]);
} else {
pthread_mutex_unlock (&curl_locks[n]);
}
}
void seafil... | 1 |
#include <pthread.h>
void *customer(void *num);
void *barber(void *);
int UD(int, int);
pthread_cond_t seats_available;
pthread_cond_t barber_free;
pthread_cond_t wake_up;
pthread_cond_t done_cut;
pthread_mutex_t barber_chair;
pthread_mutex_t number_seats;
pthread_mutex_t finished;
pthread_mu... | 0 |
#include <pthread.h>
int arr[10];
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_barrier_t barrier;
static int avail = 0;
static void *producer(void *arg)
{
sleep(1);
printf("\\n%s: Started producing..\\n",... | 1 |
#include <pthread.h>
void *accessFile(void*);
void handleSignalInterrupt(int);
int threadsMade = 0;
int threadsRunning = 0;
int fileAccessTime = 0;
pthread_mutex_t lock;
int main() {
signal(SIGINT, handleSignalInterrupt);
char buffer[256];
srand(time(0));
if(pthread_mutex_... | 0 |
#include <pthread.h>
static int dumperi_readq_check(struct CacheBase *cache) {
pthread_mutex_lock(&cache->readq_lock);
int res = (cache->readq != 0);
pthread_mutex_unlock(&cache->readq_lock);
return res;
}
int dumper_readq_enqueue(struct CacheBase *cache, struct CacheElem *elem) {
pthread_... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
extern int __VERIFIER_nondet_int();
int idx=0;
int ctr1=1, ctr2=0;
int readerprogress1=0;
int readerprogress2=0;
pthread_mutex_t mutex;
void __VERIFIER_atomic_use1(int myidx) {
__VERIFIER_assume(myidx <= 0 && ctr1>0);
ctr1++;
}
void... | 0 |
#include <pthread.h>
void* register_write(void* data)
{
int clock_start = 0;
int new_instruction = 1;
CLOCK_ZERO_READ[3] = 1;
while (1)
{
if (STOP_THREAD == 1)
{
pipeline[3].instr.Itype = NO_OP;
pipeline[3].instr.Ctype = NO_OP;
temp_pipeline[3].instr.Itype = NO... | 1 |
#include <pthread.h>
static char* output_string = 0;
static pthread_mutex_t output_lock;
static int initialized = 0;
static pthread_t thread;
static void* query_time_thread() {
time_t raw;
struct tm* info;
if(output_string == 0) {
output_string = calloc( 64, sizeof(char... | 0 |
#include <pthread.h>
pthread_mutex_t tunnel;
void *train(void* arg)
{
sleep(rand()%10);
pthread_mutex_lock(&tunnel);
printf("Moi, %s, j'entre dans le tunnel\\n", (char*)arg);
sleep(2);
pthread_mutex_unlock(&tunnel);
printf("Moi, %s, je sors du tunnel\\n", (char*)arg);... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int final_result = 0;
struct thread_data{
int startidx;
int maxidx;
};
ub4 phash(ub4 val, ub2 * scramble, ub1 * tab)
{
ub4 a, b, rsl;
b = (val >> 5) & 0x1fff;
a = ((val << 22) >> 19);
rsl = (a^scramble[tab[b]... | 0 |
#include <pthread.h>
struct node
{
int servico;
struct node *next;
};
struct node *front = 0;
struct node *rear = 0;
void enqueue(int idServico){
struct node *nptr = malloc(sizeof(struct node));
nptr->servico = idServico;
nptr->next = 0;
if (rear == 0)
{
f... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void
thread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
pt... | 0 |
#include <pthread.h>
FILE*file;
int num;
}ph;
ph one, two, three, four, five;
pthread_mutex_t mutex;
FILE*results;
int process=0;
void *read_thread(void *ptr);
void printresults(void);
int main(void) {
pthread_mutex_init(&mutex, 0);
FILE*file1, *file2, *file3, *file4, *file5;
... | 1 |
#include <pthread.h>
extern pthread_mutex_t mutexA;
extern pthread_mutex_t mutexB;
pthread_mutex_t mutexA = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexB = PTHREAD_MUTEX_INITIALIZER;
extern int mBalance;
int mBalance=0;
static int modbal_armed ();
static void modbal_one();
static void modbal_... | 0 |
#include <pthread.h>
char *message = "HELLO B78! WELCOME TO THE CHAT EDGE. START CHATTING WITH YOUR FRIENDS. YOUR IP IS :";
pthread_mutex_t mutex;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct sockaddr_in sock_addr, sock_addr2;
int len;
int sd, fd[500], count = 0, file_d;
pthread_t tid... | 1 |
#include <pthread.h>
int i = 0;
int j = 0;
pthread_mutex_t m;
void handle(void *d)
{
printf("退出后的调用!\\n");
pthread_mutex_unlock(&m);
}
void* pthread_add1(void *num)
{
while(1){
pthread_cleanup_push(handle,0 );
pthread_mutex_lock(&m);
i++;
j++;
printf("线程one：i:%dj:%d\\n",i,j);
pth... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.