text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
struct global {
int flag;
int gameover;
} g;
struct data {
int indice;
int point;
int tirage;
} d[2];
int tirage() {
int r;
r = rand()%2;
return r;
}
... | 1 |
#include <pthread.h>
char *axis_names[ABS_MAX + 1] = {
"X", "Y", "Z", "Rx", "Ry", "Rz", "Throttle", "Rudder",
"Wheel", "Gas", "Brake", "?", "?", "?", "?", "?",
"Hat0X", "Hat0Y", "Hat1X", "Hat1Y", "Hat2X", "Hat2Y", "Hat3X", "Hat3Y",
"?", "?", "?", "?", "?", "?", "?",
};
char *button_names[KEY_... | 0 |
#include <pthread.h>
char buffer[80000 + 1];
int wordcount;
pthread_mutex_t lock;
struct param
{
int index;
int start;
int end;
};
void wcount(struct param *arg);
double sec(void);
int main (int argc, char *argv[]){
FILE *fp = fopen(argv[1], "r");
if (fp != 0) {
size_t newLen = fr... | 1 |
#include <pthread.h>
void* clnt_connection(void * arg);
void send_message(char* message, int len);
void error_handling(char * message);
int clnt_number=0;
int clnt_socks[10];
pthread_mutex_t mutx;
int main(int argc, char **argv)
{
int serv_sock;
int clnt_sock;
struct sockaddr_in serv_addr... | 0 |
#include <pthread.h>
struct hostent *my_gethostbyname_r(const char *name,
struct hostent *res ,
char *buffer ,
int buflen ,
int *h_errnop)
{
struct hostent... | 1 |
#include <pthread.h>
struct listnode* create_node(char *str)
{
if(!str) {
fprintf(stderr, "Error creating node.\\n");
return 0;
}
unsigned int strln = strlen(str);
struct listnode *tmp_node = malloc(sizeof(struct listnode));
tmp_node->str = malloc((str... | 0 |
#include <pthread.h>
Turn turn = None;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
void *first (void *args)
{
while(1)
{
pthread_mutex_lock(&lock);
while(turn != First)
pthread_cond_wait(&condition, &lock);
printf("f... | 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;
struct foo *f_next;
int f_id;
};
struct foo *
foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
void* studentRoutine(void* param);
void* taRoutine(void* param);
int main(void) {
printf("CS149 SleepingTA from Mark Casapao\\n");
waiting_students = 0;
pthread_mutex_init(&mutex_lock, ... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
void * thread_func(void * arg)
{
FILE * fp = (FILE *)arg;
int n;
char buf[32];
int semid;
printf("Hello this is %d\\n", pthread_self());
pthread_mutex_lock(&lock);
printf("%d got the mutex!\\n", pthread_self());
fseek(fp, 0, 0);
fgets(buf, 32... | 0 |
#include <pthread.h>
bool AGING_Init() {
ASSERT_PRINT("Entering:AGING_Init()\\n");
Aging_Registers = calloc(NumOfPagesInMM, sizeof (unsigned int));
int i = 0;
for (i = 0; i < NumOfPagesInMM; i++)
Aging_Registers[i] = 0;
pthread_mutex_init(&Aging_mutex, 0);
if (pth... | 1 |
#include <pthread.h>
int n, **matrix;
pthread_mutex_t matrix_mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_main(void *arg)
{
int thread_number = *((int *)arg), i, j;
int op = rand() % 2;
if (thread_number % 2 == 0)
{
for (i = 0; i < n; i++)
{
if (o... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex;
pthread_mutex_t stop_mutex;
pthread_cond_t count_empty_cond;
pthread_cond_t count_full_cond;
int count=0;
int iteration=0;
enum THREAD_ENUM{
FILL_THREAD=0,
EMPTY_THREAD=1,
ALL_THREADS
};
char THREAD_NAMES[ALL_THREADS][64]={
"FILL",... | 1 |
#include <pthread.h>
int g_key = 0x333;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
void incSem() {
int shmid;
int *addr = 0;
pthread_mutex_lock(&g_mutex);
{
shm_create(".", 0, &shmid);
shm_map(shmid, (void **)&addr);
*(int*)addr += 1;
pr... | 0 |
#include <pthread.h>
extern int idx, sink;
extern double dsink;
extern void *psink;
void bit_shift_main (void);
void dynamic_buffer_overrun_main (void);
void dynamic_buffer_underrun_main (void);
void cmp_funcadr_main (void);
void conflicting_cond_main (void);
void data_lost_main (void);
void data... | 1 |
#include <pthread.h>
struct colam {
int ilec;
int iesc;
int cdat;
int buf[10];
} cola;
pthread_mutex_t mcola = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t no_llena = PTHREAD_COND_INITIALIZER;
pthread_cond_t no_... | 0 |
#include <pthread.h>
int testFermat(unsigned long p);
unsigned long getRand(unsigned long a,unsigned long b);
unsigned long NWD(unsigned long a, unsigned long b);
unsigned long mulMod(unsigned long a, unsigned long b, unsigned long n);
unsigned long powMod(unsigned long a, unsigned long e, unsigne... | 1 |
#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);
while (head == 0)
... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5];
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)
{
int i;
if (argn ... | 1 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
};
struct cache {
struct s *slots[10];
pthread_mutex_t mutex[10];
} c;
struct s *new(int x) {
struct s *p = malloc(sizeof(struct s));
p->datum = x;
p->next = 0;
return p;
}
void list_add(struct s *node, struct s *list) ... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
int count = 1;
int sended =0;
int lastprime=2;
int TCOUNT;
int COUNT_LIMIT;
int catchprime;
void *watch_count(void *t);
void *int_count(void *t);
int test_prime(int);
int main(int argc,char* argv[]){
TCOUNT = ... | 1 |
#include <pthread.h>
struct luargs
{
int i, j, partition;
};
static void print(mtype *arr);
void *lu(void*);
pthread_t threads[4][4];
pthread_cond_t conds[4][4];
pthread_mutex_t mutexes[4][4];
int done[4][4];
struct luargs args[4][4];
mtype A[4*4];
mtype x[4], P[4];
int n;
static void s... | 0 |
#include <pthread.h>
int client_fds[10];
int client_idx;
int output_fd;
int barrier;
pthread_mutex_t client_fds_lock;
pthread_mutex_t file_lock;
void* racey_worker(void* data)
{
int fd;
int n = 0;
char buf[256];
printf("Thread into position\\n");
while (barrier == 0) {}
for (;;)... | 1 |
#include <pthread.h>
pthread_mutex_t fork1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fork2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fork3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fork4 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fork5 = PTHREAD_MUTEX_INITIALIZER;
void* philisopher_1(v... | 0 |
#include <pthread.h>
struct node
{
char user[5];
char process;
int arrival;
int duration;
struct node *next;
}*head;
struct display
{
char user[5];
int timeLastCalculated;
struct display *next;
}*frontDisplay, *tempDisplay, *rearDisplay;
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pt... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex;
static pthread_once_t init = PTHREAD_ONCE_INIT;
extern char** environ;
static void thread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mut... | 0 |
#include <pthread.h>
pthread_t th;
size_t id, result;
} TestThread;
char *locks, *data;
pthread_mutex_t *mutexes;
void* worker_bitlock(void *ptr)
{
TestThread *wrkr = (TestThread*)ptr;
size_t i;
for(i = 0; i < 10000; i++) {
bitlock_yield_acquire(locks, i);
wrkr->result += i ... | 1 |
#include <pthread.h>
pthread_cond_t condizione = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int m,n,x;
int contatore;
int **matrice;
int *array;
int mThread;
void stampa ( ){
printf("\\n");
for (int i = 0; i < m; i++)
{
for(int j=0;j<n;j++){
printf("%d \\t"... | 0 |
#include <pthread.h>
int api_running = 1;
int api_wait = 0;
int last_ind = 511;
pthread_mutex_t rp_analog_sig_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t thread0;
float *ana_sig_array = 0;
float *ptime = 0;
float *panalog_signals = 0;
unsigned int sleep_delta_T;
unsigned int num_of_meas;
FIL... | 1 |
#include <pthread.h>
extern int run;
int auth_thread_init(struct mosquitto_db *db){
int res = 0;
pthread_mutex_init(&db->auth_list_mutex, 0);
res = pthread_create( &db->auth_thread_id, 0,_mosquitto_auth_thread_main, db) ;
if( res != 0 ){
_mosquitto_log_printf(0, MOSQ_LOG_ERR, "pthread... | 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_... | 1 |
#include <pthread.h>
static pthread_mutex_t muxLog;
FILE * fp;
void inizializzazioneLogFile(const char * filename){
time_t t;
char ts[64];
pthread_mutex_init(&muxLog, 0);
fp = fopen(filename,"w+");
t = time(0);
ctime_r(&t,ts);
ts[strlen(ts)-1] = '\\0';
fprintf(fp, "***************... | 0 |
#include <pthread.h>
int Inicializar()
{
int i, err_retorno;
pthread_attr_t attr;
pthread_mutex_init(&clientes_a_chegar_mutex, 0);
clientes_a_chegar = N_CLIENTES;
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);
for(i=0; i<N_FILAS; ++i)
{
sem_init(&fila[i... | 1 |
#include <pthread.h>
pthread_t thread1;
pthread_mutex_t mutex;
pthread_mutexattr_t mta;
int ret;
void *a_thread_func()
{
ret=pthread_mutex_unlock(&mutex);
pthread_exit((void*)0);
}
int main()
{
if(pthread_mutexattr_init(&mta) != 0)
{
perror("Error at pthread_mutexattr_init()\\n");
r... | 0 |
#include <pthread.h>
struct to_info{
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void *timedout_helper(void *arg)
{
struct to_info *pto_info = (struct to_info *)arg;
nanosleep(&pto_info->to_wait, 0);
(*pto_info->to_fn)(pto_info->to_arg);
return (void *)0;
}
void tim... | 1 |
#include <pthread.h>
struct registers {
unsigned long counter;
unsigned long instructions_cnt;
};
struct context {
unsigned long timeline;
struct registers reg;
};
struct pcb {
pthread_mutex_t mutex;
pthread_t tid;
unsigned long idx;
unsigned long state;
str... | 0 |
#include <pthread.h>
int field [100][100] ;
void makeField();
void makeField(){
int i=0;
int j=0;
for(i=0;i<100;i++){
for(j =0;j<100;j++){
field[i][j]==0;
}
}
field[50][50] = 1024;
}
int getPosition(int x, int y){
if(field[x][y]!=0){
return 1;
}
}
void setPosition(int x,... | 1 |
#include <pthread.h>
pthread_mutex_t m1;
pthread_mutex_t m2;
int *x;
int *y;
void* thread_a(void *args) {
pthread_mutex_lock(&m1);
pthread_mutex_lock(&m2);
*x = 2;
pthread_mutex_unlock(&m2);
if (1) {
sleep(2);
printf("aborting, x = %d, y = %d\\n", *x, *y);
... | 0 |
#include <pthread.h>
int MAX = 10;
semaphore mutex = 1;
semaphore empty = MAX;
semaphore full = 0;
pthread_mutex_t mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void* produtor(void *ptr) {
int i;
int num = (int)(size_t)ptr;
num++;
for (i = 0; i < MAX; i++) {
pthread_mutex_lock(... | 1 |
#include <pthread.h>
static pthread_mutex_t parent_mutex[10];
static pthread_mutex_t child_mutex[10];
static void * routine(void * arg)
{
for (int i = 0; i < 10; ++i)
{
pthread_mutex_lock(&child_mutex[i]);
}
for (int i = 0; i < 10; ++i)
{
pthread_mutex_lock(... | 0 |
#include <pthread.h>
extern pthread_mutex_t tel_mutex;
int test_tel_start(void)
{
int cur_row=2;
int ret, fd, ps_state;
char tmp[512];
char* ptmp = 0;
time_t start_time,now_time;
char property[PROPERTY_VALUE_MAX];
char moemd_tel_port[BUF_LEN];
char write_buf[1024] = {0};
ui_fill_locked(... | 1 |
#include <pthread.h>
static int accounts[ 10 ];
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static int sum( void ) {
int s = 0;
int i;
for ( i = 0; i < 10; i++ ) {
s += accounts[ i ];
}
return s;
}
static void *transfer( void *acc_from ) {
int from = *(int *)... | 0 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t C = PTHREAD_COND_INITIALIZER;
int customer_count = 0;
int chair_count = 5;
int max_customer_count = 10;
int total = 10;
pthread_cond_t call_customer=PTHREAD_COND_INITIALIZER;
pthread_cond_t start_haircut=PTHRE... | 1 |
#include <pthread.h>
static inline struct spdk_nvme_ns_data *
_nvme_ns_get_data(struct spdk_nvme_ns *ns)
{
return &ns->ctrlr->nsdata[ns->id - 1];
}
static
int nvme_ns_identify_update(struct spdk_nvme_ns *ns)
{
struct nvme_completion_poll_status status;
struct spdk_nvme_ns_data *nsdata;
int rc... | 0 |
#include <pthread.h>
int epfd;
int addEpollEvent(int epfd, int fd, struct epoll_event *event)
{
if( epoll_ctl(epfd, EPOLL_CTL_ADD, fd, event) == -1)
return -1;
return 1;
}
int modifyEpollEvent(int epfd, int fd, struct epoll_event *event)
{
if( epoll_ctl (epfd, EPOLL_CTL_MOD, fd, event) == ... | 1 |
#include <pthread.h>
pthread_mutex_t forks[5];
pthread_mutex_t cntlock;
int cnt = 0;
void bsleep() {
for(int i = 0; i < 50; i++)
sched_yield();
}
void* act() {
int tid = pthread_self();
int f1 = (int)(tid-1)%5;
int f2 = (int)tid%5;
int eating = 0;
int ret = pthread_mutex_... | 0 |
#include <pthread.h>
struct queue_root {
struct queue_head *in_queue;
struct queue_head *out_queue;
pthread_mutex_t lock;
};
struct queue_root *ALLOC_QUEUE_ROOT()
{
struct queue_root *root =
malloc(sizeof(struct queue_root));
pthread_mutex_init(&root->lock, 0);
root->in_queue... | 1 |
#include <pthread.h>
int numFiles = 0;
int totalTime = 0;
pthread_mutex_t mutexTotalTime;
void* dispatch_execute (void* arg);
void* worker_execute(void* arg);
void printStats(int);
int main() {
srand(time(0));
pthread_mutex_init(&mutexTotalTime, 0);
int status;
pthread_t disp... | 0 |
#include <pthread.h>
long a = 0;
long b = 0;
pthread_mutex_t a_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t b_mutex = PTHREAD_MUTEX_INITIALIZER;
void *a_thread(void *arg) {
printf("This thread increments a and adds to b\\n");
int ret = pthread_mutex_lock(&a_mutex);
if(ret == EINVAL)... | 1 |
#include <pthread.h>
struct message
{
long msg_type;
char msg_text[BUFFER_SIZE];
}msgbuf;
static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t v = PTHREAD_COND_INITIALIZER;
void *receiver(void *args)
{
int qid = *(int *)args;
bzero(msgbuf.msg_text, BUFFER_SIZE);... | 0 |
#include <pthread.h>
int isPrime(int n){
for(int i=2;i<n;i++){
if(n%i ==0){
return 0;
}
}
if(n==1){
return 0;
}
return 1;
}
int numPrimes = 0;
int n = 50;
int intervalSize;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void* countP... | 1 |
#include <pthread.h>
pthread_mutex_t proMutex;
pthread_mutex_t cusMutex;
sem_t emptysem;
sem_t fullsem;
char g_caDish[10];
int g_iProNum = 0;
void *product(void *arg)
{
int num = (int)arg;
while (1)
{
sem_wait(&emptysem);
pthread_mutex_lock(&proMutex);
srand((unsigned int)... | 0 |
#include <pthread.h>
void* led_one();
void* led_two();
pthread_mutex_t lock_mutex = PTHREAD_MUTEX_INITIALIZER;
int main(void)
{
pthread_t led_one_thread;
pthread_t led_two_thread;
int led_one_thread_ret = pthread_create(&led_one_thread, 0, led_one, 0);
int led_two_thread_... | 1 |
#include <pthread.h>
volatile static char buf[bufSize];
volatile static int head = 0;
volatile static int tail = 0;
volatile static int n = 0;
static pthread_mutex_t bufMutex;
static pthread_cond_t bufEmptyCv;
static pthread_cond_t bufFullCv;
void put(long id, char ch) {
pthread_mutex_lock(&bu... | 0 |
#include <pthread.h>
datatype name;
struct node *next;
} node;
node *front, *rear;
int len;
} queue;
void queue_init(queue *q)
{
q->front = q->rear = 0;
q->len = 0;
}
void queue_put(queue *q, datatype new_name)
{
node *mynode = (node *)malloc(sizeof(node));
mynode->name = new_name;
my... | 1 |
#include <pthread.h>
pthread_mutex_t locki[26];
pthread_mutex_t lockb[26];
int busy[26];
int inode[32];
pthread_t tids[27];
void *thread_routine(void * arg)
{
int i,b,j;
int tid;
tid = *((int *)arg);
assert(tid>=0 && tid<27);
i = tid % 32;
assert(i >=0 && i < 26);
pthread_m... | 0 |
#include <pthread.h>
struct readerArgs
{
int fd;
size_t number;
};
ssize_t pgetLine(int fd, char *str, size_t maxLength, off_t offset);
void getCurrentTime(char *str, size_t maxLength);
void* readerFunc(readerArgs *args);
void* writerFunc(void *fd);
void clearResources(int fd);
pthread_rw... | 1 |
#include <pthread.h>
struct critical_data {
int len;
char buf[100];
}data[2];
pthread_mutex_t mutex;
void * write_thread (void *p)
{
printf("\\n In Write thread\\n");
if(pthread_mutex_lock(&mutex)==0)
{
printf("\\n\\t Entering critical section in Write thread \\n");
... | 0 |
#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,min, max;
int myid;
int mycount = 0;
t_data = (struct thrd_data *) thrd_arg;
myid = t_data->id;
min... | 1 |
#include <pthread.h>
int count = 0;
int count1 = 0;
pthread_mutex_t lock;
void * ThreadAdd(void * a)
{
int i, tmp;
for(i = 0; i < 1000000; i++)
{
tmp = count;
tmp = tmp+1;
count = tmp;
pthread_mutex_lock( &lock );
++count1;
pthread_mutex_unlock( &lock... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int pileA = 5;
int pileB = 0;
int pileC = 0;
void* monk(void *arg) {
while (pileA > 0) {
pthread_mutex_lock(&mutex);
printf("Monk : Je passe un paquet de A à B, laisse moi bien le poser\\n");
pil... | 1 |
#include <pthread.h>
int ticket_number;
int cycles_number;
pthread_mutex_t ticketMutex;
pthread_cond_t condition;
void printHelp() {
printf("Program ocekava na prikazove radce jako prvni parametr pocet vlaken M a pocet pruchodu kritickou sekci N. N, M >= 0\\nPriklad spusteni: program 1024 10... | 0 |
#include <pthread.h>
pthread_mutex_t m;
int s = 0;
int l = 0;
void* thr1(void* arg)
{
pthread_mutex_lock (&m);
__VERIFIER_assert (l==0 || s==1);
s = 1;
l = 1;
pthread_mutex_unlock (&m);
return 0;
}
int main()
{
s = __VERIFIER_nondet_int(0, 1000);
pthread_t t[5];
p... | 1 |
#include <pthread.h>
const int NUM_THREADS = 3;
const int NUM_INC = 10;
const int COUNT_LIMIT = 12;
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_cond;
void *inc_count(void *t)
{
int my_id = *(int*)t;
for (int i = 0; i < NUM_INC; ++i){
pthread_mutex_lock(&count_mutex);... | 0 |
#include <pthread.h>
const char *DESTINATION_FILE = "destination.txt";
pthread_mutex_t mutex;
void printToFile( int lettersCount, char *sourceFile);
void *readFile( void *filename ) {
char *sourceFile = filename;
printf("The file %s has entered to the lecture function \\n", sourceFile)... | 1 |
#include <pthread.h>
struct responce_times {
struct timeval start_time;
struct timeval end_time;
int responce_time;
};
int atack_start = 0;
char *host = 0;
char *path = 0;
int *ilist = 0;
pthread_mutex_t mutex;
struct responce_times *responce_list = 0;
int responce_i = 0;
int debug_i... | 0 |
#include <pthread.h>
pthread_mutex_t mutex, mutex2, mutex3;
time_t init_time;
int cnt, cnt2;
void espera_activa( int tiempo) {
time_t t;
t = time(0) + tiempo;
while(time(0) < t);
}
int get_the_time(){
return (time(0) - init_time);
}
void *tareaA( void * args) {
printf("%d::A::voy a... | 1 |
#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) {
... | 0 |
#include <pthread.h>
extern int make_thread( void *(*)(void *), void * );
struct Info {
void (*func)( void * );
void *arg;
struct timespec time2wait;
};
void *timeout_helper( void *arg ) {
struct Info *tip;
tip = (struct Info *) arg;
nanosleep( &tip->time2wait, 0 );
(*ti... | 1 |
#include <pthread.h>
int g_buffer[10];
unsigned short in = 0;
unsigned short out = 0;
unsigned short produce_id = 0;
unsigned short consume_id = 0;
sem_t g_sem_full;
sem_t g_sem_empty;
pthread_mutex_t g_mutex;
pthread_t g_thread[1 +1];
void* consume(void *arg)
{
int i;
int num = (int)arg;
w... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int best_rank;
int cnt;
long int tid;
} Leader;
Leader* leader;
sem_t* barrier;
int randomRank(int max);
void* thRoutine(void* thArg);
int main(int argc, char** argv) {
int *arg, i, j, k, ranks[10];
pthread_t th;
srand(time(0));
leader ... | 1 |
#include <pthread.h>
struct QueueEntry {
char* string;
int empty;
int timestamp;
};
struct QueueEntry Q[3];
pthread_mutex_t Q_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t signal_mutex = PTHREAD_MUTEX_INITIALIZER;
int g_timestamp = 0;
void Q_init();
void Q_clear();
void Q_add(c... | 0 |
#include <pthread.h>
int quit,sum,j;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc =PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
printf("thr_fn\\n");
if (j==0){
printf("the init j success\\n");
while(j<101){
pthread_mutex_lock(&lock);
... | 1 |
#include <pthread.h>
pthread_t thread_id;
int id, arr, run, prio;
}Flow;
void init(char *str, Flow *flow);
int flowComp(const void *A, const void *B);
int comp(const Flow *flowA, const Flow *flowB);
static void start(Flow *self);
void finish();
int flowComp(const void *A, const void *B);
vo... | 0 |
#include <pthread.h>
struct jack_ringbuffer* jack_output_buffer;
pthread_mutex_t jack_output_buffer_mutex;
int jack_put_bytes=0;
int jack_get_bytes=0;
struct jack_ringbuffer* new_jack_ringbuffer(int n) {
struct jack_ringbuffer* buffer;
buffer=malloc(sizeof(struct jack_ringbu... | 1 |
#include <pthread.h>
struct lectred {
pthread_mutex_t m;
pthread_cond_t cl, ce;
int ecriture;
int nb_lecteurs, nb_lect_att, nb_ecri_att;
};
struct linked_list {
int nb;
struct linked_list *next;
};
struct linked_list_head {
struct lectred sync;
struct linked_list *head;
};
struct ... | 0 |
#include <pthread.h>
{
int start, end, *q, pos;
}table_s, *table;
int nbthread = 4, n = 20;
int *rethread;
{
int i;
pthread_mutex_t *mutex;
}patate_s, *patate;
int *rethread;
patate o;
int sumseq(int *q, int n)
{
int ret=0;
for (int i=0 ; i< n ; i++)
ret += q[i];
return ret;
}
void *... | 1 |
#include <pthread.h>
void *ssu_loop1(void *arg);
void *ssu_loop2(void *arg);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int shared_value;
int main(void) {
pthread_t tid1, tid2;
int status;
shared_value = 0;
if(pthread_create(&tid1, 0, ssu_loop1, 0) != 0) {
fprintf(stderr, "pth... | 0 |
#include <pthread.h>
struct timeval startread,startcalc,finish,readtime,calctime,overalltime;
int n,a[100],value;int thread_count,count;
pthread_mutex_t mutex;
void *t1(void *x)
{
int i=(int)x;
int k;
if(i==thread_count-1)
{
for(k=(i)*(n);k<count;k++){
if(a[k]==3)
{
pt... | 1 |
#include <pthread.h>
struct udp_splice_handle {
pthread_mutex_t lock;
int sock;
uint16_t id;
};
static int udp_splice_get_family_id(int sock)
{
struct {
struct nlmsghdr nl;
char buf[4096];
} buf;
struct genlmsghdr *genl;
struct rtattr *rta;
struct sockaddr_nl addr = {
.nl_family =... | 0 |
#include <pthread.h>
void search_by_thread( void* ptr);
{
char* start_ptr;
char* end_ptr;
int slice_id;
} slice_data;
{
char* start_ptr;
char* end_ptr;
int thread_id;
int num_slices;
char match_str[16];
char* array_address;
slice_data* slice_struct_address;
} thread_data;
i... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void printMsg(char *str, int err)
{
printf("%s:%s\\n", str, strerror(err));
exit(1);
}
void *thr_fn(void *arg)
{
int err;
... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t thereAreOxygen, thereAreHydrogen;
pthread_t oxygen, hydrogen[2];
int numberOxygen = 0 , numberHydrogen=0;
int activeOxygen = 0 , activeHydrogen=0;
int currentOxygen = 0 , currentHydrogen=0;
void dataIn(){
int var=0;
if(numberHydro... | 1 |
#include <pthread.h>
static sem_t _sem_send_msgs_empty;
static sem_t _sem_send_msgs_full;
static char *send_msgs[16] = { 0 };
static pthread_mutex_t _lock_send_id;
void thread_sendstream_post_new_msg(char *msg)
{
static int pos = 0;
assert(msg != 0);
sem_wait(&_sem_send_msgs_empty... | 0 |
#include <pthread.h>
int
kill (pid_t pid, int signo)
{
if (pid != getpid ())
{
errno = EOPNOTSUPP;
return -1;
}
pthread_mutex_lock (&sig_lock);
struct sigwaiter *waiter;
for (waiter = sigwaiters; waiter; waiter = waiter->next)
if ((waiter->signals & sigmask (signo... | 1 |
#include <pthread.h>
struct station {
int passenger_count;
int train_in_station;
};
struct station cal_station;
pthread_mutex_t station_key;
pthread_cond_t train_arrived;
pthread_cond_t seats_available;
pthread_cond_t train_loaded;
pthread_mutex_t seats_key;
int seats_count;
... | 0 |
#include <pthread.h>
extern sem_t GroupSize;
void *gc_thread(void *arg)
{
struct sock_token *token = (struct sock_token *)arg;
sem_wait(&(token->done));
sem_close(&token->done);
Free(token->client);
Free(token->time_lock);
Free(token->last_time);
Free(token);
}
void *th... | 1 |
#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(err, "sigwait failed");... | 0 |
#include <pthread.h>
int g_counter = 0;
int g_stop_it = 0;
pthread_mutex_t mutex_stop = PTHREAD_MUTEX_INITIALIZER;
int sockaddrInit(const char *host, int port, struct sockaddr_in *peer)
{
int code;
memset(peer, '\\0', sizeof(struct sockaddr_in));
peer->sin_family = AF_INET;
peer->... | 1 |
#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);
while(head==0)
pthread_... | 0 |
#include <pthread.h>
int numOfPassengersOnBus;
int turn;
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 = "Consumer1";
const char* msg3 = "Consumer2";... | 1 |
#include <pthread.h>
static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
struct mntent *getmntent_r (FILE *filep,
struct mntent *mnt, char *buff, int bufsize)
{
static const char sep[] = " \\t\\n";
char *cp, *ptrptr;
if (!filep || !mnt || !buff)
return 0;
while ((... | 0 |
#include <pthread.h>
struct tdata {
int count;
int turn;
int thread;
pthread_mutex_t lock;
int thread_count;
};
void *countUp(void *param) {
struct tdata* datas = (struct tdata*)param;
pthread_mutex_lock(&datas->lock);
int thread_id = datas->thread;
datas->thread++;
pthread_mu... | 1 |
#include <pthread.h>
long thread_count;
pthread_mutex_t mutex;
char** messages;
void* Thread_prod_con(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
int main(int argc, char* argv[]) {
pthread_t* thread_handles;
Get_args(argc, argv);
thread_handles = mall... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
int maxYield = 20;
void *second_thread(void *a) {
assert(a == 0);
printf("T2: acquire lock\\n");
assert(pthread_mutex_lock(&mutex1) == 0);
printf("T2: got the lock. Yielding now %d times.\\n", maxYield);
... | 1 |
#include <pthread.h>
static int keyCols[3] =
{
5,
16,
1
};
static int keyRows[4] =
{
0,
2,
3,
4
};
unsigned waitingFirst = 0;
unsigned waitingLast = 0;
int* buffer = 0;
size_t currentBufferSize = 0;
pthread_t driverThread;
pthread_mutex_t bufferMutex;
pthread_cond_t eventsQueued;
... | 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(void)
{
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a,0,thread1,(void *)0);
pthread_cre... | 1 |
#include <pthread.h>
void * serverthread(void * parm);
pthread_mutex_t mut;
int visits = 0;
main (int argc, char *argv[])
{
struct hostent *ptrh;
struct protoent *ptrp;
struct sockaddr_in sad;
struct sockaddr_in cad;
int sd, sd2;
int port;
int alen;
... | 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;
void main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0);
pth... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int idCinta;
int maxBeltSize;
int toGenerate;
void *Consumer(){
struct element *elemGotptr;
struct element elemGot;
while(1){
if(queue_empty() == 0){
pthread_mutex_lock(&mutex);
elem... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.