text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static void** head = 0;
static int listSize = 0;
static int listCapa = 5;
static pthread_mutex_t lock;
void referer_init(){
if(head!= 0) return;
pthread_mutex_init(&lock, 0);
head = malloc(listCapa * sizeof(void*));
}
int referer_add(void* addr){
pthread_mutex_loc... | 1 |
#include <pthread.h>
static int valueget;
static char nameget;
struct elem{
char c;
int integer;
};
struct buffer{
struct elem content[16];
int readp;
int writep;
int counter;
pthread_mutex_t bufferlocker;
pthread_cond_t bufferwait;
};
static struct buffer b;
v... | 0 |
#include <pthread.h>
int buffer[100];
int nextp, nextc;
int count=0;
int ProFin=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void printfunction(void * ptr)
{
int count = *(int *) ptr;
if (count==0)
{
printf("All items produced are consumed by the consumer \\n");
}
else
{
fo... | 1 |
#include <pthread.h>
struct _int_channel{
int queue[100];
int front;
int back;
int MAX_SIZE;
int size;
bool poisoned;
pthread_mutex_t lock;
pthread_cond_t write_ready;
pthread_cond_t read_ready;
};
int _init_int_channel(struct _int_channel *channel){
if(pth... | 0 |
#include <pthread.h>
int x, y;
} my_state;
my_state state;
sigset_t set;
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
void display(my_state *ptr) {
printf("\\nx = %1d\\n", ptr->x);
usleep(1000);
printf("y = %1d\\n", ptr->y);
}
void *monitor(void *arg) {
int sig=0;
for (;;) {
sig... | 1 |
#include <pthread.h>
struct Buff_List *next;
char word[20];
int count;
}Buff_List;
char word[20];
}S_Buff;
Buff_List *head;
int i;
FILE *fp;
int start;
int end;
int buff_count;
int n;
int b;
}threadPara;
char S_Buffer[10][100][20];
pthread_mutex_... | 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++;
if (count ... | 1 |
#include <pthread.h>
pthread_mutex_t prod_cons_mutex;
pthread_cond_t prod_cons_cond;
int cantProdCons = 1,
buffer = 0;
int generateItem();
void *producir(void *arg)
{
printf("Estoy en el hilo productor..\\n");
while ( 1 ) {
sleep(3);
if ( buffer == 100 ){
print... | 0 |
#include <pthread.h>
pthread_mutex_t mutexA;
pthread_mutex_t mutexB;
void* locker1(void* args)
{
pthread_mutex_lock(&mutexA);
pthread_mutex_lock(&mutexB);
pthread_mutex_unlock(&mutexB);
pthread_mutex_unlock(&mutexA);
return 0;
}
void* locker2(void* args)
{
pthread_mutex_lock(&mute... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int data = 0;
void *thread1(void *arg)
{
pthread_mutex_lock(&mutex);
data++;
printf ("t1: data %d\\n", data);
pthread_mutex_unlock(&mutex);
return 0;
}
void *thread2(void *arg)
{
pthread_mutex_lock(&mutex);
data+=2;
printf ("t2: ... | 0 |
#include <pthread.h>
struct list task_list = LIST_INITIALIZER(task_list);
struct primes_list{
struct list_head list;
int data;
};
void log_info(const char* x){
printf("%s",x);
}
pthread_mutex_t task_list_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t list_av = PTHREAD_COND_INITIA... | 1 |
#include <pthread.h>
{
int MaxPost;
pthread_cond_t codaA;
pthread_cond_t codaB;
}park_t;
void *asd;
park_t park;
int app=0;
{
pthread_t macchina;
int id;
int Ntentativi;
}Car;
Car ntid[100];
pthread_mutex_t accept_car = PTHREAD_MUTEX_INITIALIZER;
void *ParkA(int *id)
{
int tent=0;
wh... | 0 |
#include <pthread.h>
const int RMAX = 1000;
int thread_count;
int* a;
int n;
int phase;
int counter;
pthread_mutex_t mutex;
pthread_cond_t cond_var;
void Usage(char* prog_name);
void Get_args(int argc, char* argv[], int* n_p, char* g_i_p,int*thread_count);
void Generate_list(int a[], int n);
v... | 1 |
#include <pthread.h>
int
sigwaitinfo (const sigset_t *restrict set, siginfo_t *restrict info)
{
pthread_mutex_lock (&sig_lock);
struct signal_state *ss = &_pthread_self ()->ss;
pthread_mutex_lock (&ss->lock);
if ((process_pending & *set) || (ss->pending & *set))
{
bool local ... | 0 |
#include <pthread.h>
void * set_dynamixel(void * var){
while(1){
float dyna1_speed = -999.9f;
float dyna2_speed = -999.9f;
float dyna1_pose = -999.9f;
float dyna2_pose = -999.9f;
switch(commandGripper){
case 0:
pthread_mutex_l... | 1 |
#include <pthread.h>
void *Producer(void *);
void *Consumer(void *);
sem_t empty;
sem_t full;
pthread_mutex_t mutex;
int g_data[10];
int g_idx;
int main(void) {
pthread_t pid, cid;
sem_init(&empty, 0, 10);
sem_init(&full, 0, 0);
pthread_mutex_init(&mutex,0);
printf("main started\... | 0 |
#include <pthread.h>
pthread_mutex_t lock,agent,tobs,paps,mats;int i;
void * age()
{while(1)
{ pthread_mutex_lock(&lock);
i=rand()%3;
if(i==0)
{printf("Agent puts tobacco on the table\\n");
printf("Agent puts paper on the table\\n");
sleep(1);
pthread_mutex_unlock(&mats);
}
else if(i==1)
... | 1 |
#include <pthread.h>
int g_itemnum;
struct
{
pthread_mutex_t mutex;
int buff[(100000)];
int nindex;
int nvalue;
} shared = { PTHREAD_MUTEX_INITIALIZER };
void* producer(void*);
void* consumer(void*);
int main(int argc, char **argv)
{
int i;
int threadnum, threadcount[... | 0 |
#include <pthread.h>
struct sigaction my_sig;
sem_t sem1;
sem_t sem2;
pthread_mutex_t rsrcA;
FILE *file_ptr;
pthread_t tid_2;
pthread_t tid_3;
size_t words;
size_t lines;
size_t characters;
}file_data;
file_data statistics;
void my_handler(int signum)
{
printf("AES\\n");
pr... | 1 |
#include <pthread.h>
{
pthread_mutex_t mut;
pthread_cond_t inserimento[2][2][2];
int coda[2][2][2];
int temperatura;
int n_piastrelle;
}monitor;
monitor m;
{
int id;
int t;
int qta;
int tipo;
int temperatura;
}lot;
lot new_lot(int id)
{
lot s;
s.id = id;
s.t= rand()%10;
s.qta =... | 0 |
#include <pthread.h>
static struct netflow_cache_t nfc_instance;
static struct netflow_cache_t *nfcptr = 0;
static int nfc_cache_size = 0;
static struct netflow_cache_data_t *netf_key = 0;
static int front = 0, rear = 0;
static int bufuse = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIA... | 1 |
#include <pthread.h>
struct input {
int num;
int cT;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
int curThread = 1;
int timecount = 0;
void *createThread(void *input) {
struct input *in = input;
int actual = in->cT;
prin... | 0 |
#include <pthread.h>
size_t number_of_primes;
size_t *arg_parse(int argc, char *argv[]) {
if (argc != 4) {
fprintf(stderr, "usage: %s [start] [end] [num_threads]\\n", argv[0]);
exit(1);
}
char *endptr;
long tokargs[3];
for (size_t i = 0; i < sizeof(tokargs) / sizeof(toka... | 1 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void
prepare(void)
{
printf("preparing locks mutex @lock1 @lock2...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void
parent(void)
{
print... | 0 |
#include <pthread.h>
extern char coup_part[13];
extern char rdy;
extern pthread_mutex_t synchro_mutex;
extern pthread_cond_t synchro_cv;
char * send_plateau_ia()
{
static int first = 1;
static pthread_t th;
int retour = 0;
if (first)
{
first = 0;
coup_part[0] = 0;
pthre... | 1 |
#include <pthread.h>
int kuz;
int sharmuta;
pthread_mutex_t zain = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t tutzke = PTHREAD_MUTEX_INITIALIZER;
void* suma(void*arg)
{
for(int i=0;i<10000;++i)
{
pthread_mutex_lock(&zain);
kuz= kuz +1;
pthr... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void * thread1(void *arg)
{
pthread_cleanup_push(pthread_mutex_unlock,&mutex);
while(1)
{
printf("thread1 is runnning!\\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond,&mutex);
printf("thread1 applied the c... | 1 |
#include <pthread.h>
void *thd_integrate(void *);
struct integralApprox result;
pthread_mutex_t mtx_accum;
struct thd_args {
double (*pFunction)(double);
double interval[2];
double precision;
};
struct integralApprox threaded_integrate(double *pFunction(double), double start, double e... | 0 |
#include <pthread.h>
struct syscall_page* basepage;
struct syscall_buffer* base_buffers;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int last_index = 0;
void printstack(void)
{
int i, j, index;
printf("\\n");
for (index = 0; index < NUM_THREADS; index++)
{
i... | 1 |
#include <pthread.h>
static int reader_count = 0;
static int writer_count = 0;
static pthread_mutex_t reader_count_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t new_reader_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t writer_count_mutex = PTHREAD_MUTEX_INITIALIZER;
static p... | 0 |
#include <pthread.h>
int sharedCounter = 0;
pthread_mutex_t lock= PTHREAD_MUTEX_INITIALIZER;
void * thread_odd()
{
while(sharedCounter<20){
sleep(1);
pthread_mutex_lock(&lock);
printf("Odd acquired lock-");
if(sharedCounter%2 != 0) {
printf("Odd print: %d ", sharedCounter);... | 1 |
#include <pthread.h>
buffer_item buffer[200];
int index_counter_in = 0,index_counter_out = 0;
void *thread_Insert(void *arg);
void *thread_Remove(void *arg);
sem_t buff_sem;
pthread_mutex_t mutx;
char thread1[]="Producer A";
char thread2[]="Producer B";
int main(int argc, char **argv)
{
pth... | 0 |
#include <pthread.h>
static int worms;
static sem_t empty, any;
static pthread_mutex_t lock;
void *parent_bird(void *arg)
{
int i;
while (1) {
sem_wait(&empty);
pthread_mutex_lock(&lock);
worms = 13;
printf(" + parent bird brings %d worms\\n\\n", worms);
pthread_mutex_unlock(&lo... | 1 |
#include <pthread.h>
int *a;
int *b;
int sum; int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[3];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len;
long offset;
int mysum, *x, *y;
offset = *(long *)arg;
len = dotstr.veclen;
... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[5];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
t... | 1 |
#include <pthread.h>
int
init_function(struct vmod_priv *priv, const struct VCL_conf *conf)
{
return (0);
}
pthread_mutex_t header_mutex;
static void
header_init_re(struct vmod_priv *priv, const char *s)
{
if (priv->priv == 0) {
assert(pthread_mutex_lock(&header_mutex) == 0);
if (pri... | 0 |
#include <pthread.h>
sem_t sem_stu;
sem_t sem_ta;
pthread_mutex_t mutex;
int chair[3];
int count = 0;
int next_seat = 0;
int next_teach = 0;
void rand_sleep(void);
void* stu_programming(void* stu_id);
void* ta_teaching();
int main(int argc, char **argv){
pthread_t *students;
pthread_... | 1 |
#include <pthread.h>
int N;
pthread_mutex_t mutex;
struct bufitem
{
int value;
int readf[5];
sem_t var_stat;
int status;
};
struct bufitem buf[5];
int wp=0;
int rp[5]={0,0,0,0,0};
void *write();
void *read(void *);
int main()
{
N=5;
int o;
for(o=0;o<N;o++)
{
sem_init(&(buf[o].var_st... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_barrier_t barrier1;
int SharedVariable = 0;
void *SimpleThread(void *args)
{
int num, val;
int which = (int)args;
for(num = 0; num < 20; num++){
pthread_mutex_lock(&mutex1);
val = SharedVariable;
printf("... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t monitor = PTHREAD_COND_INITIALIZER;
int cond = 0;
void
task_cleanup(void * arg)
{
printf("task: clean up\\n");
pthread_mutex_unlock(&lock);
}
void *
task(void * arg)
{
pthread_cleanup_push(task_cleanup, ... | 0 |
#include <pthread.h>
int buffer1[4];
int buffer2[4];
int in1;
int out1;
int in2;
int out2;
int buffer2_is_empty()
{
return in2 == out2;
}
int buffer2_is_full()
{
return (in2 + 1) % 4 == out2;
}
int buffer1_is_empty()
{
return in1 == out2;
}
int buffer1_is_full()
{
return (in1 + 1) % 4 =... | 1 |
#include <pthread.h>
int mediafirefs_utimens(const char *path, const struct timespec tv[2])
{
printf("FUNCTION: utimens. path: %s\\n", path);
time_t since_epoch;
struct tm local_time;
static int b_tzset = 0;
char print_time[24];
bool is_file = 0;
const c... | 0 |
#include <pthread.h>
static pthread_mutexattr_t attr;
static pthread_mutex_t *pmutex;
static char shared_file[] = "/tmp/shared_file.mmap";
static int fd = -1;
void
mutex_init(void)
{
if ((fd = open(shared_file, O_RDWR | O_CREAT | O_TRUNC, FILE_MODE)) < 0)
err_sys("open error");
... | 1 |
#include <pthread.h>
pthread_mutex_t msg = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t usuarios = PTHREAD_COND_INITIALIZER;
pthread_cond_t pombo_correio = PTHREAD_COND_INITIALIZER;
void* usuario(void *arg);
void* pombo(void *arg);
int carta = 0;
int main(){
int i;
int *id;
pthread_... | 0 |
#include <pthread.h>
volatile int flags[10];
volatile int wait[10];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *DoWork1(void *threadid)
{
flags[0] = flags[0] + 1;
wait[0] = 0;
pthread_exit(0);
}
void *DoWork2(void *threadid)
{
pthread_mutex_lock (&mutex);
f... | 1 |
#include <pthread.h>
struct llist_node *ll;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;;
void *build_list(void *args){
struct threads_arg *local_args;
local_args = (void *)args;
int factor_int = local_args->factor;
int maxcnt = local_args->total_threads;
char *string;
... | 0 |
#include <pthread.h>
pthread_once_t my_init_mutex = PTHREAD_ONCE_INIT;
void initialize_once_app(void)
{
printf("work only once\\n");
}
void* EntryFunction(void* arg)
{
printf("Thread %d ran~\\n", (int)arg);
pthread_t id = pthread_self();
printf("my id is %x\\n", (int)id);
int ... | 1 |
#include <pthread.h>
pthread_t tid1,tid2;
int a = 0;
int n ;
int buffer[n];
int counter =0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void * producer () {
int nextp = 0;
int in = 0;
while(1){
while(counter == n) { continue; }
pthread_mutex_lock(&mutex1);
bu... | 0 |
#include <pthread.h>
char name[256];
static int name_i = 0;
static int ppi = 0;
pthread_mutex_t number_mutex;
pthread_mutex_t number2_mutex;
void recv_user_info(int con_fd, char *info)
{
if(recv(con_fd, info, sizeof(info), 0) < 0)
{
perror("recv");
exit(1);
}
}
void exe_in(int *con... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
sem_t start0, start1, start2, start3, start4, start5, start6, start7, start8, start9;
struct buffer
{
int idata;
char cdata[100];
}buf;
void *w0(void *arg)
{
int w0_idata = 0;
char w0_cdata[100] = "0";
sem_wait(&start0);
pthread_m... | 0 |
#include <pthread.h>
int buffer[160];
int in = 0;
int out = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait_empty_buffer;
pthread_cond_t wait_full_buffer;
int buffer_is_empty()
{
return in == out;
}
int buffer_is_full()
{
return (in + 1... | 1 |
#include <pthread.h>
const size_t N_THREADS = 20;
pthread_mutex_t mutex;
struct timespec timeout;
int use_timeout;
void *run(void *arg) {
int *argi = (int *) arg;
int my_tidx = *argi;
int retcode;
printf("in child %d: sleeping\\n", my_tidx);
sleep(2);
if (use_timeout) {
while... | 0 |
#include <pthread.h>
pthread_mutex_t tmutex[5] = {PTHREAD_MUTEX_INITIALIZER};
pthread_t pid[5];
int mutexcount = 0;
void* func(void* args) {
int arc = (int*)args;
srand((unsigned int)time(0));
while(1) {
sleep(5);
if (lockfull()) {
continue;
}
... | 1 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int count;
} semaphore_t;
void init_sem(semaphore_t *s, int i)
{
s->count = i;
pthread_mutex_init(&(s->mutex), 0);
pthread_cond_init(&(s->cond), 0);
}
void P(semaphore_t *sem)
{
pthread_mutex_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t full;
sem_t empty;
int top = 0;
int bottom = 0;
void *produce(void *arg) {
int i;
for (i = 0; i < 5 * 2; i++) {
printf("producer is pushing data\\n");
sem_wait(&empty);
pthread_mutex_lock(&mutex);
... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_nonzero;
void *inc_count(void *t) {
long id = (long)t;
pthread_mutex_lock(&count_mutex);
if (count == 0)
pthread_cond_signal(&count_nonzero);
count = count + 1;
printf("Thread %ld updated count ... | 1 |
#include <pthread.h>
int somme = 0;
int nb_somme = 0;
pthread_mutex_t mutex_somme = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_print = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_print = PTHREAD_COND_INITIALIZER;
void *thread_rand(void *arg)
{
int* i = (int*)malloc(sizeof(int));
*i = ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t esperaPares;
pthread_cond_t esperaImpares;
int turnoImpares=1;
pthread_mutex_t mtx;
pthread_cond_t esperaBarrera;
int hilosespera=0;
void barrera(){
pthread_mutex_lock(&mtx);
hilosespera++;
while (hilosespera<2 )... | 1 |
#include <pthread.h>
int philo_states[NPHILO] = { '-' };
int philo_states_restore[NPHILO] = { 0 };
int sticks[NPHILO] = { 0 };
pthread_cond_t philo_conditions[NPHILO];
pthread_mutex_t stick_mutex;
pthread_mutex_t print_mutex;
pthread_barrier_t barrierSingle;
pthread_barrier_t barrierAll;
cha... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex;
static pthread_cond_t teller_available;
int id;
int checked_in;
int doing_service;
pthread_cond_t done;
pthread_t thread;
struct teller_info_t *next;
} *p_teller;
static p_teller teller_list = 0;
void teller_check_in(p_t... | 1 |
#include <pthread.h>
static pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
static 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 ) {
pri... | 0 |
#include <pthread.h>
int g_itemnum;
struct
{
pthread_mutex_t mutex;
int buff[(100000)];
int nindex;
int nvalue;
} shared = { PTHREAD_MUTEX_INITIALIZER };
void* producer(void*);
void* consumer(void*);
int main(int argc, char **argv)
{
int i;
int threadnum, threadcount[... | 1 |
#include <pthread.h>
struct msgs{
long msgtype;
char msg_text[512];
};
static int num = 2;
struct prodcons
{
char buf[16];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
struct prodcons buffer;
void init(struct prod... | 0 |
#include <pthread.h>
int tid;
pthread_mutex_t * p2c;
pthread_mutex_t * c2p;
int numVerts;
int numThr;
int** M_prev;
int** M_curr;
} pt_mat;
void *Thr(void *thrargs) {
struct pt_mat *mat;
mat = (struct pt_mat *)thrargs;
int t = (mat->tid);
int i,j,k;
for(k=0; k<(mat->numVer... | 1 |
#include <pthread.h>
int n;
int p;
int c;
int x;
int p_time;
int c_time;
int size;
int* queue;
pthread_mutex_t lock;
sem_t empty;
sem_t full;
void producer();
void consumer();
int main(int argc, char** argv) {
int elapsed;
int i;
time_t begin;
time_t end;
n = atoi(argv[1]);
... | 0 |
#include <pthread.h>
pthread_mutex_t sillas_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t esperando_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_sentarse = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_sentado = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_comer = PTHREAD_COND_I... | 1 |
#include <pthread.h>
static int connect_downstream
(
struct JH_server_worker worker [const restrict static 1]
)
{
struct sockaddr_un addr;
const int old_errno = errno;
errno = 0;
if ((worker->downstream_socket = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
{
JH_FATAL
... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_route(void *args)
{
int i = 0;
for (i = 0; i < (int)args; i++)
{
pthread_mutex_lock(&mutex);
count++;
printf("c: count: %d\\n", count);
pthread_mutex_unlock(&mutex);
}
return 0;
}
in... | 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) {
printf("inc_count():... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i < 10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
printf("inc_count():... | 1 |
#include <pthread.h>
pthread_mutex_t lock1,lock2;
{
int val;
struct node* next;
}node;
node *start='\\0';
node *getnode(int a)
{
node *temp=malloc (sizeof(node));
temp->val=a;
temp->next='\\0';
return temp;
}
void insert(int a)
{
if(start=='\\0')
start=getnode(a);
else
{
node *temp=st... | 0 |
#include <pthread.h>
struct queue {
int a;
int available;
int arr[20];
int front;
int count;
int inserted;
int deleted;
pthread_mutex_t mutex;
pthread_cond_t produce_more;
pthread_cond_t consume_more;
};
void do_some_work(int);
int done = 0;
void qu... | 1 |
#include <pthread.h>
void * watek_klient (void * arg);
int l_kr, i;
int l_kl = 5;
int l_kf = 3;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
main(){
pthread_t *tab_klient;
int *tab_klient_id;
l_kr = 1;
tab_klient = (pthread_t *) malloc(l_kl*sizeof(pthread_t));
tab_klient_id ... | 0 |
#include <pthread.h>
int
pthread_detach(pthread_t tid)
{
pthread_thread_t *pthread;
if ((pthread = tidtothread(tid)) == NULL_THREADPTR)
return EINVAL;
assert_preemption_enabled();
disable_preemption();
pthread_lock(&pthread->lock);
pthread->flags |= THREAD_DETACHED;
pthread_unlock(&pth... | 1 |
#include <pthread.h>
struct _dot{
double *a;
double *b;
double sum;
int vec_len;
};
dot dotstr;
pthread_t call_threads[4];
pthread_mutex_t mutex;
void dot_product() {
int start, end, i;
double mysum, *x, *y;
start = 0;
end = dotstr.vec_len;
x = dotstr.a;
y = dotstr.b;
... | 0 |
#include <pthread.h>
int estado_filosofo[5];
pthread_mutex_t palillo[5];
void *filosofo(void *num) {
int fil_id = *(int *)num;
while (1) {
estado_filosofo[fil_id] = 0;
printf("Filósofo %d pensando\\n", fil_id);
sleep( (rand() % 2) + 1 );
estado_filosofo[fil_id] = 1;
printf("Filó... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
... | 0 |
#include <pthread.h>
u64 total_pthread_count;
pthread_mutex_t start_mutex;
pthread_cond_t start_cond;
int start;
} global_state_t;
global_state_t global_state;
int id;
} my_pthread_t;
void raw__nanosleep(u64 nanoseconds) {
struct timespec sleepTime;
struct timespec remainingSle... | 1 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main(int argc, char* argv[])
{
int res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if(res != 0)... | 0 |
#include <pthread.h>
char buf[200] = {0};
pthread_mutex_t mutex;
unsigned int flag = 0;
void *func(void *arg)
{
sleep(1);
while (flag == 0)
{
pthread_mutex_lock(&mutex);
printf("本次输入了%d个字符\\n", strlen(buf));
memset(buf, 0, sizeof(buf));
pthread_mutex_unlock(&mutex);
sleep(2)... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *producer(void *arg)
{
long int i;
long int loops = (long int)arg;
for (i=0; i<loops; i++) {
pthread_mutex_lock(&mutex);
while (buffer_is_full())
pth... | 0 |
#include <pthread.h>
unsigned short buff = 0;
unsigned short reader_count = 0;
unsigned short control = 1;
pthread_mutex_t rmutex, wmutex;
void* thread_writer(void *arg)
{
puts("thread_writer created");
while (control) {
pthread_mutex_lock(&wmutex);
printf("writer have changed the content: ... | 1 |
#include <pthread.h>
int LoomSwitches[MaxNumFuncs];
struct Operation *LoomOperations[MaxNumInsts];
pthread_mutex_t Mutexes[MaxNumFilters];
void LoomSlot(unsigned SlotID) {
struct Operation *Op;
assert(SlotID < MaxNumInsts);
for (Op = LoomOperations[SlotID]; Op; Op = Op->Next) {
Op->Cal... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct que
{
int data;
struct que *next;
}*fr = 0, *rr = 0;
struct que *create_node(int d)
{
struct que *new = 0;
new = (struct que *)malloc(sizeof(struct que));
new->data = d;
new->next = 0;
return new;
}
void inser... | 1 |
#include <pthread.h>
int n,waitvar=0;
int glEvmCnt=0,glVoterCnt=0 ;
int boothid;
int evmCnt;
int evmSlot;
int voterCnt;
pthread_mutex_t lockevm ;
pthread_mutex_t lockstruct ;
pthread_mutex_t lockcast ;
int waiting ;
int casted;
int ready;
int tmp;
int alloted;
int waitevm;
}booth ... | 0 |
#include <pthread.h>
pthread_t callThd[4];
double *array_a;
double *array_b;
double big_sum;
int veclen;
pthread_mutex_t mutex;
pthread_attr_t attr;
void *dotprod(void *arg)
{
int i, start, end;
double *x, *y;
double mysum;
long currThread = (long) arg;
start = currThread... | 1 |
#include <pthread.h>
struct mymesg {
long mtype;
char mtext[512 +1];
};
struct threadinfo {
int qid;
int fd;
int len;
pthread_mutex_t mutex;
pthread_cond_t ready;
struct mymesg m;
};
void *helper(void *arg) {
int n;
struct threadinfo *tip = arg;
... | 0 |
#include <pthread.h>
char compute_gear_mode(int gear_mode)
{
char gear_val;
switch(gear_mode)
{
case P:
gear_val = 'P';
break;
case R:
gear_val = 'R';
break;
case N:
gear_val = 'N';
break;
case D:
gear_val... | 1 |
#include <pthread.h>
static pthread_mutex_t servers_mutex=PTHREAD_MUTEX_INITIALIZER;
static struct notifyfs_server_struct *servers=0;
static struct notifyfs_server_struct local_server;
struct notifyfs_server_struct *get_local_server()
{
return &local_server;
}
void add_server_to_l... | 0 |
#include <pthread.h>
void LinuxClock_ClockImpl_OnExit(int state, struct LinuxClock_Instance *_instance);
void LinuxClock_send_signal_clock_tick(struct LinuxClock_Instance *_instance);
void f_LinuxClock_sleep_ms(struct LinuxClock_Instance *_instance, int timeout_ms);
void f_LinuxClock_start_cl... | 1 |
#include <pthread.h>
static int nbfgetsInitialized = 0;
static volatile int nbfgetsReady = 0;
static char nbfgetsBuffer[256];
static pthread_cond_t nbfgetsCond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t nbfgetsMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_t nbfgetsThread;
static... | 0 |
#include <pthread.h>
int orb =0;
pthread_t tid[5];
int counter;
pthread_mutex_t lock;
pthread_cond_t cond;
int work=0;
void* doSomeThing(void *arg)
{
int who,tmp;
int i = 0,j;
counter += 1;
who = counter;
printf("\\n Job %d created\\n", who);
for(j=0;j<5;j++){
pthread_mutex_lock(&lock);... | 1 |
#include <pthread.h>
static const uint32_t S_NSECS = 1000000000UL;
static const uint32_t MS_NSECS = 1000000UL;
void
thread_delay_ms(int ms)
{
time_t now;
struct timespec then;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
now =... | 0 |
#include <pthread.h>
pthread_mutex_t flaglock;
pthread_cond_t mycond;
int queue_long;
int stock_time;
p call;
char *arg[10];
}fun_arg;
fun_arg *fuar_p;
struct node *next;
}mytar,*mytar_p;
mytar *front;
mytar *rear;
}queue,*listp_queue;
listp_queue g_queue;
listp_queue creat_queue()
{
... | 1 |
#include <pthread.h>
pthread_mutex_t mutexsum;
char char_array[8000000][16];
int char_counts[26];
char getRandomChar()
{
int randNum = 0;
char randChar = ' ';
randNum = 26 * (rand() / (32767 + 1.0));
randNum = randNum + 97;
randChar = (char) randNum;
return randChar;
}
void init_... | 0 |
#include <pthread.h>
struct timespec start_timer, end_timer;
uint8_t *image;
uint_t *out_mem;
size_t block_size;
} pthread_args;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
sem_t sem;
size_t N;
size_t N_THREADS;
double calc_time(struct timespec start, struct timespec end) {
struct ... | 1 |
#include <pthread.h>
void show_errno(int err) {
switch(err) {
case EINVAL :
do{ printf("%d--", 35); printf("[%u]-- %s", (unsigned int)pthread_self(), "EINVAL"); printf("\\n"); }while(0);
break;
case ETIMEDOUT :
do{ printf("%d--", 38); printf("... | 0 |
#include <pthread.h>
struct ryu_malloc_memories{
struct order *holder;
pthread_mutex_t mutex;
struct ryu_malloc_memories *next;
struct ryu_malloc_using_chain *using;
};
struct ryu_malloc_using_chain{
char *memory;
struct ryu_malloc_using_chain *next;
};
struct ryu_malloc_m... | 1 |
#include <pthread.h>
pthread_mutex_t mutexid;
pthread_mutex_t mutexres;
int idcount = 0;
pthread_mutex_t joinmutex[4];
int join[4];
int result[4];
int target;
int sequence[(4 * 30)];
void *thread (void *arg)
{
int id, i, from, count, l_target;
pthread_mutex_lock (&mutexid);
l_t... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.