text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
void* SHM_alloc(char* shm_name, size_t len)
{
int fd = shm_open(shm_name, O_RDWR|O_CREAT,0644);
if(fd < 0)
{
printf("create share memory error.");
return 0;
}
if(ftruncate(fd,len)!=0)
{
error("truncate share memory error.... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
char const LETTERS[11] = "ABCDEFGHIJ";
void* thread_print(void*);
int turn = 0;
int main(int argc, char const *argv[])
{
long i;
int j;
pthread_t threads[10];
for ... | 0 |
#include <pthread.h>
static pthread_mutex_t queue_mutex;
void initBTServer(void (*acceptCallback)(), void (*readerCallback)(char*,int), void (*disconnectCallback)()) {
_readerCallback = readerCallback;
_acceptCallback = acceptCallback;
_disconnectCallback = disconnectCallback;
socketHand... | 1 |
#include <pthread.h>
int summer_shared_index;
pthread_mutex_t max_mutex, thresh_mutex, summ_mutex;
struct summ_args {
int ma;
double *a, *afunc, *sum;
};
void *dataworker() {
}
void *summer(void * packed_args) {
struct summ_args *args = (struct summ_args *)packed_args;
int ma = arg... | 0 |
#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);
pthrea... | 1 |
#include <pthread.h>
struct TErrNode {
struct TErrNode *next;
pthread_t thread;
size_t used;
size_t size;
struct LineInfo {
char file[64];
char function[64];
size_t line;
} *stack;
} ;
static struct TErrNode *top = 0;
static pthread_mutex_t mutex;
static struct TErrNode ... | 0 |
#include <pthread.h>
int id;
double balance;
bool bInUse;
pthread_mutex_t mutex;
pthread_cond_t freeAcc;
} Account;
Account bank[5];
pthread_mutex_t lock[5];
bool withdraw(Account* acc, double amount) {
pthread_mutex_lock(&lock[acc->id]);
if(acc->balance - amount >= 0) {
acc->balance... | 1 |
#include <pthread.h>
int grades[10] = {0};
int total_grade = 0;
int total_bellcurve = 0;
pthread_barrier_t barr1;
pthread_barrier_t barr2;
pthread_mutex_t mutex;
void* read_grades(){
FILE *grade_file = fopen("grades.txt","r");
if(grade_file == 0){
perror("Error opening fil... | 0 |
#include <pthread.h>
void *Producer(void *arg);
void *Consumer(void *arg);
time_t time;
int no;
pid_t kernelThreadID;
pthread_t posixThreadID;
} InfoStruct;
sem_t full, empty;
pthread_mutex_t mutex;
int bufferSize = 0;
InfoStruct buffer[5];
int main(void) {
pthread_t producer[2... | 1 |
#include <pthread.h>
struct mt {
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(void)
{
int fd, i;
struct mt *mm;
pid_t pid;
fd = open("mt_test", O_CREAT | O_RDWR, 0777);
ftruncate(fd, sizeof(*mm));
mm = mmap(0, sizeof(*mm), PROT_READ|PROT_WRITE, MAP_SHARED, fd, ... | 0 |
#include <pthread.h>
static pthread_mutex_t *config_openssl_mutexes;
static void
gfarm_openssl_lock(int mode, int n, const char *file, int line)
{
if (mode & CRYPTO_LOCK)
pthread_mutex_lock(&config_openssl_mutexes[n]);
else
pthread_mutex_unlock(&config_openssl_mutexes[n]);
}
static unsign... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_mutex_t minBarrier;
pthread_mutex_t maxBarrier;
pthread_cond_t go;
int numWorkers;
int numArrived = 0;
int value;
int xIndex;
int yIndex;
} MINMAX;
MINMAX min;
MINMAX max;
void Barrier() {
pthread_mutex_lock(&barrier);
numArri... | 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 interval {
double seconds;
struct timespec *time_start;
pthread_mutex_t *time_start_mutex;
struct rusage *rusage_start;
struct timespec last_time;
};
static inline void set_uninitialized(struct timespec *ts)
{
ts->tv_sec ... | 0 |
#include <pthread.h>
int
timer_create (clock_id, evp, timerid)
clockid_t clock_id;
struct sigevent *evp;
timer_t *timerid;
{
int retval = -1;
struct timer_node *newtimer = 0;
struct thread_node *thread = 0;
if (0
)
{
__set_errno (ENOTSUP);
r... | 1 |
#include <pthread.h>
int reboot(int);
static pthread_t DeadmanThread = 0;
static int DeadmanActive = 0;
static int DeadmanTimeRemaining = 0;
static pthread_mutex_t DeadmanMutex = PTHREAD_MUTEX_INITIALIZER;
static void deadman_function(void* arg)
{
while(1)
{
sleep(1);
... | 0 |
#include <pthread.h>
int array[1000];
int result[8];
int availableIndex = -1;
pthread_mutex_t lock;
void *threadFunction (void *arg)
{
int subArraySize= 1000/8;
int threadIndex = (int)arg;
int beginIndex = threadIndex * subArraySize;
int endIndex = beginIndex+subArraySize;
int res = 0, i;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int flag;
} event_t;
event_t main_event;
void *
test_thread (void *ms_param)
{
int status = 0;
event_t foo;
struct timespec time;
struct timeval now;
long ms = (long) ms_param;
printf("... | 0 |
#include <pthread.h>
pthread_mutex_t pid_mutex;
pid_t pid;
}pid_data_t;
pid_t thisPID;
pthread_mutexattr_t myattr;
int set_priority(int priority);
int get_priority();
int main(int argc, char *argv[]) {
printf("Welcome to the server\\n");
int fildescr=shm_open("/sharedpid",O_RDWR|O_CREAT,S_I... | 1 |
#include <pthread.h>
int main() {
pthread_mutex_t mu1, mu2;
pthread_mutex_init(&mu1, 0);
pthread_mutex_init(&mu2, 0);
pthread_mutex_lock(&mu1);
pthread_mutex_lock(&mu2);
pthread_mutex_unlock(&mu2);
pthread_mutex_unlock(&mu1);
pthread_mutex_lock(&mu2);
pthread_mutex_lock(&mu1)... | 0 |
#include <pthread.h>
struct ThreadsafeBufferContext* threadsafe_buffer_context_new() {
struct ThreadsafeBufferContext* context = (struct ThreadsafeBufferContext*) malloc(sizeof(struct ThreadsafeBufferContext));
if (context != 0) {
context->buffer_size = 0;
context->buffer = 0;
pth... | 1 |
#include <pthread.h>
sem_t maitreD;
int sem_init(sem_t *maitreD, int pshared, unsigned int value);
int rendezvous_count = 0;
pthread_mutex_t rendezvous_count_mutex;
pthread_cond_t rendezvous_count_threshold_cv;
int rendezvous_oncePerCycle = 0;
void *task (void *t) {
int i;
int busyT... | 0 |
#include <pthread.h>
void *calculSomme(void *args);
struct matrice
{
unsigned int nbLigne;
unsigned int nbColonne;
int **element;
int sommeFinal;
};
pthread_mutex_t mutex;
struct matrice *matrice = 0;
int main(int argc, char *argv[])
{
srand(time(0));
int i = 0, j = 0;
... | 1 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
long long n;
double total_int;
double a, b, h;
pthread_mutex_t mutex;
void* Trap (void* rank);
double f (double x);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
int main(int argc, char* argv[])
{
l... | 0 |
#include <pthread.h>
char *messages[8];
pthread_mutex_t mutexsum;
struct thread_data
{
int thread_id;
int sum;
char *message;
};
struct thread_data thread_data_shared;
void *PrintHello(void *threadarg)
{
int taskid, sum;
char *hello_msg;
struct thread_data * my_data;
my_d... | 1 |
#include <pthread.h>
{
pthread_mutex_t fine_sondaggio;
sem_t barrier;
int sondaggi_terminati;
} Barriera;
{
pthread_mutex_t lock;
int voti[10];
} Sondaggio;
Sondaggio sondaggi[10];
Barriera b;
pthread_mutex_t film_lock;
pthread_t spettatori[10];
int winner;
int found_wi... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("prepare locks...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent locks ...\\n");
pthread... | 1 |
#include <pthread.h>
pthread_mutex_t gmutex;
int x = 0;
void *thread_func(void *arg)
{
int myid = (int) arg;
pthread_mutex_lock(&gmutex);
x = x + myid;
printf("Hello from thread %d x = %d\\n", myid, x);
pthread_mutex_unlock(&gmutex);
pthread_ex... | 0 |
#include <pthread.h>
void *gpsdthread(void *ptarg)
{
struct gps_data_t data;
struct gpsdthread_context *ctx;
int r;
double last_update = 0;
struct timespec ts;
ctx = (struct gpsdthread_context *)ptarg;
r = gps_open("localhost", DEFAULT_GPSD_PORT, &data);
if (r != 0) {
fp... | 1 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("preparing locks...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent unlocking locks...\\n"... | 0 |
#include <pthread.h>
static void *threader(void *args)
{
struct async *self = (struct async *)args;
struct async_task *tmp;
struct async_task task;
for (;;) {
pthread_mutex_lock(&self->lock);
if (self->count == 0 && !self->shutdown)
pthread_cond_wait(&self->notify, &self->lock);
if ... | 1 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static int currentLockOwerId = -1;
void std_inst_lock();
void std_inst_unlock();
static FILE* ofile = 0;
extern long g_flag;
FILE* OutputFile() {
if (ofile == 0) {
ofile = fopen("llfi.stat.trace.txt", "w"... | 0 |
#include <pthread.h>
struct readerArgs
{
int fd;
size_t number;
};
union semun
{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
ssize_t pgetLine(int fd, char *str, size_t maxLength, off_t offset);
void getCurrentTime(char *str, size_t maxLengt... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int num=0;
void* numOne(void *p){
pthread_mutex_lock(&lock);
while (num) {
num=0;
}
pthread_mutex_unlock(&lock);
return 0;
}
void* numZero(void *p){
pthread_mutex_lock(&lock);
while(!num) {
num=1;
}
pthread_mutex_unlock(&lock);
retu... | 0 |
#include <pthread.h>
long NTHREADS = 8;
double pi = 0;
long t_atis;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* runner(void* arg) {
long a;
int pi_t = 0;
unsigned int random = rand();
unsigned int* random_ptr = &random;
for (a = 0; a < t_atis; a++) {
double k = rand_... | 1 |
#include <pthread.h>
static void thread_create(pthread_t *tid,void *(*fun)(void *));
static void thread_wait(pthread_t tid);
void * fun1(void *arg);
void * fun2(void *arg);
pthread_mutex_t lock;
int sum = 0;
int main(int argc, char const *argv[])
{
pthread_mutex_init(&lock,0);
... | 0 |
#include <pthread.h>
int N;
int maxnum;
char *Init;
int PRINT;
matrix A;
double b[4096];
double y[4096];
{
pthread_mutex_t lock;
pthread_cond_t cond;
int count;
} barrier_t;
static barrier_t barrier;
int thread_num = 8;
void work(void);
void *gaussian_work(void* thr_id);
void Init_Matr... | 1 |
#include <pthread.h>
static volatile int counter = 0;
int threshold;
pthread_mutex_t lock;
void *mythread(void *arg) {
int i;
int localCounter = 0;
for (i = 0; i < 1000000; i++)
{
localCounter++;
if (localCounter == threshold) {
pthread_mutex_l... | 0 |
#include <pthread.h>
pthread_t tid1, tid2;
int g_Flag = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* thread1(void *);
void* thread2(void *);
int main(void)
{
if(pthread_create(&tid2, 0, thread2, 0) != 0)
return -2;... | 1 |
#include <pthread.h>
pthread_mutex_t me;
} track_t;
track_t tracks[2];
} station_t;
int station;
int direction;
int id;
} train_t;
int *choices;
int remaining;
} selector_t;
station_t *stations;
track_t *tracks;
train_t *trains;
int n_stations;
int n_trains;
sel... | 0 |
#include <pthread.h>
pthread_mutex_t a;
void* fn1(void * args){
int x, l, j, k;
x = 0;
l = 0;
pthread_mutex_lock(&a);;
j = 0;
if( k != 25 ){
if( k == 21 ){
pthread_mutex_unlock(&a);;
} else {
}
} else {
k = 13;
pthread_mutex_lock(&a);;
}
pthread_mutex_lock(&a);... | 1 |
#include <pthread.h>
int count;
int pending_posts;
} sem_t;
sem_t sem_producer;
sem_t sem_consumer;
pthread_mutex_t mut_buf = {0,0};
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-... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int VAR = 0;
void* p_inc(void* arg) {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 5;
ts.tv_nsec = 0;
int res = pthread_mutex_timedlock(&mutex, &ts);
for (int i = 0; i < 100000; i++) {
VAR+... | 1 |
#include <pthread.h>
int thread_count = 0;
static pthread_mutex_t mutex_stock = PTHREAD_MUTEX_INITIALIZER;
struct args {
int* a;
int n;
int level;
};
void args_init(struct args * args, int *a , int n, int level)
{
args->a = a;
args->n = n;
args->level = level;
}
void quick_sort (str... | 0 |
#include <pthread.h>
unsigned long top = 0;
unsigned long bottom = 1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* checkPrime(void *arg)
{
unsigned long num = *(unsigned long *) arg;
for (unsigned long i = 2; i <= num / 2; i++)
{
if (num % i == 0) {
pthread_exit(0);
... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
int do_count(void)
{
int n;
pthread_mutex_lock(&counter_mutex);
count = count + 5;
n = count -5;
pthread_mutex_unlock(&counter_mutex);
return n;
}
void my_copy(const char *s, FILE **fp... | 0 |
#include <pthread.h>
pthread_mutex_t Device_mutex;
struct VirtualPCB
{
int tid;
char state;
int priority;
int arrivetime;
int cpuburst;
int needtime;
int waittime;
}PCB[20];
void thread_init()
{
int n;
srand(time(0));
for(n=0; n<20; n++)
{
PCB[n].tid = n+1;
PCB[n].state = 'F';
... | 1 |
#include <pthread.h>
int mystack_init(struct mystack* stack)
{
pthread_mutexattr_t mutex_attr;
pthread_mutexattr_init(&mutex_attr);
pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE_NP);
pthread_mutex_init(&stack->mutex, &mutex_attr);
pthread_mutexattr_destroy(&mutex_attr);
... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
long long n;
double sum;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double Serial_pi(long long n);
int main(int argc, char* argv[]) {
long thr... | 1 |
#include <pthread.h>
void study(int ID);
void * foodDeliveryService(void * size_of_order);
void * studentActions(void * ID);
pthread_t * students;
pthread_t deliveryWorker;
int delivery_service_called = 0;
int * studentID;
pthread_mutex_t food_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t no... | 0 |
#include <pthread.h>
int MyTurn = 0;
{
pthread_mutex_t *lock;
pthread_cond_t *wait;
int id;
int size;
int iterations;
char *s;
int nthreads;
} Thread_struct;
void *infloop(void *x)
{
int i, j, k;
Thread_struct *t;
t = (Thread_struct *) x;
for (i = 0; i < t->iterations; i++)
{... | 1 |
#include <pthread.h>
void
signal_dispatch (struct signal_state *ss, siginfo_t *si)
{
SIGNAL_DISPATCH_ENTRY;
int signo = si->si_signo;
assert (signo > 0 && signo < NSIG);
assert (pthread_mutex_trylock (&ss->lock) == EBUSY);
do
{
if ((sigmask (signo) & STOPSIGS))
{
s... | 0 |
#include <pthread.h>
struct dte_request_queue *dte_req_q;
struct dte_alloc_info_t dte_alloc_info;
void init_dte_request_queue(struct dte_request_queue **p_dte_req_q)
{
int i;
struct dte_request *reserved_dte_request;
*p_dte_req_q = (struct dte_request_queue *)malloc(sizeof(struct dte_request_... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
int NUMTHRDS;
int VECLEN;
DOTDATA dotstr;
pthread_t *callThd = 0;
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg... | 0 |
#include <pthread.h>
int n;
char str[1024];
int print_turn = 0;
pthread_cond_t cond_print_turn = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mtx_print_turn = PTHREAD_MUTEX_INITIALIZER;
void*
print_thread(void* my_turn)
{
long my_turn_idx = (long)my_turn;
for (;;) {
pthread_mutex_l... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int scholarship = 4000;
static int total = 0;
static void *calculate(void *data);
struct Data
{
const char *name;
int doze;
};
int main(void)
{
pthread_t tid1;
pthread_t tid2;
pthread_t t... | 0 |
#include <pthread.h>
int s = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *ExecutaTarefa (void *threadid) {
int i;
int tid = (int) threadid;
printf("Thread : %d esta executando...\\n", (int) tid);
for (i=0; i<10000000; i++) {
pthread_mutex_lock(&mutex);
s++... | 1 |
#include <pthread.h>
int proto_listenfd;
int proto_vsftp_listenfd;
int proto_stop = 1;
pthread_t proto_listen_tid;
void *proto_listen_thread( void *args );
pthread_t proto_reqhand_tid;
void *(*proto_reqhand_thread)( void *args );
pthread_mutex_t proto_sockfd_pass_mutex;
pthread_cond_t... | 0 |
#include <pthread.h>
int thread_count;
int barrier_thread_counts[100];
pthread_mutex_t barrier_mutex;
void Usage(char* prog_name);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread, i;
pthread_t* thread_handles;
double start, finish;
if (argc != 2)
... | 1 |
#include <pthread.h>
long i;
pthread_t r[10];
pthread_t w[4];
long shared = 999;
pthread_mutex_t wlock;
pthread_mutex_t rclock;
int reader_count = 0;
void * writer(void * index) {
long w = (long)index;
while(1) {
pthread_mutex_lock(&wlock);
shared = random() % 1000;
... | 0 |
#include <pthread.h>
pthread_mutex_t full_mutex = PTHREAD_MUTEX_INITIALIZER;
int full = 0;
int count = 0;
void* produce(void* x){
while(1){
while(full){
}
pthread_mutex_lock(&full_mutex);
count++; full = 1;
printf("Produced: %d\\n", count);
pthread_mutex_unlock(&full_mutex)... | 1 |
#include <pthread.h>
pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t net_bh_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t net_bh_wakeup = PTHREAD_COND_INITIALIZER;
int net_bh_raised = 0;
struct task_struct current_contents;
int
sock_wake_async (struct socket *so... | 0 |
#include <pthread.h>
void *hiloGetWEB(void *);
void *hiloGetWEB(void *);
int conexiones_add (char *url);
pthread_t thread_id [5];
pthread_mutex_t mutexPool = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexCounter = PTHREAD_MUTEX_INITIALIZER;
int poolCounter = ... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp, condp2;
int buffer[100];
int i = 0;
void * producer(void *ptr)
{
while(1)
{
printf("producer locking critical region\\n");
pthread_mutex_lock(&the_mutex);
while( i == 100)
{
printf("buffer not empty, pr... | 0 |
#include <pthread.h>
pthread_mutex_t _sock_lock;
void _bb_init_bb(){
if(pthread_mutex_init(&_sock_lock, 0) != 0){
puts("Failed to initialize mutex.");
exit(1);
}
}
int blox_sendDirectlyl(char* line, int len){
if(!irc_conn){
return -1;
}
if(!line){
... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(800)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_to... | 0 |
#include <pthread.h>
struct msg
{
struct msg *msg_next;
time_t msg_time;
};
struct msg *head;
pthread_cond_t qcond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;
void *
process (void *arg)
{
struct msg *mp;
for (;;)
{
pthread_mutex_lock (&mlock);... | 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>
long counter;
pthread_mutex_t lock;
time_t end_time;
void *c_thread(void *args){
int i;
while(time(0) < end_time){
pthread_mutex_lock(&lock);
for(i=0;i<10000000;i++){
counter++;
}
pthread_mutex_unlock(&lock);
}
return 0;
}
void *m_... | 1 |
#include <pthread.h>
int thread_count = 4;
int n = 10000;
double a = 0.0;
double b = 10.0;
double h;
int local_n;
int flag;
sem_t sem;
pthread_mutex_t mutex;
double total_flag = 0.0;
double total_sem = 0.0;
double total_mutex = 0.0;
void *Thread_work(void* rank);
double Trap(double local_a,... | 0 |
#include <pthread.h>
pthread_cond_t cond_empty, cond_full;
pthread_mutex_t mutex;
int count = 0, in = 0, out = 0;
int buffer[3];
void *produtor(void *arg) {
while (1) {
sleep(rand()%5);
pthread_mutex_lock(&mutex);
while (count == 3)
pthread_cond_wait(&cond_empt... | 1 |
#include <pthread.h>
struct arg_set{
int count;
char *fname;
};
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
struct arg_set *mailbox = 0;
void *count_words(void *a)
{
struct arg_set *args = a;
FILE *fp;
int c, prevc = '\\0';
if((fp = f... | 0 |
#include <pthread.h>
bool
receiver_data_raw(struct mux *mx, uint8_t chnum)
{
struct muxbuf *mxb = &mx->mx_buffer[MUX_IN][chnum];
uint16_t mss;
uint8_t *cmd = mx->mx_recvcmd;
size_t len1, len2, tail;
int err;
if (!sock_recv(mx->mx_socket, cmd, MUX_CMDLEN_DATA - 2)) {
logmsg_err("Receiv... | 1 |
#include <pthread.h>
void generate();
void Read();
void *func1(void *arg);
void *func2(void *arg);
void calculate();
void resultToFile();
int A[1000]={0};
int prefix_sum[1000]={0};
int temp[1000]={0};
int n;
pthread_t tids[1000][1000];
pthread_mutex_t mutex;
struct S
{
int i ;
int j ;
};
i... | 0 |
#include <pthread.h>
void error_out(int errnum) {
switch(errnum) {
case 0:
fprintf(stderr, "Usage: ./search-engine [num-indexer-threads] [list-of-files.txt]\\n");
exit(1);
case 1:
fprintf(stderr, "File does not exist.\\n");
exit(1);
case 2:
fprintf(stderr, "File s... | 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(&(sip... | 0 |
#include <pthread.h>
int nitems;
int buff[1000000];
struct {
pthread_mutex_t mutex;
int nput;
int nval;
} put = {
PTHREAD_MUTEX_INITIALIZER, 0, 0
};
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
} nready = {
PTHREAD_MUTEX_INITIALIZER, PTHREAD... | 1 |
#include <pthread.h>
int countA;
int countB;
pthread_mutex_t mutex;
} Counter;
void* TF1(void*);
void* TF2(void*);
sem_t *b1, *b2, *print;
Counter *c;
int main(int argc, char **argv) {
if (argc != 2)
{
return -1;
}
b1 = (sem_t *) malloc(sizeof(sem_t));
b2 = (sem_t *) mall... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[8];
pthread_mutex_t mutexsum;
void *dotprod(void *arg){
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
le... | 1 |
#include <pthread.h>
pthread_cond_t full_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t data_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t num_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t pthread[10];
int num_thread = 0;
int isFull = 0;
void *accessR (void*);
int main (int argc, char*... | 0 |
#include <pthread.h>
int readersInQueue = 0;
int writersInQueue = 0;
int readersInLibrary = 0;
int writersInLibrary = 0;
pthread_mutex_t varMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t libraryMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t entryCond = PTHREAD_COND_INITIALIZER;
unsigned lon... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PHTREAD_MUTEX_INITIALIZER;
extern char **environ;
static void
thread_init(void)
{
pthread_key_create(&key, free);
}
char *
getenv(const char *name)
{
i... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *generator_function(void *arg);
void *print_function(void *arg);
long sum;
long finished_producers;
int main(void) {
pthread_t generatorThre... | 1 |
#include <pthread.h>
pthread_mutex_t downloader_mutex, parser_mutex;
unsigned long downloaders[MAX_THREADS];
unsigned long parsers[MAX_THREADS];
int downloader_threads = 0;
int parser_threads = 0;
char *fetch(char *link) {
int fd = open(link, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "f... | 0 |
#include <pthread.h>
int x = 0;
pthread_mutex_t x_mutex;
pthread_cond_t x_cond;
void *A (void *t) {
int boba1, boba2;
printf("A: Comecei\\n");
boba1=10000; boba2=-10000; while (boba2 < boba1) boba2++;
printf("HELLO\\n");
pthread_mutex_lock(&x_mutex);
x++;
if (x==2) {... | 1 |
#include <pthread.h>
sem_t SEntrada;
pthread_mutex_t C1;
pthread_mutex_t C2;
char est[24];
pthread_t th_auto[19];
int lugar;
void automovil( void *id );
int entrada( void *id ,int puerta);
void salida( void *id ,int salida,int lug);
void tiempo(int time);
void interfaz();
int main()
{
int ... | 0 |
#include <pthread.h>
struct ThumbQueue {
struct ThumbQueue *next;
char *uri;
char *flavour;
int id;
};
struct {
pthread_mutex_t mutex;
struct ThumbQueue *first;
struct ThumbQueue *last;
sem_t work;
pthread_t thread;
int counter;
} thumb_state;
struct ThumbMemBuffer {
void *data;
in... | 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;
char message[1024];
int clnt_socks[256], level[7];
int max_cnt;
int message_cnt=0;
pthread_mutex_t mutx=PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char *argv[... | 0 |
#include <pthread.h>
int count;
double values[10];
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void push(double v) {
pthread_mutex_lock(&m);
values[count++] = v;
pthread_mutex_unlock(&m);
}
double pop() {
pthread_mutex_lock(&m);
double v = values[--count];
pthread_m... | 1 |
#include <pthread.h>
static pthread_mutex_t owsl_openssl_user_mutex ;
static size_t owsl_openssl_user_count ;
static pthread_mutex_t * owsl_openssl_mutex_array = 0 ;
static size_t owsl_openssl_mutex_size ;
struct CRYPTO_dynlock_value
{
pthread_mutex_t mutex ;
} ;
int
owsl_openssl_wrapper_initi... | 0 |
#include <pthread.h>
double h;
double result;
int N;
double step;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double exp(double x);
double f(double x){
return x*x;
}
void *partialTrapezoid(void *inter){
double *interval = ((double *) inter);
int i;
double x_i;
double a = i... | 1 |
#include <pthread.h>
static pthread_t buffer_dump_thread, read_log_thread;
static char *key, *buf;
static int cur_pos = 0, fd;
static FILE *flog;
static pthread_mutex_t buf_access;
static void *buffer_dump(void *arg) {
int t;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &t);
pthread_setcance... | 0 |
#include <pthread.h>
pthread_mutex_t mx, my;
int x=2, y=2;
void *thread1() {
int a;
pthread_mutex_lock(&mx);
a = x;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
pthread_mutex_unlock(&my);
a =... | 1 |
#include <pthread.h>
static int buffer[8];
static int n = 0;
static pthread_mutex_t lock;
static pthread_mutex_t mutex;
pthread_cond_t fila = PTHREAD_COND_INITIALIZER;
void produtor(void)
{
int i;
for(i = 0; i < 64; i++)
{
if(n == 8)
{
pthread_cond_wait(&fila, &mutex);
}
... | 0 |
#include <pthread.h>
pthread_t cons[2];
pthread_t prod[2];
pthread_mutex_t buffer_mutex;
int buffer[1000];
int prod_pos=0, cons_pos=0;
void *produtor(void *arg) {
int n;
while(1) {
n = (int)(drand48() * 1000.0);
pthread_mutex_lock(&buffer_mutex);
buffer[prod_pos] = n;
prod_pos = (pr... | 1 |
#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++) {
... | 0 |
#include <pthread.h>
void * enanitos(void *);
void * blancanieves(void *);
sem_t sillas;
pthread_mutex_t comer = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t comiendo = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t puede_comer = PTHREAD_COND_INITIALIZER;
void * enanitos(void * p){
int valor_sem;
... | 1 |
#include <pthread.h>
pthread_mutex_t shortTermSchedulerMutex;
bool enableShortTermScheduler;
sem_t processInReady_sem;
void initializeshortTermScheduler() {
pthread_mutex_init(&shortTermSchedulerMutex, 0);
sem_init(&processInReady_sem, 1, 0);
enableShortTermScheduler = 1;
}
void... | 0 |
#include <pthread.h>
int chain;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t w = PTHREAD_COND_INITIALIZER;
pthread_cond_t all = PTHREAD_COND_INITIALIZER;
void *thread(void *arg)
{
chain -= 1;
pthread_t tid;
if (chain == 0)
{
pthread_mutex_lock(&m);
... | 1 |
#include <pthread.h>
void* osl_mutex_create()
{
int32_t ret = 0;
pthread_mutex_t *mt;
pthread_mutexattr_t pma;
mt = (pthread_mutex_t*)malloc( sizeof(pthread_mutex_t) );
if( mt )
{
memset( mt, 0, sizeof(pthread_mutex_t) );
ret |= pthread_mutexattr_init( &pma );
ret |= pthread_mute... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.