text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
{
unsigned int addr;
unsigned int size;
unsigned int caller;
struct memstat *next;
} memstat_t;
memstat_t mem_list[1000 +2];
void *(*old_malloc_hook)(size_t);
void (*old_free_hook)(void *);
memstat_t *listhead_free = &mem_list[0];
memstat_t *listhead_mem... | 1 |
#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)
{
... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_mutex_t cond_mutex;
pthread_cond_t cond;
void handler(int sig) { printf("SIGINT %d\\n", sig); (void) sig; }
void* thread_main(void* n) {
if(n != 0) {
pthread_t t;
pthread_create(&t, 0, thread_main, (void*) ((uintptr_t) n - 1... | 1 |
#include <pthread.h>
pthread_t idThdAfficheurs[20];
int tour = 0;
pthread_mutex_t affMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t tourMutex = PTHREAD_MUTEX_INITIALIZER;
void thdErreur(int codeErr, char *msgErr, void *codeArret) {
fprintf(stderr, "%s: %d soit %s \\n", msgErr, c... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_mutex_t lock2;
pthread_mutex_t lock3;
int value;
int value2;
int value3;
sem_t sem;
void *functionWithCriticalSection(int* v2) {
pthread_mutex_lock(&(lock));
value = value + *v2;
pthread_mutex_unlock(&(lock));
sem_post(&sem);
}... | 1 |
#include <pthread.h>
pthread_mutex_t monitor_protect;
pthread_cond_t self[7];
enum {THINKING,HUNGRY,EATING} state[7];
char *state_string[] = {"thinking", "hungry ", "eating "};
void random_spin(int max);
pthread_mutex_t random_protect, stderr_protect;
void test(int k)
{
if (state... | 0 |
#include <pthread.h>
pthread_mutex_t g_fastmutex = PTHREAD_MUTEX_INITIALIZER;
static void init(void)
{
int s;
if (!g_mem.init)
{
s = getpagesize() * 13;
g_mem.min = ft_stdmem(0, s);
s = 128 * s;
g_mem.med = ft_stdmem(0, s);
g_mem.init = 1;
}
}
void *malloc(size_t size)
{
void *pt... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int buffer[100];
int duration = 20;
int length = 0;
void *producer(void *arg)
{
char *str;
str=(char*)arg;
for(int i = 0; i < duration; i++) {
pthread_mutex_lock (&mutex);
buffer[length] = i;
... | 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(size... | 1 |
#include <pthread.h>
struct thrd_data{
int id;
int start;
int end;
};
int count = 0;
pthread_mutex_t count_mtx;
void *do_work(void *thrd_arg)
{
struct thrd_data *t_data;
int i,j,min, max;
int myid;
int mycount = 0;
int *primes;
int c;
int z = 1;
primes = malloc(sizeof(int)*m... | 0 |
#include <pthread.h>
int array[4];
int array_index = 0;
pthread_mutex_t mutex;
void *thread(void * arg)
{
pthread_mutex_lock(&mutex);
array[array_index] = 1;
pthread_mutex_unlock(&mutex);
return 0;
}
int main()
{
int i, sum;
pthread_t t[4];
pthread_mutex_init(&mutex, ... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int shared_data;
void *thread_function(void *arg)
{
pthread_mutex_lock(&lock);
printf("I'm in the thread function.\\n");
sleep(10);
pthread_mutex_unlock(&lock);
return 0;
}
int main(void)
{
pthread_attr_t attributes;
pthread_t threa... | 0 |
#include <pthread.h>
int ncount;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *pthread_funct(void *data) {
time_t timer;
int number;
number = *((int *)data);
char buffer[26];
struct tm* tm_info;
srand(time(0));
int r = rand()%10;
while(ncount < number) {
pthread_mutex_loc... | 1 |
#include <pthread.h>
void create_threads(int records_num);
void *start_thread(void *records_num) ;
int find_text(char *text);
int read_data(int records_num) ;
void destructor(void *data) ;
int read_records(char **data) ;
int id;
char text[RECORD_SIZE - sizeof(int)];
} record_str;
pt... | 0 |
#include <pthread.h>
pthread_mutex_t chopstick[6] ;
void *eat_think(void *arg)
{
char phi = *(char *)arg;
int left,right;
switch (phi){
case 'A':
left = 5;
right = 1;
break;
case 'B':
left = 1;
right = 2;
break;
case 'C':
left = 2;
right = 3;
break;
case 'D':
... | 1 |
#include <pthread.h>
static struct helper_data {
volatile int exit;
volatile int reset;
volatile int do_stat;
struct sk_out *sk_out;
pthread_t thread;
pthread_mutex_t lock;
pthread_cond_t cond;
struct fio_mutex *startup_mutex;
} *helper_data;
void helper_thread_destroy(void)
{
pthread_co... | 0 |
#include <pthread.h>
static double getDoubleTime();
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
int main(void) {
int res;
pthread_t a_thread[10];
void *thread_result;
int lots_of_threads;
double start_time = getDoubleTime();
res = pthread_mutex_init(&work_mutex, ... | 1 |
#include <pthread.h>
int numOfPassengersOnBus;
void* print_message(void* ptr);
pthread_mutex_t verrou;
int main(int argc, char* argv[])
{
pthread_t tProducer, tConsumer1, tConsumer2;
const char* msg1 = "Producer";
const char* msg2 = "Consumer A";
numOfPassengersOnBus = 0;
pthread_mutex... | 0 |
#include <pthread.h>
static struct quadtree *bitmaps = 0;
static struct quadtree *threadlist = 0;
static struct threadpool *threadpool = 0;
static pthread_mutex_t bitmaps_mutex;
static pthread_mutex_t running_mutex;
static pthread_attr_t attr_detached;
static void
pngloader_on_dequeue (void ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long counter = 0;
struct pthread_args
{
unsigned int chunk_size;
char *buffer;
unsigned int* histogram;
};
void * local_histo (void * ptr)
{
unsigned int i;
struct pthread_args *arg = ptr;
while (arg->buffer[... | 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++;
... | 1 |
#include <pthread.h>
pthread_mutex_t sum_mutex, min_mutex, max_mutex;
int numWorkers;
double read_timer() {
static bool initialized = 0;
static struct timeval start;
struct timeval end;
if( !initialized )
{
gettimeofday( &start, 0 );
initialized = 1;
}... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cc = PTHREAD_COND_INITIALIZER;
pthread_cond_t cp = PTHREAD_COND_INITIALIZER;
int tam_cola = 0;
int total_items = 0;
double tiempo_prod = 0;
double tiempo_cons = 0;
int cola = 0;
int producidos = 0;
int consumi... | 1 |
#include <pthread.h>
static struct {
int value;
pthread_mutex_t mutex;
} money;
static void *make_money(void *arg)
{
bool mutex_done = 0;
if (!mutex_done &&
!pthread_mutex_trylock(&money.mutex)) {
++money.value;
mutex_do... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int i =1;
void* thread1(void* arg)
{
for(i = 1; i < 10; i++)
{
pthread_mutex_lock(&mutex);
printf("thread1:i=%d\\n",i);
if(i % 3 == 0) {
printf("thread1: I will no... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int count=0;
void AddCount_Odd_Func(void);
void AddCount_Even_Func(void);
int main()
{
int ret;
pthread_t odd_thread,even_thread;
pthread_attr_t thread_attr;
count = 0;
pthread_mutex_init(&mutex,0);
pthread_cond_in... | 0 |
#include <pthread.h>
int buf[100];
int count = 0;
int id;
} ids;
pthread_mutex_t lock;
pthread_cond_t cond;
void producer(void* arg){
ids* args = (ids*)arg;
int id = args->id;
while(1){
pthread_mutex_lock(&lock);
if (count == 100){
printf("B... | 1 |
#include <pthread.h>
{
off_t pos;
off_t nbytes;
}COMPUTE_INFO,*PCOMPUTE_INFO;
value_type mmap_compute(off_t pos,off_t nbytes);
void thread_compute(void *param);
char *g_src = 0;
int g_nthreads = 0;
value_type g_final_res = 0;
pthread_mutex_t nthreads_mutex;
int main(int argc,char **argv)
... | 0 |
#include <pthread.h>
pthread_mutex_t mp = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t turno = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t prod = PTHREAD_COND_INITIALIZER;
pthread_cond_t cons = PTHREAD_COND_INITIALIZER;
void * produtor(void * arg);
void * consumidor(void * arg);
double drand4... | 1 |
#include <pthread.h>
int chairs[3];
int available_chairs;
int ta_state;
int waker;
pthread_mutex_t sleeplock;
pthread_mutex_t chairlock;
pthread_mutex_t sleepm;
pthread_mutex_t dusunceli_ta;
pthread_cond_t ta_sleeping = PTHREAD_COND_INITIALIZER;
pthread_cond_t ta_helping = PTHREAD_COND_INITIA... | 0 |
#include <pthread.h>
int g1, g2, g3;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
void *t1(void *arg) {
pthread_mutex_lock(&mutex1);
pthread_mutex_lock(&mutex2);
g1 = g2 + 1;
pt... | 1 |
#include <pthread.h>
pthread_mutex_t tcb_alloc_mutex;
extern const unsigned int socket_tcb_ring_size ;
const unsigned int tcb_socket_ring_size = 1024;
int Ntcb = 0;
struct tcb *tcbs[10];
void InitTcpTcb()
{
InitSocketTcbRing();
InitSocketInterface();
int i;
for(i=0;i<10; i++) {
... | 0 |
#include <pthread.h>
struct ritual_dynump * ritual_dynump_create(int sz) {
struct ritual_dynump *rv = malloc(sizeof *rv);
rv->element_size = sz;
rv->current = ritual_ump_create( sz );
if( !rv->current ) {
free( rv );
return 0;
}
if( pthread_mutex_init( &rv... | 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<=10; i++)
{
pthread_mutex_lock(&the_mutex);
while(buffer !=0) pthread_cond_wait(&condp, &the_mutex);
printf("procucer prod... | 0 |
#include <pthread.h>
static pthread_t bws_pusher;
static int bws_timer = 0;
void * bws_thread (void * args);
void init_bws(int interval) {
int t1;
sem_init(&s_bws_hasdata, 0, 0);
sem_init(&s_bws_processed, 0, 0);
bws_timer = interval;
t1 = pthread_create(&bws_pusher, 0, bws_threa... | 1 |
#include <pthread.h>
int N;
int maxnum;
char *Init;
int PRINT;
matrix A;
double b[4096];
double y[4096];
pthread_barrier_t barrier;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void
Init_Matrix()
{
int i, j;
printf("\\nsize = %dx%d ", N, N);
printf("\\nmaxnum = %d... | 0 |
#include <pthread.h>
{
int res;
int count;
pthread_cond_t cond;
pthread_mutex_t mutex;
}Result;
void *set_fn(void *arg)
{
Result *r = (Result*)arg;
int i = 1;
int sum = 0;
for(; i <= 100; i++){
sum += i;
}
r->res = sum;
pthread_mu... | 1 |
#include <pthread.h>
unsigned int counter = 1;
unsigned int result = 0;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t result_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t print_mutex = PTHREAD_MUTEX_INITIALIZER;
bool is_pandig( int* );
bool is_pandig2( int*, i... | 0 |
#include <pthread.h>
void traitantSIGINT(int num){
double pourcentageReussite;
pthread_mutex_lock(&mCptExitFaux);
pthread_mutex_lock(&mCptVoitures);
pourcentageReussite=(1-(double)cptExitFaux[0]/((double)cptVoitures[VRAI]+(double)cptVoitures[FAUX]))*100;
printf("\\nLe pourcentage de réussite... | 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
child(void)
{
printf("child unlocking locks ...\\n"... | 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;
int f_id;
struct foo * f_next;
};
struct foo *foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(str... | 1 |
#include <pthread.h>
double delta=1;
int thread_count = -1;
double area=0;
pthread_mutex_t mut;
struct my_thread_rank
{
int rank;
};
int get_max_threads()
{
int max_string_size = 10;
FILE *fp;
char* ret;
int max = -1;
char str[max_string_size];
fp = fopen("/proc/sys/kernel/threads-max","r"... | 0 |
#include <pthread.h>
void* producer(void* arg);
void* consumer(void* arg);
int buffer[100];
int count = 0;
int input = -1;
int output = -1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t space_required = PTHREAD_COND_INITIALIZER;
pthread_cond_t data_required = PTHREAD_C... | 1 |
#include <pthread.h>
struct virgo_address
{
int node_id;
struct hostport* hstprt;
void* addr;
};
struct hostport
{
char* hostip;
int port;
};
void virgo_systemcalls(pthread_mutex_t* lock,int process);
int main(int argc, char* argv[])
{
pthread_mutex_t lo... | 0 |
#include <pthread.h>
pthread_t main_thread;
pthread_attr_t detached_attr;
pthread_attr_t joinable_attr;
int n_threads = 50;
pthread_mutex_t dthrds_create_mutex;
void
create_thread (pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg)
{
pthread_t child;
int rc;
w... | 1 |
#include <pthread.h>
void* data[100];
int size;
} Stack;
void Stack_Init(Stack *S)
{
S = (Stack *)malloc(sizeof(S));
S->size = 0;
}
int Stack_Empty(Stack *S){
return S->size;
}
void* Stack_Top(Stack *S)
{
if (S->size == 0) {
fprintf(stderr, "Error: stack empty\\n");... | 0 |
#include <pthread.h>
pthread_cond_t cond_empty, cond_full;
pthread_mutex_t mutex;
int count = 0, in = 0, out = 0;
int contadorConsumo = 0;
int buffer[3];
void *produtor(void *arg)
{
while (1)
{
pthread_mutex_lock(&mutex);
while (count == 3)
pthread_cond_wait(&c... | 1 |
#include <pthread.h>
int nb_philo;
int nb_Grain_De_Riz = 5;
pthread_mutex_t * mutexs;
sem_t sem;
struct philo
{
int identifiant;
};
void initialisation(){
srand (time (0));
sem_init(&sem,0,nb_philo-1);
mutexs = malloc(nb_philo*sizeof(pthread_mutex_t));
for(int i... | 0 |
#include <pthread.h>
struct link{
struct link *next;
char *value;
};
int no_of_links = 0;
struct link *head_of_queue, *tail_of_queue;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int add_to_queue(char *value)
{
pthread_mutex_lock(&lock);
if (no_of_links == 0) {
tail_of_queue =... | 1 |
#include <pthread.h>
struct addict *init_addict(unsigned int time, unsigned int cost,
struct server *server, struct server *next)
{
struct addict *addict = malloc(sizeof(struct addict));
check(!addict, out);
addict->order_time = time;
addict->order_cost = cost;
... | 0 |
#include <pthread.h>
void process_data(char *buffer, int bufferSizeInBytes);
int get_external_data(char *buffer, int bufferSizeInBytes);
int min(int a, int b) { return a > b ? b : a; }
int get_external_data(char *buffer, int bufferSizeInBytes)
{
int status;
int val;
char srcString... | 1 |
#include <pthread.h>
static void* collector (void* arg){
int fd_skt, i, j;
struct sockaddr_un sockAdd;
char string[10];
planet_t* p;
strncpy(sockAdd.sun_path, SOCKNAME, UNIX_PATH_MAX);
sockAdd.sun_family=AF_UNIX;
fd_skt = socket(AF_UNIX, SOCK_STREAM, 0);
if(fd_skt == -1){
perror("E... | 0 |
#include <pthread.h>
int main(int argc, char *argv[])
{
int err;
struct timespec tout;
struct tm *tmp = 0;
char buf[64] = "";
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&lock);
printf("mutex is locked\\n");
clock_gettime(CLOCK_REALTIM... | 1 |
#include <pthread.h>
struct thread_global{
char global_buf[188*7];
int size_var;
int flag;
};
struct ts_data{
char addr_buf[32];
int port_no;
int soid;
double bit_rate;
};
struct ts_send{
char addr_buf_1[32];
int port_no_1;
int soid_1;
double bit_rate_1;
};
struct thread_global i... | 0 |
#include <pthread.h>
int
xshmfence_trigger(struct xshmfence *f) {
pthread_mutex_lock(&f->lock);
if (f->value == 0) {
f->value = 1;
if (f->waiting) {
f->waiting = 0;
pthread_cond_broadcast(&f->wakeup);
}
}
pthread_mutex_unlock(&f->lock)... | 1 |
#include <pthread.h>
double a, b, ht,total;
pthread_mutex_t mutex;
int thread_size, n, interval;
double f(double x)
{
double func;
func=x*x;
return func;
}
double Trap (double point_a,double point_b,int trap_count,double length)
{
double value, x;
value = (f(point_a)+ f(point_b))/2.0;
... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5] ;
void *sim(void *p)
{
int i = (int)p;
while(1)
{
printf("Philosopher %d is hungry\\n",i);
if(i == 4)
{
pthread_mutex_lock(&forks[0]);
printf("Philosopher %d taking right fork\\n",i);
sleep(1);
... | 1 |
#include <pthread.h>
struct global_data{
int count;
pthread_mutex_t mtx;
sem_t sem_a;
sem_t sem_b;
};
void * task_a(void * ctx)
{
struct global_data *d = ctx;
int i;
printf("started task_a\\n");
for(i=0; i < d->count; ++i){
sem_wait(&d->sem_a);
pthread_mute... | 0 |
#include <pthread.h>
int g_Flag=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* thread1(void *arg)
{
int err = 0;
printf("Enter thread 1\\n");
printf("This is thread 1, g_Flag:%d, thread id is %u\\n",g_Flag,(unsigned int)pthread... | 1 |
#include <pthread.h>
pthread_mutex_t s = PTHREAD_MUTEX_INITIALIZER;
int client_id= -1;
void *handle_client(void *arg)
{
int conn_s = *(int *)arg;
char buffer[1024], buffer2[1024];
int res;
pthread_mutex_lock(&s);
int CID = ++client_id;
pthread_mutex_unlock(&s);
fpri... | 0 |
#include <pthread.h>
static pthread_mutex_t linkage_mutex = PTHREAD_MUTEX_INITIALIZER;
static int linkage_warning = 0;
const char *avahi_exe_name(void) {
static char exe_name[1024] = "";
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mutex);
... | 1 |
#include <pthread.h>
static volatile int quit, riseandwhine;
static pthread_mutex_t closermtx;
static pthread_cond_t closercv;
static void *
closer(void *arg)
{
pthread_mutex_lock(&closermtx);
while (!quit) {
while (!riseandwhine)
pthread_cond_wait(&closercv, &closermtx);
riseandwh... | 0 |
#include <pthread.h>
int thread_count;
int barrier_thread_counts[1000];
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) Us... | 1 |
#include <pthread.h>
extern int on_txn_abort(int);
int mutually_serializable(int txnid, int files_read_bit, char *file_path,long f_inode,int f_flags)
{
struct txn_node *ptr_txn_node;
int before_after_bit;
int abort_txnid;
int local_wait =0;
int i;
pthread_mutex_lock(&txn_mute... | 0 |
#include <pthread.h>
struct job {
struct job* next;
int num;
};
struct job* job_queue;
struct job* tail;
sem_t job_queue_count;
void print_list(struct job * job_list){
int i;
i=1;
struct job* aux = job_queue;
while(aux != 0){
printf("%d) %d\\n",i,aux->num);
aux = aux->next;
i++;... | 1 |
#include <pthread.h>
void *student_loop(void *param)
{
int times_through_loop = 0;
int sleep_time = 0;
srandom((unsigned)time(0));
while (times_through_loop < 5) {
sleep_time = (int)((random() % MAX_SLEEP_TIME)+1);
hang_out(param, sleep_time);
if (pthread_mutex_lock(&m... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t is_zero;
static int shared_data = 32767;
void *func1(void *arg)
{
while(shared_data != 0)
{
printf("%s: waitinf for is_zero\\n", __func__);
pthread_cond_wait(&is_zero, &lock);
}
printf("%s: got is_zero\\n", __func__);
printf("... | 1 |
#include <pthread.h>
int VT_mc13783_S_IT_U_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783_S_IT_U_cleanup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int a... | 0 |
#include <pthread.h>
struct Locks{
pthread_mutex_t* lock;
int number_parent;
int number_children;
} locks;
void * thread_body(void * param) {
int i;
locks.number_children = 2;
pthread_mutex_lock(&(locks.lock[1]));
while(!pthread_mutex_trylock(&(locks.lock[2]))){
... | 1 |
#include <pthread.h>
void* pthread_getspecific(pthread_key_t key)
{
struct pthread* thread = pthread_self();
if ( key < thread->keys_length )
return thread->keys[key];
pthread_mutex_lock(&__pthread_keys_lock);
assert(key < __pthread_keys_length);
assert(__pthread_keys[key].destructor);
... | 0 |
#include <pthread.h>
int cur_client_num = 0;
int client_num;
int port_num;
int total_sent = 0;
int total_to_send = 0;
struct hostent *server;
struct sockaddr_in server_addr;
pthread_mutex_t client_num_mutex = PTHREAD_MUTEX_INITIALIZER;
void error_msg(const char *msg) {
perror(msg);
e... | 1 |
#include <pthread.h>
pthread_t fid[1],cid[20];
pthread_mutex_t cpu=PTHREAD_MUTEX_INITIALIZER,s[20];
int num;
int remain;
int state;
}pcb;
pcb thread[20];
int total=0;
int waitTime=0;
void* child(void* vargp){
int i = *(int*)vargp;
pthread_mutex_lock(&s[i]);
pthread_mutex_lock(&cpu);
... | 0 |
#include <pthread.h>
void invoke_write(void *mysde);
void invoke_read(void *num);
pthread_mutex_t wrt,wrtcount,reader;
int sde,readcount,writecount;
int main(int argc,char *argv[])
{ char *one="1",*two="2",*three="3",*four="4";
char *w1="1 ",*w2="2 ",*w3="3 ",*w4="4 ";
pthread_t writer1,writ... | 1 |
#include <pthread.h>
size_t count;
uint64_t* numbers;
} number_list;
number_list input;
number_list* primes;
pthread_mutex_t prime_mutex;
struct random_data* r_data;
} worker_args;
pthread_t threads[256];
worker_args args[256];
pthread_mutex_t prime_mutex = PTHREAD_MUTEX_INITIALI... | 0 |
#include <pthread.h>
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
int countFitsInterval = 0;
int countingIsDone = 0;
int count = 0;
void *functionCount1()
{
f... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
... | 0 |
#include <pthread.h>
int produced[15]={0};
int i=1;
{
sem_t sem;
pthread_mutex_t mutex;
}Bank;
Bank shared;
int serviced[15]={0};
void *Token_machine(void *),*counter(void *);
void main()
{
int i;
pthread_t tid_machine[3],tid_counter[8];
for(i=0;i<3;i++)
{
pthread_create(&tid_machine[i],... | 1 |
#include <pthread.h>
void threadSafetyNew(struct ThreadSafety* threadSafety,
const char* name)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&threadSafety->Mutex, &attr)... | 0 |
#include <pthread.h>
uint32_t counter = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_cond;
void *function1()
{
for(;;)
{
pthread_mutex_lock(&count_mutex);
counter++;
if(counter < 3 || counter > 6)
{
pthread_cond_broadcast(&count_cond);
}
printf("... | 1 |
#include <pthread.h>
void *(*realmalloc)(size_t size) = 0;
void *(*realcalloc)(size_t nmemb, size_t size) = 0;
void (*realfree)(void *ptr) = 0;
void *(*realrealloc)(void *ptr, size_t size) = 0;
const unsigned char magic[4] = { 0xfa, 0xde, 0xfa, 0xde };
static char init_calloc = 0;
pthrea... | 0 |
#include <pthread.h>
long long sum;
pthread_mutex_t sumLock;
int gcd(int a, int b) {
return a < b ? gcd(b, a) : b == 0 ? a : gcd(b, a % b);
}
int phi(int n) {
int i, r = 0;
for( i=1; i<n; i++ )
if ( gcd(n, i) == 1 ) r++;
return r;
}
void* threadRoutine(void* arg)
{
... | 1 |
#include <pthread.h>
int n;
int rowCounter = 0;
int* m;
int sliceSize;
pthread_mutex_t m1;
int numC[10];
int (*numCount)[10] = &numC;
void createMatrix()
{
printf("Creating Matrix:\\n");
int i,j;
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
{
*((m + ... | 0 |
#include <pthread.h>
int **matrix1,**matrix2,**matrix3;
int p;
int f1,c1,f2,c2;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *funcion_hilo(void *id_thread);
void multiplica_matrix(int **matrix1,int **matrix2,int f1,int c1,int c2,int **matrix3);
int main() {
int i,j;
printf("... | 1 |
#include <pthread.h>
const int PRODUCT_NUM = 10;
const int BUFFER_SIZE = 4;
int buffer[BUFFER_SIZE];
int rd_idx, wr_idx, g_num;
pthread_mutex_t mutex;
sem_t sem_empty, sem_full;
void ConsumerFunc(void) {
int id = ((int)pthread_self()) % 10000;
volatile int flag = 1;
while (flag) {
... | 0 |
#include <pthread.h>
void* producer();
void* consumer();
pthread_mutex_t lock_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t done_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_done_cond = PTHREAD_COND_INITIALIZER;
int flag = 0;
{
int num_e, total_leng, end_of_file;
} bundle;
... | 1 |
#include <pthread.h>
FILE *fp1, *fp2, *fp3;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char buf[1024], buf1[1024], buf2[1024];
char filename[2][1024];
int row[2] = {0};
char *itostr(int i, char *str) {
sprintf(str, "%d", i);
return str;
}
char *genrow(char *res, char *name, i... | 0 |
#include <pthread.h>
int choice =-1;
pid_t pid;
pthread_mutex_t tree;
struct node
{
int key;
struct node* left;
struct node* right;
}*root=0;
struct node* insert(struct node* bn,int t)
{
if(bn==0)
{
bn =(struct node*)malloc(sizeof(struct node));
bn->key=t;
bn->left=0;
bn->right=0;
... | 1 |
#include <pthread.h>
int shared_resource = 0;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static void signal_handler(int sig) {
printf("signal handler for %d\\n", sig);
exit(1);
}
void *task2 (void *arg) {
int i, j, tmp, loop;
loop = (int)arg;
for (i=0; i<loop; i++) {
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int i, n, tid;
void (*task_fun) (void *arg, int tid, int i);
void *task_arg;
} context_t;
static void *start_routine (void *cp)
{
context_t *context = cp;
int tid;
pthread_mutex_lock (&context->mutex);
tid = context->tid++;
pthread_... | 1 |
#include <pthread.h>
static int top=0;
static unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR: ;
goto ERROR;
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(void)
{
return top;
}
int stack_empty(void)
... | 0 |
#include <pthread.h>
struct Params
{
long startPos;
long endPos;
};
pthread_mutex_t readFlag;
pthread_mutex_t writeFlag;
pthread_mutex_t copyFlag;
pthread_mutex_t changeFlag;
char *progName, *inFile, *outFile;
volatile unsigned short int threadCount = 0;
unsigned short int threadLimit;
... | 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>
{
elem_t val;
struct Node* next;
pthread_mutex_t lock;
} Node;
{
Node* head;
pthread_mutex_t lock;
} List;
List* new_list()
{
List* l = malloc(sizeof(List));
l->head = 0;
pthread_mutex_init(&l->lock, 0);
return l;
}
bool insert(List* l... | 1 |
#include <pthread.h>
int pin_button;
int pin_left;
int pin_right;
} encdata;
int lcd = -1;
int enc_val = 0;
int btn_val = 0;
int shutdown = 0;
pthread_t t_encoders[2];
pthread_mutex_t m_lcd, m_enc, m_btn;
void stdoutup() {
printf("\\033[2K\\r\\tvalue: %i\\tbutton: %i", enc_val, btn_val);
}... | 0 |
#include <pthread.h>
int thread_id;
int num_threads;
int max;
int result;
int *logarray;
int arraysize;
int logfile;
} threadinfo_t;
pthread_mutex_t rl;
void report(char *str) {
pthread_mutex_lock(&rl);
printf("%s\\n",str);
pthread_mutex_unlock(&rl);
}
int ilog(int n) {
in... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t space_available = PTHREAD_COND_INITIALIZER;
pthread_cond_t data_available = PTHREAD_COND_INITIALIZER;
int b[10];
int size = 0, front = 0, rear = 0;
void add_buffer(int i) {
b[rear] = i;
rear = (rear... | 0 |
#include <pthread.h>
void print_function(int *value);
int main( int argc, char ** argv)
{
pthread_t ** threads = calloc(5, sizeof(pthread_t));
int i,value;
value = 9;
for(i = 0; i < 5; i++){
threads[i] = malloc(sizeof(pthread_t));
pthread_create(threads[i], 0, (void*) print_function, (v... | 1 |
#include <pthread.h>
bool removePet(int index){
pthread_mutex_lock(&lock);
sem_wait(semaforo);
read(pipefd[0], &witness, sizeof(char));
struct dogType *removedPet;
removedPet = malloc(sizeof(struct dogType));
struct dogType *previousPet;
previousPet = malloc(sizeof(... | 0 |
#include <pthread.h>
int i = 0;
int amountOfPoints = 0;
int totalPoints = 0;
int all = 0;
pthread_t tid[2];
pthread_mutex_t lock;
void *count(void *X)
{
pthread_mutex_lock(&lock);
all = all + amountOfPoints;
for (i=0; i < amountOfPoints; i++)
{
double X = (double)ran... | 1 |
#include <pthread.h>
struct pctool *pctool_init(int buffer_size) {
struct pctool *pctool = (struct pctool *)new(sizeof(struct pctool));
memset(pctool, 0, sizeof(struct pctool));
pctool->buffer_size = buffer_size;
pctool->buffer = (void *)new(pctool->buffer_size * sizeof(void *));
mems... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.