text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
buffer_t buffer[5];
int buffer_index;
pthread_mutex_t buffer_mutex;
sem_t full_sem;
sem_t empty_sem;
void insertbuffer(buffer_t value) {
if (buffer_index < 5) {
buffer[buffer_index++] = value;
} else {
printf("Buffer overflow\\n");
}
}
... | 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 main()
{
printf("Initializing mutex as recursive...\\n");
pthread_mutex_t mutex;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
if (pthread_mutex_init(&mutex, &attr) != 0)
{
fprintf(stderr, "pthr... | 1 |
#include <pthread.h>
pthread_mutex_t aarrived, barrived;
pthread_cond_t lock;
int islocked = 0;
void main() {
pthread_cond_init(&lock, 0);
pthread_mutex_init(&aarrived, 0);
pthread_mutex_init(&barrived, 0);
pthread_t threada, threadb;
void *threadAFunction(), *threadBFun... | 0 |
#include <pthread.h>
static int si_init_flag = 0;
static int s_conf_fd = -1;
static struct sockaddr_un s_conf_addr ;
static int s_buf_index = 0;
static char s_conf_buf[(16384)];
static pthread_mutex_t s_atomic;
static char CONF_LOCAL_NAME[16] = "/tmp/rptClient";
inline int netReportSockS... | 1 |
#include <pthread.h>
pthread_mutex_t forks[5];
pthread_mutex_t lforks;
pthread_t phils[5];
void *philosopher (void *id);
int food_on_table ();
void get_fork (int, int, char *);
void down_forks (int, int);
pthread_mutex_t foodlock;
int sleep_seconds = 0;
int
main (int argn,
char **argv)... | 0 |
#include <pthread.h>
void * process_request(void * arg);
void * process_response(void * arg);
void setnonblockingmode(int fd);
pthread_mutex_t mutex;
struct epoll_event *ep_events;
struct epoll_event event;
int epfd, event_cnt;
int fd_cnt = 0;
int store[22222];
BOOL request_finish = 0;
int main(... | 1 |
#include <pthread.h>
extern SLAVE_FUN(fd4t10s_sw)();
extern SLAVE_FUN(cross_correlation_sw)();
struct Param;
void master_wait() {
pthread_mutex_lock(&mut1);
while(g_status != 0)
{
pthread_cond_wait(&cond1, &mut1);
}
pthread_mutex_unlock(&mut1);
g_status = CG_MAX;
}
void master_... | 0 |
#include <pthread.h>
{
int count;
pthread_mutex_t lock;
pthread_mutex_t s;
} Semaphore;
Semaphore *full, *empty;
int in, out;
int buffer[16];
static void
semaphore_init (Semaphore *s, int i)
{
pthread_mutex_init (&s->lock, 0);
pthread_mutex_init (&s->s, 0);
pthread_mutex_l... | 1 |
#include <pthread.h>
int A = 5;
int B = 5;
pthread_mutex_t mutex_A = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_B = PTHREAD_MUTEX_INITIALIZER;
void *generate(void *arg) {
int i;
for (i=1; i<100; i++) {
pthread_mutex_lock(&mutex_A);
A = i;
A = 5;
pthread_mutex_unlock(&m... | 0 |
#include <pthread.h>
int fd[2];
int emptypos = 5000;
long produceNum = 0;
long consumeNum = 0;
struct element
{
int flag;
struct element *next;
};
struct queue
{
struct element *head;
struct element *tail;
};
struct queue myqueue;
int empty()
{
if(!myqueue.head || !myqueue.tail)
ret... | 1 |
#include <pthread.h>
static void * recv_thread_func(void * pv);
static void * reconnect_thread_func(void * pv);
static int connect_server();
int sockfd;
unsigned char connect_flag=0;
unsigned char recv_thread_start=1;
unsigned char reconnect_thread_start=1;
char * ip ;
int port;
char recv_b... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread1(void *);
void *thread2(void *);
int i=1;
int main()
{
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a,0,thread1,(void*)0);
pthread_create(&t_... | 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>
int qleitor=0;
int qescritor=0;
pthread_cond_t cond_l, cond_e;
pthread_mutex_t mutex;
int tid;
int count;
} t_Args;
t_Args global;
void *leitor(void* arg){
int tid = *(int*)arg;
int boba1=10000, boba2=0;
while(1){
pthread_mutex_lock(&mutex);
while(qescritor>0)
... | 1 |
#include <pthread.h>
void *producer_fun(void *arg);
void *consumer_fun(void *arg);
pthread_mutex_t con_mutex, pro_mutex;
sem_t empty, full;
int in = -1;
int out = -1;
int main(void)
{
pthread_t consumer, producer;
int producer_num = 0;
int consumer_num = 0;
pthread_mutex_init(&pro_mutex, 0... | 0 |
#include <pthread.h>
double sum=0.0, a[1000000];
pthread_mutex_t sum_mutex;
void *do_work(void *tid)
{
int i, start, *mytid, end;
double mysum=0.0;
mytid = (int *) tid;
start = (*mytid * 1000000 / 4);
end = start + 1000000 / 4;
printf ("Thread %d doing iterations %d to %d\\n",*myti... | 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;
int clnt_socks[256];
pthread_mutex_t mutx;
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
int clnt_... | 0 |
#include <pthread.h>
int sharedVar = 0;
int numReader = 0;
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_write = PTHREAD_COND_INITIALIZER;
void *writer (void *param);
void *reader (void *param);
int main(int argc, char *argv[... | 1 |
#include <pthread.h>
int numOfPassengersOnBus;
int turn;
void* print_message(void* ptr);
pthread_mutex_t verrou;
struct node
{
int x;
struct node *next;
};
int main(int argc, char* argv[])
{
pthread_t tProducer, tConsumer1, tConsumer2;
const char* msg1 = "Producer";
const char* msg2... | 0 |
#include <pthread.h>
struct msg {
struct msg *next;
int num;
};
struct msg *head;
struct msg *mp;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p)
{
for (;;) {
pthread_mutex_lock(&lock);
... | 1 |
#include <pthread.h>
void errormessage(char *);
{
int head;
int tail;
int validItems;
char data[5];
pthread_mutex_t lock;
}cmdque;
cmdque cmd_buff;
void errormessage(char *message)
{
perror(message);
exit(1);
}
void cmd_init(cmdque *cmd_buff)
{
int i;
cmd_buff->head=0;
cmd_buff->tail=0;... | 0 |
#include <pthread.h>
struct employee {
int number;
int id;
char first_name[32];
char last_name[32];
char department[32];
int root_number;
};
struct employee employees[] = {
{ 1, 12345678, "astro", "Bluse", "Accounting", 101 },
{ 2, 87654321, "Shrek", "Charl", "Programmer", 102 },
};
st... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t semaphore[2];
char buffer[N_BUFFER][13], temp[13];
int ptr_read = 0, finish = 0;
int escolher_ficheiro(){
int id_file = rand() % 5;
return id_file;
}
int leitor(){
int file, i, wrong, x;
char linha[10], primeira[10], filename[13];
while(... | 0 |
#include <pthread.h>
int buffer = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_productor = PTHREAD_COND_INITIALIZER;
void* consumer_th(void* arg)
{
pthread_mutex_lock(&mutex);
for (;;) {
sle... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
static void *start(void *str)
{
char buffer[1024];
snprintf(buffer, sizeof (buffer), "thread in %s\\n", str);
printf("%s", buffer);
pthread_mutex_lock(&mutex);
return 0;
}
int main(int argc, char **argv)
{
void *handle = dlopen(SHARED_LIB... | 0 |
#include <pthread.h>
int sillas = 4;
int pendiente = 0;
pthread_mutex_t enanoMtx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t blancaMtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t enanoCond = PTHREAD_COND_INITIALIZER;
pthread_cond_t blancaCond = PTHREAD_COND_INITIALIZER;
void * blancaCtrl(void*... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t emptySlots;
pthread_cond_t filledSlots;
int N;
int buffer[10000];
int in = 0;
int out = 0;
int count = 0;
int fin = 0;
int num;
void *producer(void *param);
void *consumer(void *param);
int main(int argc, char *argv[]){
int i =... | 0 |
#include <pthread.h>
extern void init_scheduler(int);
extern int scheduleme(float, int, int, int);
FILE *fd;
struct _thread_info
{
int id;
float arrival_time;
int required_time;
int priority;
};
double _global_time;
float _last_event_time;
pthread_mutex_t _time_lock;
pthread_mutex_t _las... | 1 |
#include <pthread.h>
void initMutex(pthread_mutex_t *mutexsum)
{
pthread_mutex_init(mutexsum, 0);
}
void lockMutex(pthread_mutex_t *mutexsum)
{
pthread_mutex_lock (mutexsum);
}
int lockMutexAndWait(pthread_mutex_t *mutexsum)
{
int errCode;
int retval = 1;
struct timespec abs_t... | 0 |
#include <pthread.h>
pthread_mutex_t ctr_mutex;
pthread_cond_t ctr_cond;
int ctr;
void *add(void *p)
{
while(ctr < 10)
{
pthread_mutex_lock(&ctr_mutex);
ctr++;
printf("ADD: New value of ctr is %d\\n", ctr);
if(ctr>=10)
{
printf("ADD: Reached limit o... | 1 |
#include <pthread.h>
pthread_t filosofos[5];
int pratos[5];
pthread_mutex_t palitos[5];
void *filosofo(void *args) {
int *ptr = (int*) (args);
int N = (*ptr);
printf("Entrando no filosofo %d\\n", N);
while (pratos[N] < 5) {
pthread_mutex_lock(& (palitos[N]) );
pthread_mu... | 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 (12 == count) {
... | 1 |
#include <pthread.h>
pthread_mutex_t theMutex;
pthread_cond_t condc, condp;
int buffer=0;
void* producer(void* ptr)
{
int x;
for(x=0; x<=4; x++)
{
pthread_mutex_lock(&theMutex);
printf("Producer Locked\\n");
while(buffer!=0)
{
printf("Producer waiting\\n");
pthread_cond_wait(&con... | 0 |
#include <pthread.h>
pthread_mutex_t write_lock;
pthread_mutex_t read_lock;
enum Status i2c_temp_init(uint8_t fd,uint8_t addr)
{
if(addr == 0x48 || addr == 0x49 || addr == 0x4A || addr==0x4B)
{
if(ioctl(fd,I2C_SLAVE,addr)<0)
{
return FAIL;
}
return SUCCESS;
}
else return FAIL;
}... | 1 |
#include <pthread.h>
char* key;
char* value;
size_t value_len;
struct hash_item** pprev;
struct hash_item* next;
} hash_item;
hash_item* hash[1024];
pthread_mutex_t hash_mutex;
hash_item* hash_get(const char* key, int create) {
unsigned b = string_hash(key) % 1024;
... | 0 |
#include <pthread.h>
int nextNum;
pthread_mutex_t nextNumLock;
pthread_mutex_t genPrimesLock;
int getNext()
{
int temp;
pthread_mutex_lock(&nextNumLock);
nextNum++;
temp = nextNum;
pthread_mutex_unlock(&nextNumLock);
return temp;
}
void addPrime(int newPrime)
{
pthread_mutex_lock(&gen... | 1 |
#include <pthread.h>
static char running = 1;
static long long counter = 0;
pthread_mutex_t c_mutex;
int i;
void *process (void *arg)
{
while (running) {
pthread_mutex_lock (&c_mutex);
if (i > 4)
pthread_exit (0);
counter++;
pthread_mutex_u... | 0 |
#include <pthread.h>
static void process_function();
static void process_function_actual(int job_type);
static int process_judege(struct Job *job);
extern void ftp_file_manage_init(){
register_job(JOB_TYPE_FTP_FILE_MANAGE,process_function,process_judege,CALL_BY_TCP_DATA_MANAGE);
}
static vo... | 1 |
#include <pthread.h>
struct sk_buff * alloc_skb(uint32_t datasize)
{
struct sk_buff *skb = malloc(sizeof(struct sk_buff));
skb->dev = 0;
skb->dst = 0;
skb->protocol = 0;
skb->len = 0;
skb->data = malloc(datasize);
skb->head = skb->data;
skb->tail = skb->data;
... | 0 |
#include <pthread.h>
static State gamestate;
int row;
int col;
char under_char;
}frog_info;
static frog_info frog;
int id;
Direction dir;
int row;
int sleeptime;
}log_line_info;
static log_line_info logs_info[(20)];
pthread_t log_thread[(20)];
pthread_mutex_t mutex = PTHREAD_MUT... | 1 |
#include <pthread.h>
uint32_t ip;
uint16_t port;
uint32_t readopcnt;
uint32_t writeopcnt;
struct _csdbentry *next;
} csdbentry;
static csdbentry *csdbhtab[256];
static pthread_mutex_t *csdblock;
void csdb_init(void) {
uint32_t i;
for (i=0 ; i<256 ; i++) {
csdbhtab[i]=0;
}
csdblock... | 0 |
#include <pthread.h>
int
timer_getoverrun (timerid)
timer_t timerid;
{
struct timer_node *timer;
int retval = -1;
pthread_mutex_lock (&__timer_mutex);
if (! timer_valid (timer = timer_id2ptr (timerid)))
__set_errno (EINVAL);
else
retval = 0;
pthread_mutex_unlock (&__... | 1 |
#include <pthread.h>
void *find_min(void *) ;
pthread_mutex_t minimum_value_lock;
long int partial_list_size;
int minimum_value;
long int *list;
long int NumElements, CLASS_SIZE;
int NumThreads;
int main (int argc,char * argv[])
{
pthread_t *threads;
pthread_attr_t pta;
... | 0 |
#include <pthread.h>
static int g_temp_cute_leak_check = 0;
static pthread_mutex_t mmap_mutex = PTHREAD_MUTEX_INITIALIZER;
void init_mmap_mutex() {
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
... | 1 |
#include <pthread.h>
void *worker(void *params)
{
t_worker_thread *worker;
t_thread_pool *parent;
t_queue **active_threads;
t_queue **idle_threads;
worker = params;
parent = worker->parent;
active_threads = &parent->active_threads;
idle_threads = &parent->idle_threads;
worker->running = ... | 0 |
#include <pthread.h>
static pthread_mutex_t piMutexes [4] ;
int piThreadCreate (void *(*fn)(void *))
{
pthread_t myThread ;
return pthread_create (&myThread, 0, fn, 0) ;
}
void piLock (int key)
{
pthread_mutex_lock (&piMutexes [key]) ;
}
void piUnlock (int key)
{
pthread_mutex_unlock (&p... | 1 |
#include <pthread.h>
int common=0;
int common2=0;
pthread_mutex_t lck;
pthread_mutex_t lck2;
void* print(void* unused)
{
int x=1,i;
int retval;
pthread_mutex_lock(&lck);
common++;
sleep(1);
printf("Common: %d\\tx: %d ( Thread ID: %d )\\n",common,x,(int)pthread_s... | 0 |
#include <pthread.h>
static int init(void)
{
if (LOCK_INIT == 1)
return (0);
LOCK_INIT = 1;
pthread_mutex_init(&g_locker, 0);
return (ft_init_malloc());
}
void *malloc(size_t size)
{
void *ptr;
if (init() || size == 0)
return (0);
pthread_mutex_lock(&g_locker);
ptr = malloc_unsafe(si... | 1 |
#include <pthread.h>
int N=100;
int T=4;
pthread_mutex_t count_lock;
pthread_cond_t ok_to_proceed;
int count;
} barrier;
double escalar;
barrier *barrera;
double max, min, suma;
double *R;
double* M[4];
pthread_mutex_t mutexMax;
pthread_mutex_t mutexMin;
pthread_mutex_t mutexAvg;
d... | 0 |
#include <pthread.h>
float* normProf(long double *temp , int nbins);
long double maxArray(long double *temp , int nbins);
float maxBand(float *temp , int nchans);
float minBand(float *temp , int nchans);
struct parameters check_adc;
struct POLYCO polyco;
void *plotFold(void *pa)
{
int i,check;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void* writing()
{
time_t rawtime;
struct tm *timeinfo;
int file;
int num_str = 1;
char str[100];
while(1)
{
pthread_mutex_lock(&mutex);
time(&rawtime);
timeinfo = localtime(&rawtime);
file = open("time.txt", O_CREAT|O_WRONLY|O_APPEN... | 0 |
#include <pthread.h>
struct single_pty {
int master;
int slave;
pthread_mutex_t lock;
} array[500];
struct array_info {
struct single_pty *array;
int size;
};
static void *ptmx_thread(void *arg)
{
struct array_info *info = arg;
struct single_pty *array = info->array, *cur;
int size ... | 1 |
#include <pthread.h>
static sigset_t set;
static pthread_mutex_t mutex;
static unsigned char run = 1;
static char buffer[128];
static unsigned char readline(void)
{
int idx = 0;
char ch;
ch = getchar();
while (ch >= 0) {
if (ch == '\\n' || idx == 128 -2) {
... | 0 |
#include <pthread.h>
int min(int a,int b)
{
if(a>b) return b;
else return a;
}
int nitems;
struct {
pthread_mutex_t mutex;
int buff[1000000];
int nput;
int nval;
}shared ={
PTHREAD_MUTEX_INITIALIZER
};
void *produce(void*), *consume(void*);
void *produce(void *arg)
{
for(;;)
{
pthrea... | 1 |
#include <pthread.h>
int thread_no;
int *data;
pthread_mutex_t *mutex;
} thread_arg_t;
void thread_func(void *arg) {
thread_arg_t* targ = (thread_arg_t *) arg;
int i, result;
for(i=0; i<10; i++) {
pthread_mutex_lock(targ->mutex);
result = targ->data[i] ... | 0 |
#include <pthread.h>
int pack_queue_init(struct pack_queue *q) {
pthread_mutexattr_t attr;
q->q_front = 0;
q->q_rear = 0;
q->q_size = SEND_QUEUE_SZ;
q->q_items = calloc(q->q_size, sizeof(struct pack_item));
if (q->q_items == 0)
return -1;
if (pthread_mutexattr_init(&attr) < 0)
return... | 1 |
#include <pthread.h>
int rank;
char finished;
pthread_mutex_t mutex;
pthread_cond_t cond;
} thread_data;
thread_data td[10];
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->mut... | 0 |
#include <pthread.h>
int stack[10];
int prod_counter = 0;
pthread_mutex_t mutex_prod = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_prod = PTHREAD_COND_INITIALIZER;
int cons_counter = 0;
pthread_mutex_t mutex_cons = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_cons = PTHREAD_COND_INITIA... | 1 |
#include <pthread.h>
const int buffer_size = 100;
const int retry_times = 50;
extern pthread_mutex_t signal_master_dead_mtx;
extern pthread_cond_t signal_master_dead_cv;
extern pthread_cond_t signal_server_bind_failed_cv;
char init_status_and_backup_buffer[buffer_size];
void * client_main(void * d... | 0 |
#include <pthread.h>
int places = 10;
pthread_mutex_t mutex;
pthread_cond_t conditionVar;
void *parking(void* carNum);
int main(int argc, char *argv[]){
pthread_t cars[40];
int rc ,i;
rc = pthread_mutex_init(&mutex, 0);
if(rc != 0){ printf("init error!! \\n"); }
rc =pthread_cond_in... | 1 |
#include <pthread.h>
int arr[1000][1000];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
FILE *fout;
void initArray()
{
fout = fopen("output.txt", "w");
if (fout != 0)
{
printf("opened successful");
}
int i = 0;
int j = 0;
for (i = 0; i < 1000; i++)
... | 0 |
#include <pthread.h>
double buf[256];
int buf_ptr = 0;
static pthread_mutex_t buf_lock;
void store(double x)
{
pthread_mutex_lock(&buf_lock);
buf[buf_ptr++] = x;
buf_ptr &= (256 - 1);
pthread_mutex_unlock(&buf_lock);
}
int run_test(int n)
{
int i;
for (i = 0; i < n; i++) {
double a, ... | 1 |
#include <pthread.h>
const int PRODUCT_NUM = 10;
const int BUFFER_SIZE = 4;
int buffer[BUFFER_SIZE];
pthread_mutex_t mutex;
sem_t sem_empty, sem_full;
int p_idx, c_idx;
int g_idx;
void ConsumerFunc(void) {
volatile int flag = 1;
while (flag) {
sem_wait(&sem_full);
pthread... | 0 |
#include <pthread.h>
static struct index *Dindex;
static unsigned short port;
static pthread_mutex_t M_index = PTHREAD_MUTEX_INITIALIZER;
void *work(void *mes){
void *data, *resp;
struct parameter *para;
struct doc *doc;
struct count *count;
struct query *query, *ptr;
str... | 1 |
#include <pthread.h>
unsigned int v_in, v_out;
static pthread_mutex_t mutex_saisie, mutex_resultat;
void *thread_entree_sortie(void *threadid)
{
printf("Entrez une valeur : ");
scanf("%d", &v_in);
pthread_mutex_unlock(&mutex_saisie);
pthread_mutex_lock(&mutex_resultat);
printf(... | 0 |
#include <pthread.h>
volatile int shared_counter = 0;
pthread_t people[100];
pthread_mutex_t lock;
void* returnToChair() {
pthread_mutex_lock(&lock);
for(int i=0; i<1000;i++) {
shared_counter++;
}
pthread_mutex_unlock(&lock);
return 0;
}
int main(void) {
if ... | 1 |
#include <pthread.h>
uint64_t * nombresPremiers(uint64_t n, int * taille);
uint64_t * factorisation(uint64_t n, int * taille);
void print_prime_factors(uint64_t n);
void * run(void * param);
static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mutexScanf=PTHREAD_MUTEX_IN... | 0 |
#include <pthread.h>
static struct termworker_context_t *termworker_context;
char generate_transaction(int *keying_time, int *mean_think_time)
{
double threshold;
char transaction;
threshold = get_percentage();
if (threshold < transaction_mix.new_order_threshold) {
transaction = NEW_OR... | 1 |
#include <pthread.h>
static pthread_mutex_t i2c_lock;
int ipc_i2c_read(unsigned char addr,unsigned char *data,int len,unsigned char mode)
{
int ret_val,data_counter=0;
wait_for_gpio_interrupt_i2c();
pthread_mutex_lock(&i2c_lock);
switch(mode)
{
case EIGHT_BIT:
if(data != 0)
{
... | 0 |
#include <pthread.h>
int buffer[10];
int inicio_buffer = 0;
int final_buffer = 0;
int total_buffer = 0;
pthread_mutex_t trava;
void* produtor(void *arg) {
for (int i = 0; i < 20; i++) {
while (total_buffer == 10);
buffer[inicio_buffer] = i;
pthread_mutex_lock(&trava);
to... | 1 |
#include <pthread.h>
struct malloc_chunk {
INTERNAL_SIZE_T prev_size;
INTERNAL_SIZE_T size;
struct malloc_chunk* fd;
struct malloc_chunk* bk;
struct malloc_chunk* fd_nextsize;
struct malloc_chunk* bk_nextsize;
};
pthread_t thrd;
pthread_cond_t cond = PTHREAD_COND_... | 0 |
#include <pthread.h>
static const char *devName = "/dev/i2c-1";
struct message {
struct message *next;
int data;
};
pthread_mutex_t lock;
pthread_cond_t more;
struct message *newest;
struct message *oldest;
} queue;
void enqueue(queue *q, const int m) {
struct message *n;
n->next = 0... | 1 |
#include <pthread.h>
pthread_cond_t s_cond;
pthread_mutex_t s_mutex1;
pthread_mutex_t s_mutex2;
static void* thread(void* arg)
{
pthread_mutex_lock(&s_mutex2);
pthread_mutex_lock(&s_mutex1);
pthread_cond_signal(&s_cond);
pthread_cond_wait(&s_cond, &s_mutex1);
return 0;
}
int mai... | 0 |
#include <pthread.h>
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
int i2c_write(int addr, unsigned char *i2c_tx_buf, int txcnt)
{
pthread_mutex_lock(&mutex);
int fd, ret;
struct i2c_rdwr_ioctl_data data;
fd=open("/dev/i2c-1",O_RDWR);
if(fd < 0)
{
perror("open error");
pthread_mu... | 1 |
#include <pthread.h>
void
pthread_testcancel (void)
{
struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
int cancelled;
pthread_init();
pthread_mutex_lock (&p->cancel_lock);
cancelled = (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE) && (p->attr.flags & PTHREAD... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void *
thr_fn(void *arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0)
err_exit(e... | 1 |
#include <pthread.h>
extern int makethread(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);
... | 0 |
#include <pthread.h>
long birim_iterasyon;
double Pi;
long circleCount = 0;
pthread_t *threads;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* monte_carlo(void* arg){
long i;
long incircle_thread = 0;
unsigned int rand_state = rand();
for (i = 0; i < birim_iterasyon; i++){
double... | 1 |
#include <pthread.h>
int space=0;
int MAX_DIRECTORIES = 200;
char **Filename;
int level[2]={0};
char **filesystem;
int condition1=0, condition2=0;
extern int alphasort();
void compareFS(int k);
void *traverseSystem(void *threadid);
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
pthread_mute... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main()
{
int rc;
if((rc=pthread_mutex_lock(&mutex))!=0) {
fprintf(stderr,"Error at pthread_mutex_lock(), rc=%d\\n",rc);
return PTS_UNRESOLVED;
}
rc = pthread_mutex_trylock(&mutex);
if(rc!=EBUSY) {
... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
int count = 0;
char cp_from[1024] = {0};
char cp_to[1024] = {0};
void open_file(FILE **fp1, FILE **fp2)
{
*fp1 = fopen(cp_from, "r");
if(0 == *fp1)
{
printf("open file %s error\\n", cp_from);
exit(1);
}
*fp... | 0 |
#include <pthread.h>
struct txn_node *get_txn_node(int new_txn_id,long log_rec_no)
{
struct txn_node *new_txn_node;
new_txn_node = (struct txn_node *)malloc(sizeof(struct txn_node));
new_txn_node->txn_id = new_txn_id;
new_txn_node->cur_state = RUNNING;
new_txn_node->first_LRN... | 1 |
#include <pthread.h>
static struct packet_buffer pktbuf;
static struct packet_buffer_t *pktlink;
static struct packet_buffer_t *pkt_freelist;
static struct packet_buffer_t *pkt_use_front;
static struct packet_buffer_t *pkt_use_rear;
static int packet_buffer_count = 0;
static int bufuse = 0;
stati... | 0 |
#include <pthread.h>
static volatile int data;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_m = PTHREAD_COND_INITIALIZER;
static pthread_cond_t cond_j = PTHREAD_COND_INITIALIZER;
static int is_prime(int d)
{
int i;
for (i = 2; i < d / 2; i++) {
i... | 1 |
#include <pthread.h>
int
sigaction (int sig, const struct sigaction *restrict sa,
struct sigaction *restrict osa)
{
if (sig <= 0 || sig >= NSIG)
{
errno = EINVAL;
return -1;
}
struct signal_state *ss = &_pthread_self ()->ss;
pthread_mutex_lock (&ss->lock);
if (os... | 0 |
#include <pthread.h>
int buff[10];
int buff_index;
pthread_mutex_t buff_mutex;
sem_t buff_sem_full;
int push_front(int val)
{
if(buff_index < 10) {
buff[buff_index++] = val;
return 0;
} else
return -1;
}
int pop_front()
{
if(buff_index > 0)
return buff[--buff_index];
else
return ... | 1 |
#include <pthread.h>
int rand_r(unsigned int *seedp);
int thread_count;
unsigned int n;
long long unsigned int in_global = 0;
long step_bins;
pthread_mutex_t lock;
void* monte_carlo_pi(void* args) {
long long unsigned int in = 0, i;
double x, y, d;
long thread;
unsigned int se... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait1=PTHREAD_COND_INITIALIZER;
void * thr_fn(void * arg)
{
int err, signo;
for(;;)
{
err=sigwait(&mask, &signo);
if(err!=0)
{
fprintf(... | 1 |
#include <pthread.h>
sem_t space_nums;
sem_t data_nums;
pthread_mutex_t consuming = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t producting= PTHREAD_MUTEX_INITIALIZER;
int buf[6];
void *consumer(void *arg)
{
int index = 0;
while(1)
{
sleep(1);
sem_wait(&data_nums);
pthread_mutex_lock(&... | 0 |
#include <pthread.h>
struct mail_box {
pthread_mutex_t lock;
pthread_cond_t cond;
struct message *list;
};
struct message {
struct message *next;
void *data;
};
struct mail_box *mail_box_create (void)
{
struct mail_box *mb;
if ((mb = calloc (1, sizeof (*mb))) == 0)
goto no_mem;
if ((... | 1 |
#include <pthread.h>
size_t k;
int file;
char* word;
int N;
pthread_t* threads;
sigset_t mask;
pthread_mutex_t mutex;
pthread_t main_thread_id;
struct thread_args {
int id;
} **args;
void exit_program(int status, char* message) {
if(status == 0) {
printf("%s\\n",message);
} ... | 0 |
#include <pthread.h>
static pthread_mutex_t _swap_locks[32U];
int32_t android_atomic_add(int32_t value, volatile int32_t* addr) {
int32_t oldValue;
do {
oldValue = *addr;
} while (android_atomic_release_cas(oldValue, oldValue+value, addr));
return oldValue;
}
int3... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
struct node
{
int n_number;
struct node *n_next;
}*head=0;
static void cleanup_handler(void *arg)
{
printf("cleanup handler of second thread./\\n");
free(arg);
(vo... | 0 |
#include <pthread.h>
static pthread_mutex_t table_lock = PTHREAD_MUTEX_INITIALIZER;
static void * dev_table;
static struct fd_device * fd_device_new_impl(int fd)
{
struct fd_device *dev = calloc(1, sizeof(*dev));
if (!dev)
return 0;
atomic_set(&dev->refcnt, 1);
dev->fd = fd;
dev->handle_t... | 1 |
#include <pthread.h>
int min;
int max;
} limit;
pthread_mutex_t *lock;
int *count; char *str; int max = 0;
size_t l = 0;
void getString();
void * runner(void *param);
int main(int argc, char const* argv[])
{
getString();
l = strlen(str);
count = calloc(26, sizeof(int));
pthread_t tid[4];... | 0 |
#include <pthread.h>
struct msg
{
struct msg *next;
int num;
};
struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p)
{
struct msg *mp;
for(; ;)
{
pthread_mutex_lock(&lock);
... | 1 |
#include <pthread.h>
struct lmq_msg {
unsigned len;
char *data;
struct lmq_msg *next;
};
int lmq_init(struct lmq_queue *q) {
int fds[2];
if (pipe(fds))
return -1;
memset(q, 0, sizeof(struct lmq_queue));
q->notify_r = fds[0];
q->notify_w = fds[1];
pthread_mutex_init(&q->mutex, 0... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
sem_t sem;
SharedInt* sip;
void plus(int* v2) {
pthread_mutex_lock(&(sip->lock));
sip->value = sip->value + *v2;
pthread_mutex_unlock(&(sip->lock));
}
void *functionWithCriticalSection(int* v2) {
plu... | 1 |
#include <pthread.h>
int balance;
int id;
pthread_mutex_t mutex;
} bank_account;
bank_account A, B;
int counter = 0;
init_account(bank_account *a) {
a->id = counter++;
a->balance = 0;
pthread_mutex_init(&a->mutex, 0);
}
void deposit(bank_account *f, bank_account *t, int ammount) {... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.