text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static int pipe_in[2];
static int pipe_out[2];
static FILE *fifo_in;
static FILE *fifo_out;
static pid_t npid;
static pthread_t th_fifo;
static pthread_mutex_t nmtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t ncnd = PTHREAD_COND_INITIALIZER;
static pthread_conda... | 1 |
#include <pthread.h>
int P,H,S,A;
int passenger_no,p_handler,p_screen,p_seat;
int count;
sem_t handler,screener,go_handler,go_screener,go_attendant,seated,M;
pthread_mutex_t mutex;
void *Handler(void *args){
while(1)
{
sem_wait(&go_handler);
sem_post(&handler);
}
}
void *Screener(void ... | 0 |
#include <pthread.h>
int rank;
pthread_mutex_t mutex;
pthread_cond_t cond;
} thread_data;
thread_data td[20];
void* hello_thread(void *rank) {
int thread_rank = *(int *)rank;
if (thread_rank > 0) {
thread_data *prev = &td[thread_rank - 1];
pthread_mutex_lock(&prev->mutex);
pthread_c... | 1 |
#include <pthread.h>
double cx_min;
double cx_max;
double cy_min;
double cy_max;
int ix_max;
int iy_max;
double pixel_width;
double pixel_height;
int image_size;
int image_buffer_size;
unsigned char **image_buffer;
int nthreads;
int current_iy;
pthread_mutex_t stacklock = PTHREAD_MUTEX_... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo *foo_alloc(int id) {
struct foo *fp;
int idx;
if((fp = malloc(sizeof(struct foo))) != 0) {
... | 1 |
#include <pthread.h>
long sum=0;
struct interval {
long start;
long end;
int tid;
};
pthread_mutex_t sum_mutex;
void *add(void *arg)
{
intv *myinterval = (intv*) arg;
long start = myinterval->start;
long end = myinterval->end;
printf("I am thread %d and my interval is %ld... | 0 |
#include <pthread.h>
int nitems;
int buff[1000000];
struct {
pthread_mutex_t mutex;
int nput;
int nval;
} put = {
PTHREAD_MUTEX_INITIALIZER
};
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
} nready = {
PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_... | 1 |
#include <pthread.h>
int *a;
pthread_mutex_t *mutex;
} args;
void *thread(void *arg){
int *a = ((args*)arg)->a;
pthread_mutex_t *mutex = ((args*)arg)->mutex;
int i;
pthread_mutex_lock(mutex);
for(i=0; i < 1000; i++) {
(*a)++;
}
pthread_mutex_unlock(mutex);
pthread_exit(0);
}
int m... | 0 |
#include <pthread.h>
static pthread_mutex_t *crypto_lock = 0;
static pthread_t pthread_id_cb()
{
return pthread_self();
}
static void pthread_locking_cb(int mode, int n, const char *file, int line)
{
if(mode & CRYPTO_LOCK)
pthread_mutex_lock(&crypto_lock[n]);
else
pth... | 1 |
#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(){
pthread_key_create(&key, free);
}
char *getenv(const char *name){
int i, len;
char *... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cl, ce;
int ecriture;
int nb_lecteurs, nb_lect_att, nb_ecri_att;
} lectred;
int nb;
struct linked_list *next;
} linked_list;
struct lectred sync;
struct linked_list *head;
} linked_list_head;
linked_list_... | 1 |
#include <pthread.h>
struct thread_data{
int thread_id;
int sum;
char *message;
};
pthread_mutex_t mutexA[7 +1];
void *PrintHello(void *threadarg)
{
long taskid, sum;
struct thread_data *my_data;
char *message;
my_data = (struct thread_data *) threadarg;
taskid = my_data->... | 0 |
#include <pthread.h>
int cont;
int id;
} estrutura;
volatile estrutura estr;
pthread_mutex_t mutex;
pthread_cond_t cond;
volatile int lendo = 0, escrevendo = 0, filaEscrever = 0;
volatile int lido[20];
volatile int continua;
int todasLeram () {
int res = 1, i;
for (i = 0; i < 20; ++i)
... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int* pData = 0;
static void *WaitThread(void *arg)
{
while (1) {
pthread_mutex_lock(&mtx);
if(pData == 0)
{
pthread_cond... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
int main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
data_t data;
struct _node *next;
}node_t,*node_p,**node_pp,*list_head;
list_head head = 0;
static node_p buy_node(data_t _data)
{
node_p new_node = (node_p)malloc(sizeof(node_t));
if( 0 == new_node ){
perror("malloc");
exi... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *threadFunc(void *arg)
{
int threadNum = (int)arg;
int delayTime = 0;
int count = 0;
int res;
res = pthread_mutex_lock(&mutex);
if (res)
{
printf("thread %d lock failed\\n",threadNum);
exit(1);
}
printf("thread %d is starti... | 1 |
#include <pthread.h>
int RingBuf[32]={0};
int step=0;
sem_t semblank;
sem_t semdata;
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
void *pr... | 0 |
#include <pthread.h>
int queue[20];
int front , rear;
pthread_cond_t produce_cond, consume_cond;
pthread_mutex_t queue_mutex, produce_mutex, left_mutex;
int left_cnt, product_cnt;
void* producer(void* arg);
void* consumer(void* arg);
int main()
{
front = -1;
rear = 0;
srand(getpid... | 1 |
#include <pthread.h>
pthread_mutex_t dataMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t dataPresentCondition = PTHREAD_COND_INITIALIZER;
pthread_cond_t dataVacancyCondition = PTHREAD_COND_INITIALIZER;
pthread_barrier_t hold;
int buffer[10];
int items=0;
void random_delay()
{
int r = rand() %... | 0 |
#include <pthread.h>
static pthread_mutex_t lock;
static sem_t semcount, semspace;
static float * buffer;
static int in, out;
static int bufferSize;
int init_ringbuffer(int n) {
in = 0;
out = 0;
bufferSize = n;
if (pthread_mutex_init(&lock, 0)) {
printf("pthread_mutex_init failed, termin... | 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>
int x = 0;
int y = 0;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut2 = PTHREAD_MUTEX_INITIALIZER;
void *thread_func (void * arg)
{
while(1)
{
pthread_mutex_lock(&mut);
x=5;
x+=10;
pthread_mutex_lock(&mut2);
y=10;y+=1;
printf("x is %d in ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int buffer;
int estado = 0;
void produtor(int id)
{
int i=0;
int item;
int aguardar;
printf("Inicio produtor %d \\n",id);
while (i < 10)
{
item = i + (id*1000);
do
{
pt... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_hit_threshold=PTHREAD_COND_INITIALIZER;
void *inc_count(void *idp)
{
int i=0, save_state, save_type;
int *my_id = idp;
for (i=0; i<10; i++) {
... | 1 |
#include <pthread.h>
enum threadstatus {
thread_initialized = 0,
thread_ready = 1,
thread_exit = 2
};
struct threadctrl {
unsigned *free_threads;
unsigned num_free_threads;
pthread_mutex_t mtx;
pthread_cond_t cnd;
};
struct threaddata {
unsigned index;
enum threadstatus statu... | 0 |
#include <pthread.h>
struct list_head {
struct list_head *next ;
struct list_head *prev ;
};
struct s {
int datum ;
struct list_head list ;
};
struct cache {
struct list_head slot[10] ;
pthread_mutex_t slots_mutex[10] ;
};
struct cache c ;
static inline void INIT_LIST_HEAD(struct ... | 1 |
#include <pthread.h>
static sem_t thread_count;
static pthread_mutex_t rand_mutex;
struct quicksort_arg
{
int * left;
int * right;
};
static
void print_array(int array[], size_t size)
{
for ( size_t i = 0u; i < size; ++i )
{
printf("%i\\t", array[i]);
}
putcha... | 0 |
#include <pthread.h>
int buffer[10];
int counter=0;
int in=0;
int out=0;
int total=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t semfull;
sem_t semempty;
void *producer(void *junk) {
while(1) {
sem_wait(&semempty);
pthread_mutex_lock(&mutex);
buffer[i... | 1 |
#include <pthread.h>
void *find_gif(void *path){
char *file, *file_ext, file_path[1000];
DIR *inDir;
struct dirent *inDirent;
inDir = opendir(path);
if (!inDir) {
fprintf(stderr, "Error while searching for gif files: invalid file path.\\n");
fprintf(stderr, " Unable to op... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
main() {
pthread_t thread1, thread2;
pthread_create(&thread1, 0, &functionCount1, 0)... | 1 |
#include <pthread.h>
struct hadoop_group_info *hadoop_group_info_alloc(int use_reentrant)
{
struct hadoop_group_info *ginfo;
size_t buf_sz;
char *buf;
ginfo = calloc(1, sizeof(struct hadoop_group_info));
if (!use_reentrant) {
ginfo->buf_sz = 0;
ginfo->buf = 0;
} else {
bu... | 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>
long ninc_per_thread;
long a;
long b;
long r;
long * p;
pthread_mutex_t * m;
} arg_t;
void * f(void * arg_) {
arg_t * arg = (arg_t *)arg_;
long a = arg->a, b = arg->b;
long ninc_per_thread = arg->ninc_per_thread;
if (b - a == 1) {
int i;
for (i ... | 0 |
#include <pthread.h>
int tid=0;
int size=20/10;
long media=0;
pthread_mutex_t mutex;
void *calcMedia(void *threadid){
int parcial=0;
int i;
long id = *((long *)threadid);
for(i=(id)*size; i<(id+1)*size;i++)
parcial+=i;
printf("THREAD[%ld] calculated %d\\n", id, pa... | 1 |
#include <pthread.h>
static int work = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t con = PTHREAD_COND_INITIALIZER;
static void *thread_func(void *arg)
{
int * sec = (int *)arg;
int i;
for(i = 0; i < 1000; i++) {
sleep(*sec);
pthread_mutex_loc... | 0 |
#include <pthread.h>
static char *VersionStr="1.0";
static int test_duration_timer_expired = 0;
static int wakeup_fd[2];
static pid_t *child_pids = 0;
static pthread_mutex_t sync_mutex = PTHREAD_MUTEX_INITIALIZER;
static int set_timer_ms(struct itimerval *val, int ms)
{
val->it_value.tv_sec = ms... | 1 |
#include <pthread.h>
pthread_mutex_t mutex ;
int var;
void pthread1(void *arg);
void pthread2(void *arg);
int main(int argc,char* argv[]){
pthread_t id1, id2;
int ret;
pthread_mutex_init(&mutex, 0);
ret = pthread_create(&id1, 0, (void*)&pthread1, 0);
if(ret) printf("pthread1 create failed"... | 0 |
#include <pthread.h>
char buf[1000];
void PROCESS_PACK(char datagram[],int size)
{
struct iphdr * iph=(struct iphdr *)datagram;
int msg=ntohs(iph->tot_len)-iph->ihl*4,i;
int off=iph->ihl*4;
printf("%d %d\\n",iph->tot_len,ntohs(iph->tot_len));
for(i=0;i<msg;i++)
{
printf("%c",datagram[i+off... | 1 |
#include <pthread.h>
int memory[(2*960+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*960+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx ... | 0 |
#include <pthread.h>
static pthread_mutex_t m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
pthread_mutex_lock(&m_trace);
__builtin_va_start((ap));
vprintf(string, ap);
;
pthread_mutex_unlock(&m_trace... | 1 |
#include <pthread.h>
char *buffer;
int thread_size;
int buf_ptr_idx;
pthread_mutex_t mutex;
pthread_mutex_t prio_mutex;
pthread_barrier_t barrier;
void* thread_run(void *thread_idx){
pthread_mutex_lock(&prio_mutex);
pthread_mutex_unlock(&prio_mutex);
int idx = *((int *) thread_idx);
... | 0 |
#include <pthread.h>
unsigned int thread_number = 5;
unsigned int require_number = 20;
unsigned int cur_number = 0;
long sum = 0;
const char * inputfile = "input.txt";
const char * outputfile = "output.txt";
const char * splitter1 = "=";
const char * splitter2 = "\\n";
pthread_mutex_t Device... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct list_node_s{
int data;
struct list_node_s* next;
};
int Member(int value, struct list_node_s* head_p){
struct list_node_s* curr_p = head_p;
while(curr_p != 0 && curr_p->data < value){
curr_p = curr_p->nex... | 0 |
#include <pthread.h>
{
char *message;
char *dest;
unsigned mod;
} ThreadInfo, *pThreadInfo;
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void * Proc(void * args)
{
ThreadInfo ti = * (pThreadInfo)args;
int i, j;
for(i = 0; i < 10 + ti.mod; ++i)
{
while(counter % 2 != ti.mod)
;... | 1 |
#include <pthread.h>
struct control_info {
int rounds;
int bWrite;
int pages;
char * addr;
int conflict;
};
char g_buffer[(16 * 1024 + 1) * (4*1024)];
pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
unsigned int overlap_count = 0;
void unit_work(void)
{
int i;
int f,f1,f2;
s... | 0 |
#include <pthread.h>
int NMBR_PLACE_DISPONIBLE=3;
struct n_verrou{
pthread_mutex_t verrou;
pthread_cond_t condition;
int nmbr_place_max;
};
int traitement1(){sleep(1); return 0;}
int traitement2(){sleep(2);return 0;}
int traitement3(){sleep(1);return 0;}
int n_verrou_init(struct n_verr... | 1 |
#include <pthread.h>
int buffer[10];
int in;
int out;
int download_complete;
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
int fake_number;
} shared_t;
shared_t g_shared;
int get_block_from_net(int* p) {
pthread_mutex_lock(&g_shared.mutex);
*p = ++ g_shared.fake_number;
pthread_... | 0 |
#include <pthread.h>
extern int signal_quit;
extern pthread_mutex_t signal_quit_mutex;
void*
loadmonitor(void *loadhistory)
{
struct pmm_loadhistory *h;
struct pmm_load l;
int rc;
int sleep_for = 60;
int sleep_for_counter = 0;
int sleep_for_fraction = 5;
int write_pe... | 1 |
#include <pthread.h>
static long memory[2][0xFFF];
static pthread_mutex_t locks[2];
static long read(uint16_t section, uint16_t loc) {
pthread_mutex_lock(&locks[section]);
long ret = memory[section][loc];
pthread_mutex_unlock(&locks[section]);
return ret;
}
static void write(... | 0 |
#include <pthread.h>
struct npr_symbol *npr_plus_symbol, *npr_minus_symbol;
struct backet {
struct backet *chain;
struct npr_symbol *value;
};
struct table_t {
unsigned int num_backets;
struct backet **backets;
};
static struct table_t table;
static int
hash(const char *string,... | 1 |
#include <pthread.h>
int pencil = 10;
pthread_mutex_t mutex;
void *thread_producer(void *argv)
{
for (int i = 0; i < 100; i++)
{
pthread_mutex_lock(&mutex);
++pencil;
printf("thread produce a pencil %d\\n", pencil);
pthread_mutex_unlock(&mutex);
usleep(500*1000);
}
}
void *thread_co... | 0 |
#include <pthread.h>
int producerTotal = 0;
int consumerTotal = 0;
int buffer[100];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;
int producerSum = 0;
int consumerSum = 0;
int loops = 10000;
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t fill = PTHREAD_COND_INITIALIZER... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void* producer(void *ptr) {
int i;
for (i = 1; i <= 100000; i++) {
pthread_mutex_lock(&the_mutex);
while (buffer != 0)
pthread_cond_wait(&condp, &the_mutex);
buffer = i;
print... | 0 |
#include <pthread.h>
static unsigned int const MIN_TRUCK_WEIGHT = 1;
static unsigned int const MAX_TRUCK_WEIGHT = 5;
static unsigned int const MAX_TRUCKS_PER_TRIP = 5;
static unsigned int const MAX_WEIGHT_PER_TRIP = 15;
static unsigned int const MIN_FERRY_YIELDS = 5;
static unsigned int const MAX... | 1 |
#include <pthread.h>
pthread_mutex_t g_Mtx;
int g_Sum;
{
int m_Max;
int m_Num;
pthread_t m_ThrID;
} TTHRARG;
void * thrFunc ( void * arg )
{
int i;
int c = 0;
TTHRARG * data = (TTHRARG *)arg;
for ( i = 0; i < data -> m_Max; i ++ )
c += i+1;
pthread_mutex_... | 0 |
#include <pthread.h>
static pthread_cond_t bufferA_cond=PTHREAD_COND_INITIALIZER;
static pthread_cond_t bufferB_cond=PTHREAD_COND_INITIALIZER;
int indexOfbufferA=0;
int indexOfbufferB=0;
char bufferA[50][100];
char bufferB[50][100];
pthread_mutex_t bufferA_mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_... | 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;
l... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(400)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR: __VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{... | 1 |
#include <pthread.h>
{
int balance;
pthread_mutex_t mutex;
} Account;
void deposit(Account* account, int amount)
{
pthread_mutex_lock(&(account->mutex));
account->balance += amount;
pthread_mutex_unlock(&(account->mutex));
}
void transfer(Account* accountA, Account* accountB, int amou... | 0 |
#include <pthread.h>
static long NUM_ITER = 10;
static double* buffer = 0;
static int buffer_is_empty = 1;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER;
static pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;
void... | 1 |
#include <pthread.h>
struct arg_set {
char *fname;
int count;
};
struct arg_set *mailbox = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
main(int ac, char *av[])
{
pthread_t t1, t2;
struct arg_set args1, args2;
void *count_words(void... | 0 |
#include <pthread.h>
static volatile int data;
static pthread_mutex_t mutex_m = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mutex_j = PTHREAD_MUTEX_INITIALIZER;
static int is_prime(int d)
{
int i;
for (i = 2; i < d / 2; i++) {
if (d % i == 0) {
return 0;
}
}
return 1;
}
vo... | 1 |
#include <pthread.h>
int nitems;
struct {
pthread_mutex_t mutex;
int buff[1000000];
int nput;
int nval;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
void *produce(void *);
void *consume(void *);
int main(int argc,char *argv[])
{
int i, nthreads, count[100];
pthread_t tid_pr... | 0 |
#include <pthread.h>
void entry_1()
{
int r = pthread_mutex_lock(&M.mutex);
while(M.first_process_active)
pthread_cond_wait(&M.no_first_process, &M.mutex);
M.first_process_active = 1;
}
void entry_2()
{
int r = pthread_mutex_lock(&M.mutex);
while(M.second_process_active)
pthread... | 1 |
#include <pthread.h>
int ptl_timed_wait(long wait_usec){
int timed_wait_result;
struct timespec ts;
pthread_mutex_t timed_wait_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t timed_wait_cond = PTHREAD_COND_INITIALIZER;
ptl_get_future_time(&ts, wait_usec);
pthread_mutex_lock(&timed_... | 0 |
#include <pthread.h>
int region_length;
int* left;
int* right;
} Region;
pthread_mutex_t lock;
int counter;
sem_t sem;
sem_t sem2;
} Barrier;
void* thread_sort(void*);
Barrier barrier;
int nthreads, *paddr, n;
int main(int argc, char* argv[]) {
if (argc != 2) {
printf("Syntax : %s f... | 1 |
#include <pthread.h>
int LOOPS[100000000];
pthread_mutex_t mutex;
pid_t gettid() { return syscall( __NR_gettid ); }
int I = 0;
void *consumer(void *ptr)
{
int local=0;
printf("Consumer TID %lu\\n", (unsigned long)gettid());
while (1)
{
pthread_mutex_lock(&m... | 0 |
#include <pthread.h>
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t creating_theads_mutex = PTHREAD_MUTEX_INITIALIZER;
int creating_theads = 0;
int *sharedMatrisA;
int *sharedMatrisB;
int *sharedMatrisC;
int... | 1 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
} *A;
void init (struct s *p, int x) {
p -> datum = x;
p -> next = 0;
}
void insert(struct s *p, struct s **list) {
p->next = *list;
*list = p;
}
pthread_mutex_t A_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t B_mutex ... | 0 |
#include <pthread.h>
double multiplier = 1.0;
double calculate_multiplier(char *test_image_full_path)
{
gpu_time = -1.0;
cpu_time = 1.0;
running_threads = 0;
pthread_mutex_lock(&running_mutex);
running_threads++;
pthread_mutex_unlock(&running_mutex);
if(pthread_create(&cpu_thre... | 1 |
#include <pthread.h>
void *Allen(void *arg);
void *Bob(void *arg);
pthread_mutex_t book1;
pthread_mutex_t book2;
pthread_cond_t Allenfinish;
int main() {
pthread_t tid1, tid2;
pthread_create(&tid1, 0, &Allen, 0);
pthread_create(&tid2, 0, &Bob, 0);
pthread_join(tid1, 0);
pthread_join(tid2, ... | 0 |
#include <pthread.h>
static FILE *fp = 0;
static char linestr[AU_LINE_MAX];
static char *delim = ":";
static char inacdir = 0;
static char ptrmoved = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int getstrfromtype(char *name, char **str)
{
char *type, *nl;
char... | 1 |
#include <pthread.h>
{
int data;
struct link* next;
}Node;
pthread_mutex_t mutex;
pthread_cond_t cond;
Node *head = 0;
void *producer(void *arg)
{
while(1)
{
Node *newNode = (Node *)malloc(sizeof(Node));
newNode->data = rand()%99;
newNode->next = head;
pthread_mutex_lock(&mut... | 0 |
#include <pthread.h>
void producer(void);
void consumer(void);
int produce_item(void);
void insert_item(int);
int remove_item(void);
void consume_item(int);
int count = 0;
int items_array[100];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
... | 1 |
#include <pthread.h>
int
gai_cancel (struct gaicb *gaicbp)
{
int result = 0;
int status;
pthread_mutex_lock (&__gai_requests_mutex);
status = __gai_remove_request (gaicbp);
if (status == 0)
result = EAI_CANCELED;
else if (status > 0)
result = EAI_NOTCANCELED;
else
r... | 0 |
#include <pthread.h>
pthread_mutex_t atom_add_mutex;
long long atom_add(long long * addr, long long value){
pthread_mutex_lock(&atom_add_mutex);
long long ret = *addr;
*addr += value;
pthread_mutex_unlock(&atom_add_mutex);
return ret;
}
unsigned long long atomicAdd(unsigned long long *... | 1 |
#include <pthread.h>
void *philosopher (void *id);
int food_on_table (), numRefeicoes = 0;
pthread_mutex_t chopstick[5], mut;
pthread_mutex_t food_lock;
pthread_t philo[5];
int main (int argn, char **argv)
{
long i;
pthread_mutex_init (&mut, 0);
pthread_mutex_init (&food_lock, 0);... | 0 |
#include <pthread.h>
int ReadWord(FILE*, char*, int);
char *original_filename;
char *new_filename;
char line_buffer[2][50][255];
char filename[2][255];
int buffer_size[2];
bool buffer_full[2];
bool end_of_file[2];
int line_count;
pthread_cond_t buffers_empty;
pthread_mutex_t buffers_empty_lock... | 1 |
#include <pthread.h>
void
ubik_deque_init(struct ubik_deque *d)
{
pthread_mutex_init(&d->lock, 0);
d->left = 0;
d->right = 0;
}
void
ubik_deque_pushl(struct ubik_deque *d, void *e)
{
struct ubik_deque_elem *elem;
ubik_galloc((void**) &elem, 1, sizeof(stru... | 0 |
#include <pthread.h>
int thread_num;
pthread_mutex_t mutex;
long long int number_of_tosses,batch;
long long int number_in_circle=0;
time_t start,end;
double times;
void* toss()
{
long long int sample_num=0;
long long int i=0;
srand(time(0));
unsigned seed=rand();
for(;i<batch;i++)
{
... | 1 |
#include <pthread.h>
int g_Count = 0;
int nNum, nLoop;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t my_condition=PTHREAD_COND_INITIALIZER;
void *consume(void* arg) {
int inum = 0;
inum = (int)arg;
while (1) {
pthread_mutex_lock(&mutex);
printf("consum:%d\\n", in... | 0 |
#include <pthread.h>
int bufer [10];
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
void * productor();
void * consumidor();
int main (){
srand(time(0));
pthread_t h1,h2;
pthread_mutex_lock(&m2);
pthread_create(&h1,0,&productor,0);
pthread... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t up = PTHREAD_COND_INITIALIZER, down = PTHREAD_COND_INITIALIZER;
int max = 3;
int count = 0;
int going_up = 1;
void *sleeper(void *v) {
int i = 0;
pthread_mutex_lock(&mutex);
while(1) {
fprint... | 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>
struct job{
char *filename;
double *jobstorage;
double EpsMin;
int elements;
};
pthread_mutex_t lock;
int datagrabber(FILE *fptr, double *storage);
void* scann(void *);
int main(int argc, char *argv[]){
FILE *inPtr;
FILE *outPt... | 0 |
#include <pthread.h>
pthread_mutex_t mutexid;
pthread_mutex_t mutexres;
int idcount = 0;
pthread_mutex_t joinmutex[3];
int join[3];
int result[3];
int target;
int sequence[(3 * 30)];
void *thread (void *arg)
{
int id, i, from, count, l_target;
pthread_mutex_lock (&mutexid);
l_t... | 1 |
#include <pthread.h>
pthread_t tid1, tid2;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void *pthread1(void *), *arg1;
void *pthread2(void *), *arg2;
int theValue = 50;
int main()
{
int err;
if (pthread_mutex_init(&mutex1, 0) != 0)
{
printf("\\n mutex init failed\\n");
re... | 0 |
#include <pthread.h>
extern pthread_mutex_t global_data_mutex;
void update_baro_data (int baro_fd) {
char pressure[6];
float realpressure;
int read_rc;
lseek(baro_fd,0,0);
read_rc = read(baro_fd,pressure,5);
if(0 > read_rc)
{
close(baro_fd);
global_config.baro_fd = -1;... | 1 |
#include <pthread.h>
const int NUMBER_OF_ALLOWED_ARGUMENTS = 3;
int counterTicket;
int counterProcess;
struct {
int threads;
int critical;
} arguments;
struct {
pthread_t *pthreads;
pthread_cond_t *cond;
pthread_mutex_t tickets;
pthread_mutex_t mutex;
} thread;
bool... | 0 |
#include <pthread.h>
int a = 0;
const int cycle_duration = 1000000;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* my_thread(void* dummy) {
pthread_mutex_lock(&mutex);
for(int i = 0; i < cycle_duration; i++)
a += 1;
pthread_mutex_unlock(&mutex);
return ... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
sem_t sem;
SharedInt* sip;
void *functionWithCriticalSection(int* v2) {
pthread_mutex_lock(&(sip->lock));
sip->value = sip->value + *v2;
int currvalue = sip->value;
pthread_mutex_unlock(&(sip->lock));
... | 0 |
#include <pthread.h>
int* buffer;
int nb_iter;
} test1_data;
pthread_mutex_t mutex;
void* test1(void* data)
{
test1_data* d = (test1_data*) data;
int i;
pthread_mutex_lock(&mutex);
for (i=0; i < d->nb_iter; i++)
{
(*d->buffer) += 1;
}
pthread_mutex_unlock(&mutex);... | 1 |
#include <pthread.h>
pthread_mutex_t * disponible;
int tabacos,papeles,fosforos;
pthread_mutex_t tabaco,papel,fosforo;
void administra(){
int hayIngredientes;
while(1){
hayIngredientes=0;
if(pthread_mutex_trylock(disponible)==0){
printf("El agente toma tabaco... | 0 |
#include <pthread.h>
pthread_mutex_t mutexid;
pthread_mutex_t mutexres;
int idcount = 0;
pthread_mutex_t joinmutex[3];
int join[3];
int result[3];
int target;
int sequence[(3 * 30)];
void *thread (void *arg)
{
int id, i, from, count, l_target;
pthread_mutex_lock (&mutexid);
l_ta... | 1 |
#include <pthread.h>
int map_minerals = 5000;
int minerals = 0;
int n = 0;
int m = 0;
int k = -1;
int command_centers_minerals[12] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
pthread_mutex_t mutex_workers;
pthread_mutex_t mutex_map_minerals;
pthread_mutex_t mutex_minerals;
pthread... | 0 |
#include <pthread.h>
void tslog (int level, const char * id, const char * format, ...)
{
va_list ap;
__builtin_va_start((ap));
time_t time_unix;
struct tm time_parsed;
time(&time_unix);
localtime_r(&time_unix, &time_parsed);
time_parsed.tm_year += 1900;
time_parsed.tm_mon += 1;
char *s... | 1 |
#include <pthread.h>
int count = 0;
double finalresult=0.0;
pthread_mutex_t count_mutex;
pthread_cond_t count_condvar;
void *sub1(void *t)
{
int i;
long tid = (long)t;
double myresult=0.0;
pthread_mutex_lock(&count_mutex);
if (count < 12) {
printf("sub1: thread=%ld going into wait. co... | 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) {
i... | 1 |
#include <pthread.h>
unsigned int totalDePontos = 0;
unsigned int pontosPorThread;
int totalNoCirculo = 0;
pthread_mutex_t lock;
double randf(double menor,double maior);
void *ocorrencias(void *param);
int main(int argc, char **argv) {
pthread_t tid[2];
double pi;
int i... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.