text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct timespec start[1000], stop[1000];
double minLatency=100000.00;
double maxLatency=0;
double avgLatency=0;
int N_DATA = 1000;
pthread_barrier_t barrier;
pthread_mutex_t lock;
struct buffer {
volatile int head;
volatile int tail;
int size;
volatile int *e... | 1 |
#include <pthread.h>
char phil_state[5] = {'T','T', 'T', 'T','T'};
pthread_mutex_t canEat;
sem_t amt;
const char* semaphore_name = "/amt";
void* dining_table(void* param);
void waiter(int phil_num, int request);
void check_on_table();
int main() {
pthread_t philosophers[5];
pt... | 0 |
#include <pthread.h>
{
unsigned char status;
char data[1024];
}Block_Info;
static int initindicator = 0;
pthread_mutex_t gmutex = PTHREAD_MUTEX_INITIALIZER;
Block_Info memory_block_arr[2];
int init()
{
memset(memory_block_arr, 0, 2*1024);
}
char * mymalloc(size)
{
int lindex;
if(size> 1... | 1 |
#include <pthread.h>
int fila[8];
int topo = 0;
pthread_mutex_t fila_mutex;
pthread_cond_t fila_threshold;
void FILA_push(int dado) {
int i;
for (i = topo; i > 0; i--)
fila[i] = fila[i-1];
if (topo < 8)
++topo;
fila[0] = dado;
}
int FILA_pop() {
if (to... | 0 |
#include <pthread.h>
static pthread_mutex_t* mutex;
static int* data;
static int nbth;
static void* thread(void *num)
{
int l = (long int)num;
int r = (l+1) % nbth;
int token;
if( 0 == num ) {
pthread_mutex_unlock( mutex + l );
}
while(1) {
pthread_mutex_lock(mutex ... | 1 |
#include <pthread.h>
int nitems;
int buff[1000000];
struct {
pthread_mutex_t mutex;
int npro;
int nval;
}put = {
PTHREAD_MUTEX_INITIALIZER
};
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
}nready = {
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_COND_INITIALIZER
};
void *pro... | 0 |
#include <pthread.h>
int worker_count;
static char cmd[256];
pthread_mutex_t worker_lock;
static void *worker_thread(void* arg);
int main(int argc, char **argv)
{
int i;
int result;
pthread_t tid;
if ((result=pthread_mutex_init(&worker_lock, 0)) != 0) {
fprintf(stderr, "file: ""... | 1 |
#include <pthread.h>
struct queue_node_s *next;
struct queue_node_s *prev;
char c;
} queue_node_t;
struct queue_node_s *front;
struct queue_node_s *back;
pthread_mutex_t lock;
} queue_t;
void *producer_routine(void *arg);
void *consumer_routine(void *arg);
long g_num_prod;
pt... | 0 |
#include <pthread.h>
static pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t c1 = PTHREAD_COND_INITIALIZER;
static int value = 1;
static void *threadFunc1(void *arg) {
while(value <= 100) {
pthread_mutex_lock(&m1);
while(value % 2 == 0) {
pthread_cond_wait(&c1, &m1);
... | 1 |
#include <pthread.h>
int receivingMsgStatus = 5;
struct message msg;
int runingStatus = 1;
pthread_mutex_t statusMutex;
struct MsgsQueueData serverQueueData;
void setRunningStatus(const int status)
{
pthread_mutex_lock (&statusMutex);
runingStatus = status;
... | 0 |
#include <pthread.h>
struct rsmgmt_pkt * rsmgmt_nl_Dequeue(struct rsmgmt_wave *rsmgmt)
{
struct rsmgmt_pkt *head = rsmgmt->rmpkt_nl;
pthread_mutex_lock(&rsmgmt->rsmgmt_nl_mutex);
if(head == 0){
printf("rsmgmt_pkt : head is NULL\\n");
goto _Exit;
}
if(head->valid ... | 1 |
#include <pthread.h>
void ft_malloc_display(void)
{
t_mempage *page;
t_memblock *block;
size_t p;
size_t index;
index = 0;
ft_putstr("--- START ---\\n");
page = ft_page_store(0, READ);
while (page)
{
ft_printf("page %u informations: size: %lu - blocks count: %lu%s%p\\n",
index++, pa... | 0 |
#include <pthread.h>
struct _task{
callback cb;
void *args;
struct _task *next;
};
struct _pool{
int thread_number;
int task_queue_size;
int max_queue_size;
int running;
pthread_t *pt;
task *task_queue_head;
pthread_mutex_t queue_mutex;
pthrea... | 1 |
#include <pthread.h>
pthread_mutex_t mux;
pthread_cond_t cond_full;
pthread_cond_t cond_empty;
int qsize;
int static counter = 0;
void* producer(void* argv)
{
int i;
for (i = 0; i < 3; i ++) {
pthread_mutex_lock(&mux);
while (qsize == 1)
pthread_cond_wait(&cond_full, &mu... | 0 |
#include <pthread.h>
int fd_mouse;
pthread_mutex_t click_mutex = PTHREAD_MUTEX_INITIALIZER;
void *thr_fn(void *arg)
{
fd_mouse = open_mouse();
cx = screen_w / 2;
cy = screen_h / 2;
while(1)
{
move_mouse(&fd_mouse);
if(buf_mouse[0] & 0x1)
{
memset(buf_mouse, 0, 8);
move_mouse(&fd... | 1 |
#include <pthread.h>
void search_by_thread( void* ptr);
{
char* start_ptr;
char* end_ptr;
int thread_id;
int slice_size;
char match_str[15];
} thread_data;
pthread_mutex_t mutex;
int main()
{
FILE* fRead;
char line[15];
char search_str[15];
char* array_ptr;
char* temp_ptr;
int i ... | 0 |
#include <pthread.h>
int NUM_THREADS=4;
int a[10000000];
double totalsum=0.0;
pthread_mutex_t mutex;
int print_data=0;
int validation=1;
double get_time(struct timeval tv_start,struct timeval tv_end)
{
return (double)(tv_end.tv_sec-tv_start.tv_sec)+((double)tv_end.tv_usec-tv_start.tv_usec)/1... | 1 |
#include <pthread.h>
struct products
{
int buffer[16];
pthread_mutex_t lock;
int readpos,writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init_buffer(struct products *b)
{
pthread_mutex_init(&b->lock,0);
pthread_cond_init(&b->notempty,0);
pthre... | 0 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
int contador = 0;
int buffer[5];
int N = 5;
int consumidos[20];
void *productor(void *argv){
int num_items = 0;
int i;
int pos_buffer = 0;
srand(time(0));
while( num_items < 20){
usle... | 1 |
#include <pthread.h>
void *producer(void* arg);
void *consumer(void* arg);
pthread_mutex_t mutex;
int running =1;
int buff=0;
int main()
{
pthread_t pro,consu;
pthread_mutex_init(&mutex,0);
if(pthread_create(&pro,0,(void*)producer,0) <0)
{
printf("线程创建失败\\n" );
}
... | 0 |
#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");
... | 1 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("prepareing locks,,,\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent unlocking locks,,,\\n... | 0 |
#include <pthread.h>
void * thread_fcn(void * thread_arg);
static int num_threads;
static double sum, step;
static pthread_mutex_t lock;
int main(int argc, char *argv[]) {
double start_time, end_time;
double pi;
num_threads =
get_integer_environment("NUM_THREADS",... | 1 |
#include <pthread.h>
LIST list_init(size_t capacity, bool allowdups);
bool list_destroy(LIST *l);
bool list_insert(LIST l, uintptr_t *item);
bool list_remove(LIST l, uintptr_t *item);
bool list_contains(LIST l, uintptr_t *item);
bool list_get(LIST l, uintptr_t *item);
bool list_look(LIST l, uintp... | 0 |
#include <pthread.h>
pthread_mutex_t thread_lock;
int xfernum;
int itemnum;
int procnum;
int THRESHOLD;
int mis;
int bcmax;
int bc;
int rawdata[100][30 + 1];
{
int counter;
int xferrec[100];
} cell;
cell wholedata[30][30];
{
cell stats;
int items[30];
} list;
void *large(void *arg);... | 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>
struct buffer_t {
char data[20];
int in;
int out;
pthread_mutex_t mutex;
sem_t empty;
sem_t full;
} buffer;
int totalItems = 0;
pthread_t producer[2], consumer[2];
void *produce(void *tid) {
int i;
for(i=0; i<100; i++) {
sem_wait(&(buffer.full));
... | 1 |
#include <pthread.h>
int cnt;
pthread_mutex_t mutex;
} Counter;
int k;
float result;
float *v, *v1, *v2;
float **mat;
Counter C;
void* operation(void* arg) {
int* argT = arg;
int i = *argT;
int j;
pthread_detach(pthread_self());
v[i] = 0;
for (j=0; j<k; j++) {
v[i] += mat[i][j]*v2[i... | 0 |
#include <pthread.h>
void init_web(int fd)
{
char buff[4096];
sprintf(buff,"HTTP/1.0 200 OK\\r\\n"
"Connection: Keep-Alive\\r\\n"
"Server: Network camera\\r\\n"
"Cache-Control: no-cache,no-store,must-revalidate,pre-check=0,max-age=0\\r\\n"
"Pragma: no-cache\\r\\n"
"Content-T... | 1 |
#include <pthread.h>
int buffer[100];
int nextp, nextc;
int count=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
{
for (int i=0; i<=... | 0 |
#include <pthread.h>
struct queue* consprodqueue;
int elementsToPush;
int elementsToPop;
void *consumerthreadfunction(void* arg){
pthread_mutex_t* mutex= (pthread_mutex_t*) arg;
int size;
int consumer=pthread_self();
int* ret=malloc(sizeof(int));
while(1){
pthread_mutex_lock(mutex);
if(e... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long long i = 0;
void *start_counting(void *arg) {
for (;;) {
pthread_mutex_lock(&mutex);
if (i >= 100000) {
pthread_mutex_unlock(&mutex);
return 0;
}
... | 0 |
#include <pthread.h>
int NUM_THREADS = 2;
double **V,**Q;
int n;
struct thread_data
{
int id;
};
struct thread_data *thread_data_array;
pthread_mutex_t *lock;
void *gs(void *threadarg);
double vecNorm(double *,int );
double scalarProd(double *,double *,int);
int main(int argc, char *argv[]... | 1 |
#include <pthread.h>
pthread_mutex_t mutex ;
pthread_cond_t cond_pro, cond_con ;
void* handle(void* arg)
{
int* pt = (int*)arg ;
int soldn = 0 ;
int tmp ;
while(1)
{
pthread_mutex_lock(&mutex);
while( *pt == 0)
{
printf("no tickets!\\n");
pthread_cond_signal(&cond_pro);
p... | 0 |
#include <pthread.h>
int globalInt;
int state;
pthread_t tid[2];
pthread_mutex_t lock1, lock2;
void* thread1(void *arg)
{
int i = 1;
int tempInt;
FILE *input = fopen("hw4.in", "r");
while(i == 1)
{
pthread_mutex_lock(&lock1);
if(state == 0)
state++;
i = fscanf(input, "%d\\n", &... | 1 |
#include <pthread.h>
int count = 0;
double finalresult=0.0;
pthread_mutex_t count_mutex;
pthread_cond_t count_condvar;
void *sub1(void *t)
{
int i;
long tid = (long)t;
double myresult=0.0;
sleep(1);
pthread_mutex_lock(&count_mutex);
if ( count < 12)
{
printf(... | 0 |
#include <pthread.h>
static void start(struct ActorSystem * self) {
for (int i = 0; i < self->worker_threads_size; i++) {
self->worker_threads[i]->start(self->worker_threads[i]);
}
}
static void stop(struct ActorSystem * self) {
self->cancel = 1;
for (int i = 0; i < self-... | 1 |
#include <pthread.h>
struct Params
{
int *start;
size_t len;
int depth;
};
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void *merge_sort_thread(void *pv);
void merge(int *start, int *mid, int *end)
{
int *res = malloc((end - start)*sizeof(*res));
int *lhs = start,... | 0 |
#include <pthread.h>
pthread_mutex_t lineMutex;
int lineCount=0;
char strContain(char*childstr,char*str);
char strContainDEFINE(char*str);
int countDefine(char*fileName);
int find(char * dirName);
struct task * next;
char* dir;
}task;
int num;
int shutdown;
pthread_t* workThread;
task* taskH... | 1 |
#include <pthread.h>
bool *hashTable;
pthread_mutex_t *locks;
void hashTableCreate(int numOfBlocks) {
LOG_PROLOG();
hashTable = (bool*) my_malloc(sizeof(bool) * numOfBlocks);
locks = (pthread_mutex_t*) my_malloc(sizeof(pthread_mutex_t) * numOfBlocks);
for (int i = 0; i < numOfBlocks; i++) {
... | 0 |
#include <pthread.h>
int pbs_msgjob_err(
int c,
char *jobid,
int fileopt,
char *msg,
char *extend,
int *local_errno)
{
struct batch_reply *reply;
int rc;
if ((jobid == (char *)0) || (*jobid == '\\0') ||
(msg == (char *)0) || (*msg == '\\0'))
return(PBSE_IVALREQ);... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *thread2 (void *arg);
void *thread (void *arg)
{
long j = (long) arg;
int i, ret;
pthread_t th[4];
pthread_mutex_lock(&m);
pthread_mutex_unlock(&m);
printf ("t%ld: running!\\n", j);
for (i = 0; i < 4; ... | 0 |
#include <pthread.h>
struct partilhar{
int tatuadora;
int num_cads;
int *num_cls;
int *recurso1, *recurso2;
};
struct partilhar *partilha;
struct sincronizar *sinc;
void SOpTattoo_init(int num_cl, int num_cad){
cria_recursos_partilhados(num_cad,num_cl,1);
pthread_mutexattr_t at... | 1 |
#include <pthread.h>
pthread_mutex_t myMutex;
char sentence[2000];
int charIndex = 0;
char convertUppercase(char lower) {
if ((lower > 96) && (lower < 123)) {
return (lower - 32);
}
else {
return lower;
}
}
void printChar() {
printf("The new sentence is [%d]: \\t%c\\n", charIndex, s... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t pthread_handle;
int selfid;
int isWaiting;
int blocker_thread_id;
int resume_thread_id;
pthread_attr_t attr;
pthread_cond_t cond;
} _pthread_t;
void wait(int thid, pthread_cond_t cond_c... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_value;
int a = 1;
int myglobal;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_function(void *arg)
{
int i,j;
for ( i=0; i<20; i++)
{
pthread_mutex_lock(&mymutex);
j=myglobal; j=j+1;
printf... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void handle(int signum)
{
int pid = 0;
printf("recv signum:%d \\n", signum);
while ((pid = waitpid(-1, 0, WNOHANG) ) > 0)
{
printf("退出子进程pid%d \\n", pid);
fflush(stdout);
}
}
int srv_init()
{
int ret = 0;
i... | 1 |
#include <pthread.h>
static pthread_mutex_t prof_mutex = PTHREAD_MUTEX_INITIALIZER;
char* str;
int value;
} ioctl_s;
static ioctl_s ioctl_calls[256];
static int profiling_enabled = 0;
void ioctl_start_profiling()
{
if(profiling_enabled)
ioctl_stop_profiling();
memset(ioctl_calls, 0, si... | 0 |
#include <pthread.h>
void jelly_reset(struct Jelly *jelly)
{
jelly->jelly_message_read_head = 0;
jelly->jelly_message_write_head = 0;
jelly->proximity_locations = 0;
jelly->local_proximity = 0;
jelly->routing_table_head = 0;
jelly->network_packet_receive_read = 0;
jelly->net... | 1 |
#include <pthread.h>
struct netent *getnetbyaddr(long net, int type)
{
char *buf = _net_buf();
if (!buf)
return 0;
return getnetbyaddr_r(net, type, (struct netent *) buf,
buf + sizeof(struct netent), NET_BUFSIZE);
}
struct netent *getnetbyaddr_r(long net, int type, struct netent *re... | 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(struct foo))) != 0) {
... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static void * thr_func(void *p)
{
int i,j,mark;
while(1)
{
pthread_mutex_lock(&mut_num);
while(num == 0)
{
pthread_mutex_unlock(&mut_num);
sched_yield();
pthread_mutex_lock(&mut_... | 0 |
#include <pthread.h>
static pthread_mutex_t tty_mutex;
static int mtx_inited;
static int redirect_to_display;
int tty_redirect_to_display() {
return redirect_to_display;
}
void tty_to_display(int to_display) {
redirect_to_display = to_display;
}
int tty_open(struct file *fp, int flags)... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex;
long circleCount;
long totalCount;
void *CalculatePi(void *args){
long tid = (long)args;
long i;
float x;
float y;
long total = 0;
long circle = 0;
float pi;
FILE *urandom;
urandom = fopen("/dev/urandom"... | 0 |
#include <pthread.h>
static int g_tempdir_nonce = 0;
static int g_num_tempdirs = 0;
static char **g_tempdirs = 0;
static pthread_mutex_t tempdir_lock = PTHREAD_MUTEX_INITIALIZER;
static void cleanup_registered_tempdirs(void)
{
int i;
const char *skip_cleanup;
skip_cleanup = getenv("SKIP_... | 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 sock;
int owned;
pthread_t owner;
int named;
} sock_struct;
int n_sock;
int max_sock;
sock_struct **sbs;
pthread_mutex_t *mutex;
int init_socket_tacker(int max_sockets){
sbs = malloc(sizeof(sock_struct*)*max_sockets);
pthread_mutex_init(mutex,0);
max_sock = 0... | 1 |
#include <pthread.h>
void Funcion_Error(int nHilos, FILE *fp,int numLns);
int numero_lineas(char *ruta, int *tam_lineas);
void * countWords(void * datosNecesarios);
void * printEstado(void * arg);
struct structuraHilo{
FILE *fp;
int InicioLeer;
int lineaIn;
int *tam_lineas;
int lineaFin... | 0 |
#include <pthread.h>
pthread_mutex_t kljuc;
pthread_cond_t pun, prazan;
int ulaz=0, izlaz=0;
int M[5];
int duljina=0;
int pun_brojac=0;
int prazan_brojac=1;
int broj_proiz;
int kolicina_u_spremniku=0;
char *s;
int index;
}podaci;
void * proizvodjac(void *podatak){
podaci* p = (podaci*) po... | 1 |
#include <pthread.h>
pthread_t left_mouse_thread, right_mouse_thread;
struct mouse_data* working_data;
pthread_mutex_t working_data_mutex = PTHREAD_MUTEX_INITIALIZER;
unsigned char left_data[3];
unsigned char right_data[3];
int left_mouse_fd;
int right_mouse_fd;
void left_mouse_counter(v... | 0 |
#include <pthread.h>
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
int makethread(void * (*fn)(void *), void *arg)
{
int err;
pthread_t tid;
pthread_attr_t attr;
err = pth... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int counter;
void *task(void *tid)
{
for(int i = 0; i < 1000000; i++) {
pthread_mutex_lock(&mutex);
counter += 1;
pthread_mutex_unlock(&mutex);
}
pthread_exit(0);
}
int main(int argc, char *argv[])
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mx, my;
int x=2, y=2;
void *thread1() {
int a;
pthread_mutex_lock(&mx);
a = x;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
pthread_mutex_unlock(&my);
a = a + 1;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y... | 1 |
#include <pthread.h>
int putqueue(int Q[],int *front,int *rear,int item)
{
sem_wait(&writer);
if((*rear+1)%MAX==*front)
{
printf("Queue overflow\\n");
}
if(END==*front)
{
pthread_mutex_lock(&mut);
*front=0;
*rear=0;
pthread_mutex_unlock(&mut);
}
else
{
pthread_mutex_lock(&mut);
*rear=(*rear+1... | 0 |
#include <pthread.h>
void * run_dynamixel_comm(void * var){
int hz = 100;
Dynam_Init(&dynam);
pthread_mutex_lock(&dynamixel_mutex);
bus.servo[0].id = 1;
bus.servo[1].id = 2;
bus.servo[0].cmd_mode = WHEEL;
bus.servo[1].cmd_mode = WHEEL;
Dynam_SetMode(&dynam,&(... | 1 |
#include <pthread.h>
void* print_msg_func(void *ptr);
pthread_mutex_t gmutex1 = PTHREAD_MUTEX_INITIALIZER;
int gcounter;
int main()
{
gcounter = 0;
pthread_t thread[10];
char* msg = "Messange from thread";
int ret[10];
int i,j;
for(i=0; i<10; i++)
{
ret[i] = pthrea... | 0 |
#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);
(*tip->to_fn)(tip-... | 1 |
#include <pthread.h>
void *philosopher(void *arg);
int food_left();
void pick_chop(int p, int c, char *hand);
void drop_chop(int c1, int c2);
pthread_mutex_t food_lock;
pthread_mutex_t chopstick[5];
pthread_t philos[5];
int main(int argn, char* argv[]){
pthread_attr_t attr;
int rc;
long t... | 0 |
#include <pthread.h>
char password[9] = "aaaaaaaa";
pthread_mutex_t alock;
int keysize;
char *target;
char *salt;
}passwordData;
void *passwordLooper(void *arg);
int main(int argc, char *argv[]){
int i = 0;
if (argc != 4) {
fprintf(stderr, "Too few/many arguements give.\\n");
fprint... | 1 |
#include <pthread.h>
struct thread_info {
pthread_t thread_id;
int thread_num;
char *thread_para;
};
int num = 0;
pthread_mutex_t mutex;
static void *
thread_start(void *arg)
{
struct thread_info *tinfo = (struct thread_info *)arg;
pthread_mutex_lock(&mutex);
num++;
printf("Thread: (%... | 0 |
#include <pthread.h>
int big_int;
pthread_mutex_t pmt;
void* thread(void *p)
{
printf("Thread:start add!\\n");
p = (int*)6;
int i;
for(i = 0;i < 20000000;i++)
{
pthread_mutex_lock(&pmt);
big_int++;
pthread_mutex_unlock(&pmt);
}
printf("Thread:I have added up!\\n");
pthread_exit(p);... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len;
long offset;
double mysum, *x, *y;
offset = (long)arg;
... | 0 |
#include <pthread.h>
{
char value[4];
char name[16];
} key_t;
key_t keys[] =
{
{ { 0x1b, 0x5b, 0x41 }, "dir up" },
{ { 0x1b, 0x5b, 0x42 }, "dir down" },
{ { 0x1b, 0x5b, 0x43 }, "dir right" },
{ { 0x1b, 0x5b, 0x44 }, "dir left" },
};
{
int dx;
int dy;
} dir_t;
dir_t dirs[] =
{
{ -1... | 1 |
#include <pthread.h>
struct hostent *my_gethostbyname_r(const char *name,
struct hostent *res ,
char *buffer ,
int buflen ,
int *h_errnop)
{
struct hostent... | 0 |
#include <pthread.h>
pthread_mutex_t chave_vetor;
pthread_cond_t condc, condp;
int vetor[5];
int quantidade, prod, cons;
void* produtor(void *arg) {
while(1) {
printf("Produtor: antes do lock\\n");
pthread_mutex_lock(&chave_vetor);
printf("Produtor: depois do lock\\n");
... | 1 |
#include <pthread.h>
struct skynetCore_t{
pthread_mutex_t protector;
pid_t pid;
};
int set_priority(int priority)
{
int policy;
struct sched_param param;
if (priority < 1 || priority > 63) return -1;
pthread_getschedparam(pthread_self(), &policy, ¶m);
param.sched_pr... | 0 |
#include <pthread.h>
struct {
int a;
int b;
} foo;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *
thread(void *x)
{
intptr_t data = (intptr_t) x;
while (1) {
pthread_mutex_lock(&mutex);
if (foo.a != foo.b) {
if (data == 0)
write(1, "|", 1);
else
write(1, "_"... | 1 |
#include <pthread.h>
struct timespec some_time = {0, 10000};
FILE *fptr;
pthread_mutex_t LOCK, *m_LOCK = &LOCK;
int setup, *s_shm = &setup, current, *c_shm = ¤t;
void produce(void)
{
int err, *n = 0;
printf("%2d P: attempting ot produce \\t %3d\\n", pthread_self(), getpid());
F... | 0 |
#include <pthread.h>
char ch;
int x,y;
int step;
}Word;
char ch;
short int flag;
}inputChar;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
Word *arry;
inputChar* inputarry;
int score=0;
int lose=0;
void initArry(int len,int cols,int step)
{
int i;
for(i=0;i<len;++i){
arry[i].ch=rand... | 1 |
#include <pthread.h>
int contador;
pthread_mutex_t mutex;
sem_t semaforo_productor;
sem_t semaforo_consumidor;
void agregar(char c);
void quitar();
void * productor()
{
while(1)
{
char c = 'a' + rand()%24;
agregar(c);
usleep(1000);
}
}
void * consumidor()
{
while(1)
{
... | 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(stru... | 1 |
#include <pthread.h>
int size;
int ref_count;
void *hdl;
}pl_array_t;
static pl_array_t pl_array[3] = {
{1*(400), 0, 0}
,{4*(400), 0, 0}
,{26*(400), 0, 0}
};
static pthread_mutex_t pl_mutex = PTHREAD_MUTEX_INITIALIZER;
void *buf_pl_get(int mtu)
{
void *pl;
int... | 0 |
#include <pthread.h>
int tunsrv_pendbufferwait = 0;
int tunsrv_pendbuffer = 0;
pthread_mutex_t tunsrv_pendbuffermutex;
pthread_cond_t tunsrv_mainwaitcond;
pthread_mutex_t tunsrv_mainwaitmutex;
pthread_cond_t tunsrv_threadwaitcond;
pthread_mutex_t tunsrv_threadwaitmutex;
struct tunsrv_buffer_s
{
... | 1 |
#include <pthread.h>
int num_switches = 10;
pthread_mutex_t mtx;
pthread_cond_t cond;
pthread_t threads[2];
int i, done = 0;
void *f( void *p )
{
if( i > 1 )
{
pthread_join( threads[ i % 2 ], 0 );
}
++i;
if( i < num_switches )
{
assert( !pthread_create( &t... | 0 |
#include <pthread.h>
void show_alloc_mem(void)
{
pthread_mutex_lock(&g_fastmutex);
show_alloc(0);
pthread_mutex_unlock(&g_fastmutex);
}
void show_alloc_mem_hex(void)
{
pthread_mutex_lock(&g_fastmutex);
show_alloc(1);
pthread_mutex_unlock(&g_fastmutex);
}
| 1 |
#include <pthread.h>
void *thread_func1(void *ptr);
void *thread_func2(void *ptr);
static int s_val=0;
pthread_mutex_t lock;
int main(void)
{
pthread_t thread1, thread2;
int iret1, iret2;
iret1 = pthread_create( &thread1, 0, thread_func1, (void*)0);
iret2 = pthread_create( &thread2, 0, ... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
pthread_t tid[5];
int buffer[2];
int fd;
int sequence = 1;
char buf[20];
void *data_input(void *arg)
{
int no1, no2;
while (1) {
pthread_mutex_lock(&lock);
while (sequence != 1) {
pthread_cond_wait(&cond, &lock);
... | 1 |
#include <pthread.h>
int element[(5)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int(void);
int stored_elements[(5)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=0;
q->amount=0;
ret... | 0 |
#include <pthread.h>
int g_socket_queue[5000] = {0};
unsigned short g_port_id = 1;
static pthread_mutex_t port_lock;
static unsigned short getport()
{
unsigned short result = 0;
pthread_mutex_lock(&port_lock);
result = g_port_id++;
if (result == 0)
{
result++;
}
... | 1 |
#include <pthread.h>
int m1[10][10];
int m2[10][10];
int m3[10][10];
int idx, fim;
}thread_arg, *ptr_thread_arg;
pthread_mutex_t _mutex_lock;
void *
soma(void *arg)
{
int j, k, endidx;
ptr_thread_arg argument = (ptr_thread_arg)arg;
endidx = argument->idx + argument->fim;
... | 0 |
#include <pthread.h>
char valor;
int ocorrencias;
}simbolo;
pthread_mutex_t mutex;
int nthreads;
char *arq_nome;
simbolo *vetor;
simbolo* instancia_vetor_simbolos(){
int i;
simbolo *vetor = (simbolo*) malloc(90*sizeof(simbolo));
for(i = 0; i < 90; i++){
vetor[i].valor = (char) i ... | 1 |
#include <pthread.h>
extern int errno;
static void *treat(void *);
pthread_t idThread;
int thCount;
}Thread;
Thread *threadsPool;
int sd;
int nthreads;
pthread_mutex_t mlock=PTHREAD_MUTEX_INITIALIZER;
void raspunde(int cl,int idThread);
int main (int argc, char *argv[])
{
struct soc... | 0 |
#include <pthread.h>
int pthread_sleep (int seconds)
{
pthread_mutex_t mutex;
pthread_cond_t conditionvar;
struct timespec timetoexpire;
if(pthread_mutex_init(&mutex,0))
{
return -1;
}
if(pthread_cond_init(&conditionvar,0))
{
return -1;
}
struct... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int sum = 0;
int* array;
struct arg_th{
int start;
int finish;
};
void* sum_elements(void* args){
struct arg_th* data_of_th = (struct arg_th*)args;
int start_index = data_of_th->start;
int finish_index = data_of_th->finish;
... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
len ... | 1 |
#include <pthread.h>
double a;
double b;
double area;
struct t *proximo;
} TAREFA;
pthread_mutex_t mutexInsereVetor, mutexRetiraVetor, mutexIntegral;
int a, b, nthreads, erroMaximo, numTarefas;
TAREFA *vetorTarefas;
double calcula_funcao(double x){
return sin(x*x);
}
double ... | 0 |
#include <pthread.h>
long long counter = 0;
int opt_yield = 0;
volatile static int lock2 = 0;
void add(long long *pointer, long long value)
{
long long sum = *pointer + value;
if (opt_yield)
pthread_yield();
*pointer = sum;
}
void sum(void *a)
{
int n = *(int*)a;
for (in... | 1 |
#include <pthread.h>
volatile int connfds[MAX_LINK] = {0};
volatile pthread_t thread_pool[MAX_LINK] = {0};
volatile int conn_num = 0;
pthread_mutex_t mutex_connfd_list_index = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_connfd_list = PTHREAD_MUTEX_INITIALIZER;
extern volatile int in... | 0 |
#include <pthread.h>
extern int errno;
int gridsize = 0;
int grid[10][10];
int threads_left = 0;
pthread_mutex_t lock[10][10];
time_t start_t, end_t;
int PrintGrid(int grid[10][10], int gridsize)
{
int i;
int j;
for (i = 0; i < gridsize; i++)
{
for (j = 0; j < gridsize; j++)
fprin... | 1 |
#include <pthread.h>
struct queue_buff {
int buff[10];
int in_point;
int out_point;
pthread_mutex_t mutex_buff;
pthread_cond_t queue_full;
pthread_cond_t queue_empty;
};
struct queue_buff que_buff;
volatile int is_stop = 0;
void *thread_producer_func(void *args)
{
int num = (int)a... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.