text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t mutex1, mutex2, mutex3;
int l1=0, l2=0, l3=0, l4=0, l5=0, l6=0;
void *trilho(void* x_void_ptr);
int main(){
int n_trens = 3;
pthread_t trem[n_trens];
int i,j, trem_id[n_trens];
for (i=0; i<n_trens; i++){
trem_id[i] = i+1;
if (pthread_create(... | 1 |
#include <pthread.h>
int voti[5];
int votazioni_terminate[5];
pthread_mutex_t mutex_voti[5];
sem_t barriera_sondaggi_terminati;
int numero_sondaggi_terminati;
pthread_mutex_t mutex_numero_sondaggi_terminati;
void inizializza_voti() {
int i;
for (i = 0; i < 5; i++) {
voti[i] = 0;
vot... | 0 |
#include <pthread.h>
{
pthread_mutex_t mutex;
int index;
int buffer[8];
} Buffer;
void * add_val (void *ptr) {
Buffer *b = (Buffer *) ptr;
int tmp;
while (1) {
pthread_mutex_lock (&b->mutex);
if (b->index < 8) {
tmp = random();
b->buffer[b->index++] = tmp;
... | 1 |
#include <pthread.h>
int * px = 0;
int * py = 0;
pthread_mutex_t mutex_px = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_py = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_finx = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_finy = PTHREAD_COND_INITIALIZER;
void * mon_thread1 (void * arg)... | 0 |
#include <pthread.h>
int head_index = 0;
int tail_index = 0;
int hw_buffer[1000];
pthread_t p1, p2, p3;
pthread_t k1, k2, k3;
pthread_mutex_t p_lock;
pthread_mutex_t k_lock;
int get_zufallszahl(int max_randomnummer){
int randomnummer = rand() % max_randomnummer + 1;
return randomnummer;
}
voi... | 1 |
#include <pthread.h>
const int PRODUCT_NUM = 10;
pthread_mutex_t mutex;
sem_t sem_empty, sem_full;
int g_idx;
void ConsumerFunc(void) {
volatile int flag = 1;
while (flag) {
sem_wait(&sem_full);
pthread_mutex_lock(&mutex);
printf(" ===>%d\\n", g_idx);
... | 0 |
#include <pthread.h>
sem_t client_request, server_response;
pthread_mutex_t clients_me, finished_barrier_me;
volatile int val, n_finished;
void server();
void *client_thread(void *);
int main(int argc, char *argv[]) {
pthread_t t1, t2;
sem_init(&client_request, 0, 0);
sem_init(... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void *producer(void *ptr)
{
int i;
for (i = 1; i <= 300000; i++)
{
pthread_mutex_lock(&the_mutex);
if (buffer != 0)
pthread_cond_wait(&condp, &the_mutex);
buffer = i;
pthread_cond_signal(&co... | 0 |
#include <pthread.h>
void timediff(const char * s) {
static struct timeval tv;
struct timeval tmp;
gettimeofday(&tmp, 0);
int sec = (tmp.tv_sec - tv.tv_sec)*1000000;
int msec = (tmp.tv_usec - tv.tv_usec);
printf("%20.20s diff = %12.dusec\\n", s, sec + msec);
tv = tm... | 1 |
#include <pthread.h>
int dprintf(int, const char*, ...);
static pthread_mutex_t name_service_mutex = PTHREAD_MUTEX_INITIALIZER;
static int ns_channel_initialized = 0;
static struct NaClSrpcChannel ns_channel;
static int prepare_nameservice(void) {
int ns = -1;
int connected_socke... | 0 |
#include <pthread.h>
{
pthread_mutex_t *lock;
int id;
int size;
int iterations;
char *s;
} Thread_struct;
void *infloop(void *x)
{
int i, j, k;
Thread_struct *t;
t = (Thread_struct *) x;
for (i = 0; i < t->iterations; i++)
{
pthread_mutex_lock(t->lock);
for (j = 0; j < t->si... | 1 |
#include <pthread.h>
pthread_mutex_t screen = PTHREAD_MUTEX_INITIALIZER;
int term_lines;
int term_cols;
int fd;
int current_term_lines;
} data_t;
void *recieve_message(void *arg) {
char buf[1024];
data_t *data;
data = (data_t*) arg;
int rdbytes;
int line=1;
char user_limit_exceeded... | 0 |
#include <pthread.h>
pthread_mutex_t cache_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_key_t cache_stats_thread_curr;
int thread_num = 0;
void cache_stats_process_init() {
pthread_key_create(&cache_stats_thread_curr, 0);
thread_num = mk_api->config->workers;
thread_stats = ... | 1 |
#include <pthread.h>
pthread_t tid[2];
pthread_mutex_t lock;
int sockfd = -1;
void error(char *msg)
{
perror(msg);
exit(0);
}
void ExitHandler()
{
char input[1000]="exit";
int len= strlen(input);
if (sockfd != -1)
{
write(sockfd, &len, sizeof(int));
write(sockfd, input, len);
}
... | 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() {
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0) {
printf("sigwait f... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int currState = -1;
void *CreateDrone(void *);
void funcDroneInit(int *);
void funcDroneEnRoute(int *);
void funcDroneAddressReached(int *);
void funcDroneTaskFin(int *);
void *CreateDrone(void *arg)
{
int *data = (int *) arg;
funcDrone... | 0 |
#include <pthread.h>
static
struct urcu_game_config *current_config;
static
pthread_mutex_t config_mutex = PTHREAD_MUTEX_INITIALIZER;
struct urcu_game_config *urcu_game_config_get(void)
{
assert(rcu_read_ongoing());
return rcu_dereference(current_config);
}
struct urcu_game_confi... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t index_lock = PTHREAD_MUTEX_INITIALIZER;
int * counters;
int index = 0;
bool stop = 0;
static void * locking(void * arg) {
int my_index;
pthread_mutex_lock(&index_lock);
my_index = index++;
pt... | 0 |
#include <pthread.h>
static pthread_mutex_t spi_lock;
int ipc_spi_read(unsigned char *data,int len,unsigned char mode)
{
int ret_val,data_counter=0;
wait_for_gpio_interrupt_spi();
pthread_mutex_lock(&spi_lock);
switch(mode)
{
case EIGHT_BIT:
if(data != 0)
{
while(len != 0)
... | 1 |
#include <pthread.h>
struct ws2801_kernel {
int fd_commit;
int fd_refresh_rate;
int fd_set_raw;
int fd_num_leds;
struct led *leds_packed;
};
static void ws2801_kernel_commit(struct ws2801_driver *ws_driver)
{
struct ws2801_kernel *ws = ws_driver->drv_data;
unsigned int i;
struct led *dst ... | 0 |
#include <pthread.h>
int count = 0;
int in = 0;
int out = 0;
item buff[5];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t full;
sem_t empty;
void *producer();
void *consumer();
int main(){
int i;
pthread_t pthread[4];
sem_init(&full,0,0);
sem_init(&empty,0,5 -1);
... | 1 |
#include <pthread.h>
int glab = 1;
void *r1(void *arg)
{
pthread_mutex_t* mutex = (pthread_mutex_t *)arg;
static int cnt = 10;
while(cnt--)
{
pthread_mutex_lock(mutex);
glab++;
printf("I am in r1. cnt = %d\\n", glab);
pthread_mutex_unlock(mute... | 0 |
#include <pthread.h>
int counter=0;
pthread_mutex_t mutex;
void * thrfunc(void *thread){
int i;
for(i=0;i<10;i++){
pthread_mutex_lock(&mutex);
counter++;
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
void * thrfunc1(void *thread){
int i;
for(i=0;i<10;i++){
printf ("%d\\n", cou... | 1 |
#include <pthread.h>
struct list_item
{
struct list_item *next;
unsigned int size;
unsigned char inuse;
};
struct heap_t
{
void *base;
unsigned int size;
struct list_item *first_ptr;
pthread_mutex_t mutex;
FILE * pFile;
} heap;
int heap_init(unsigned int heap_size)
{
heap.p... | 0 |
#include <pthread.h>
sem_t sem_agent;
sem_t sem_tobacco;
sem_t sem_paper;
sem_t sem_match;
sem_t tobacco;
sem_t match;
sem_t paper;
sem_t sem_mutex;
bool tobFree = 0;
bool paperFree = 0;
bool matchesFree = 0;
void *agentA(void *);
void *agentB(void *);
void *agentC(void *);
void *pusherA(void *... | 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>
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[3];
pthread_mutex_t mutexMax;
pthread_mutex_t mutexMin;
pthread_mutex_t mutexAvg;
vo... | 1 |
#include <pthread.h>
pthread_mutex_t rw_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t reader_mutex = PTHREAD_MUTEX_INITIALIZER;
int num_readers = 0;
int main()
{
pthread_t subscriber_thread1;
pthread_t publisher_thread1;
void *publish();
void *subscribe();
pthread_create(&subscr... | 0 |
#include <pthread.h>
pthread_t handles[16];
int nprimes = 0;
int lower = 0;
int biggest = 10000000;
int chunk_size = 1000;
pthread_mutex_t prime_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lower_lock = PTHREAD_MUTEX_INITIALIZER;
void * func(void* s)
{
struct subrange range;
... | 1 |
#include <pthread.h>
char *pSou_arr[THREADNUM];
char *pTar_arr[THREADNUM];
int file_size;
pthread_mutex_t lock;
pthread_cond_t cond;
void *thread_func(void *arg)
{
long num = (long)arg;
printf("child thread %ld is ready\\n", num);
pthread_mutex_lock(&lock);
pthread_cond_wait(&cond, &lock);
p... | 0 |
#include <pthread.h>
int phylo_pop = 0;
int pyDE_pop = 0;
int pyDEwait_pop = 0;
int phylowait_pop = 0;
int sign = 0;
pthread_cond_t phylo_wait;
pthread_cond_t pyDE_wait;
pthread_mutex_t room_lock;
void phyloArrive(){
pthread_mutex_lock(&room_lock);
while (sign == 2){
phy... | 1 |
#include <pthread.h>
struct YYY_Monitor {
pthread_cond_t cv;
pthread_mutex_t mutex;
};
unsigned YYY_MonitorSize(){
return sizeof(struct YYY_Monitor);
}
void YYY_InitMonitor(struct YYY_Monitor *monitor){
int err;
pthread_condattr_t cv_attr;
pthread_mutexattr_t mx_attr;
... | 0 |
#include <pthread.h>
int gnut_mprobe(void *d)
{
return 0;
}
char *xmalloc(int size)
{
char *ptr;
ptr=malloc(size);
if (!ptr) { g_debug(0,"malloc(%d) failed!\\n", size); exit(1); }
return ptr;
}
char *expand_path(char *a)
{
char *b;
if (strncmp(a,"~/", 2)==0) {
char *... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
pthread_mutexattr_t attr;
pthread_cond_t cond_lock;
int cond_counter = 0;
void down(char*);
void up(char *);
void lock_init(void)
{
pthread_mutex_init(&mutex_lock, 0);
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD... | 0 |
#include <pthread.h>
struct msg *prev;
struct msg *next;
int num;
} *pMsg;
pMsg head;
pMsg tail;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void printList();
void *consumer(void *p)
{
struct msg *mp = 0;
for (;;) ... | 1 |
#include <pthread.h>
pthread_mutex_t chopsticks[5] = {PTHREAD_MUTEX_INITIALIZER};
pthread_mutex_t room = PTHREAD_MUTEX_INITIALIZER;
int room_people=0;
time_t first,second;
void think(int i)
{
usleep(2);
printf("%d am thinking!\\n", i);
}
void wait_room(int i)
{
if(room_people==4)
pthread_mu... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(800)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR: __VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{... | 1 |
#include <pthread.h>
void initializeVariables(int x, int y) {
pthread_mutexattr_t attributes;
pthread_mutexattr_init(&attributes);
pthread_mutexattr_settype(&attributes, PTHREAD_MUTEX_NORMAL);
pthread_mutex_init(&alienThreads_mutex, &attributes);
pthread_mutex_init(&bulletThreads_mutex,... | 0 |
#include <pthread.h>
FILE *f;
char **queue;
int *lens;
int *counts;
int comp_count;
int offset = 0;
pthread_mutex_t mutex_count;
int MCSLength(char *str1, int len1, char* str2, int len2) {
int** arr = malloc(sizeof(int*)*(len1+1));
if ( arr == 0 ) {
printf("Couldn't allocate memory for the ... | 1 |
#include <pthread.h>
int quitflag;
sigset_t newmask,oldmask;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *
thr_func( void *arg)
{
int err;
int signo;
for (;;){
err = sigwait(&newmask,&signo);
if ( err != 0 )
return;
switch (... | 0 |
#include <pthread.h>
int ps_list_devices(struct ps_device *devices)
{
struct ps_handle handle;
int ret;
if (ps_init_handle(&handle))
return -1;
ret = ioctl(handle.fd, PS_IOC_LIST_DEVICES, devices);
ps_close_handle(&handle);
return ret;
}
int ps_init_handle(struct ps_handle *hand... | 1 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void* p_func(void* p)
{
pthread_mutex_lock(&mutex);
int ret;
printf(" i am child ,this is wait entrance\\n" );
ret=pthread_cond_wait(&cond,&mutex);
if(0!=ret)
{
printf("pthread_cond_wait ret is %d\\n" ,ret);
}
pr... | 0 |
#include <pthread.h>
int in = 0;
int out = 0;
int buff[10] = {0};
sem_t empty_sem;
sem_t full_sem;
pthread_mutex_t mutex;
int product_id = 0;
int prochase_id = 0;
void print()
{
int i;
for(i = 0; i < 10; i++)
printf("%d ", buff[i]);
printf("\\n");
}
void *product()
{
int id = ++pr... | 1 |
#include <pthread.h>
static int count = 0;
struct sockaddr_in srv_addr;
int listen_fd;
pthread_mutex_t pth_mutex = PTHREAD_MUTEX_INITIALIZER;
void * pth_handle_conn_func(void *args);
int main(void)
{
pthread_t pth[50];
bzero(&srv_addr, sizeof(struct sockaddr_in));
srv_addr.sin_fami... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
int block;
int busy;
int inode;
pthread_mutex_t m_inode;
pthread_mutex_t m_busy;
void *allocator(){
pthread_mutex_lock(&m_inode);
if(inode == 0){
pthread_mutex_lock(&m_busy);
busy = 1;
pthread_mutex_unlock(&m_busy);
inode... | 1 |
#include <pthread.h>
int table[5] = {0,0,0,0,0};
pthread_mutex_t lock;
pthread_cond_t cond_thread;
int current_cakes = 0;
void* baking_cakes(void* arg){
while(1){
if(current_cakes == 5){
printf("Mum is watching AliRaza\\n");
pthread_cond_signal(&cond_thread);
while(current_cakes > ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex[3] = {
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER
};
int backoff = 1;
int yield_flag = 0;
void * lock_forward(void *arg)
{
int i,iterate,backoffs;
int status;
for (iterate = 0; iterate < 30;iterate++) {... | 1 |
#include <pthread.h>
double ncircle_pts = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
double rand_double(double min, double max)
{
double scale = rand() / (double) 32767;
return min + scale * (max - min);
}
void *generate_points(void *param)
{
double x, y;
for (int ... | 0 |
#include <pthread.h>
struct synch_queue {
struct q_node * head;
struct q_node * tail;
pthread_mutex_t * lock;
int size;
};
struct q_node {
struct q_node * next;
void * data;
};
struct synch_queue * synch_queue_init()
{
struct synch_queue * queue = (struct synch_queue * )
mallo... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
pthread_mutexattr_t mutexattr_lock;
pthread_t *tid;
int run = (0==0);
void END(int sig)
{
run = (0==1);
}
Boolean pthread_mutex_set(pthread_mutex_t *mutex,pthread_mutexattr_t *mutexattr)
{
Boolean rst = (0==0);
if(0 == mutex || 0... | 0 |
#include <pthread.h>
void push(struct caminfo *cam, struct imagequeue *new)
{
struct imagequeue *ptr;
int count = 0;
ptr = cam->queue;
while(ptr)
{
if(ptr->next == 0)
break;
ptr = ptr->next;
count++;
}
if(ptr)
{
ptr->next = new;
new->prev = ptr;
}
else
{
cam->queue = ne... | 1 |
#include <pthread.h>
void TunnelController()
{
northBoundCount = 0;
southBoundCount = 0;
northBound = 0;
southBound = 0;
}
void enterTunnelNorthBound(int t) {
pthread_mutex_lock(&lock);
while (southBound == 1) {
printf("Northbound Train %... | 0 |
#include <pthread.h>
static unsigned long event_get(struct usbip_device *ud)
{
unsigned long event;
pthread_mutex_lock(&ud->lock);
event = ud->event;
ud->event = 0;
pthread_mutex_unlock(&ud->lock);
return event;
}
static int event_handler(struct usbip_device *ud)
{
unsigned long event = ... | 1 |
#include <pthread.h>
char *c;
pthread_mutex_t *mutex;
pthread_cond_t *cond;
} ab_arguments_t;
void *mythread(void* arguments) {
ab_arguments_t *args = (ab_arguments_t*)arguments;
pthread_mutex_lock(args->mutex);
if (args->c[0] == 'B') {
pthread_cond_wait(args->cond, args->mutex);
... | 0 |
#include <pthread.h>
static INITIALIZE_PARSER pf_initialize_parser = 0;
static RELEASE_PARSER pf_release_parser = 0;
static PARSER_CONTROL_EVENT pf_parse_control_event = 0;
static PARSER_SERIAL_RECV pf_parse_serial_recv = 0;
static PARSER_CONNECT_RECV pf_parse_connect_recv = 0;
static void *g_... | 1 |
#include <pthread.h>
int bucket;
struct chunk_t *next;
} chunk_t;
static int is_init;
static pthread_mutex_t mem_lock;
static int alloc = 0;
static chunk_t *buckets[256];
static int
get_bucket(int size)
{
size += sizeof(chunk_t);
if (size <= 65536)
return (size + ... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
static int iTThreads = 2;
static int iRThreads = 1;
static int data1Value = 0;
static int data2Value = 0;
pthread_mutex_t *data1Lock;
pthread_mutex_t *data2Lock;
void lock(pthread_mutex_t *);
void unlock(pthread_mutex_t *);
void *funcA(vo... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
const char *msg = "Hello World";
{
char *data;
int len;
}pthread_data_t;
pthread_data_t d;
static void *thread_wait( void *argv)
{
printf("%s - start\\n", __func__);
... | 0 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
int cond_var=0;
void *hilo_dispara(void *data)
{
while(1) {
pthread_mutex_lock(&cond_mutex);
cond_var++;
pthread_mutex_unlock(&cond_mutex);
pthread_cond_s... | 1 |
#include <pthread.h>
sem_t block;
sem_t CountNum;
pthread_mutex_t mutex;
pthread_mutex_t mutex1;
int Count[64];
void *Con_Run(void *arg)
{
static int i=0;
while(1)
{
sleep(1);
pthread_mutex_lock(&mutex);
sem_wait(&CountNum);
printf("Con::%d\\n",Count[i]);
i++;
i%=64;
sem_post(&... | 0 |
#include <pthread.h>
static inline char receive_byte(void){
char gps_date = '\\0';
if(read(BDfd,&gps_date,1) == -1)
perror("Read Error:");
return gps_date;
}
inline void gps_receive(void)
{
char c,gps_type;
int i =0,j=0;
int timeout =30;
int obdtime = 0;
int sum = 0,gps_flag = 0;
ch... | 1 |
#include <pthread.h>
static pthread_t threadTickGenerator;
static pthread_t threadFIFO2DA[MAX_CHANNEL];
static pthread_mutex_t mutexTick[MAX_CHANNEL];
static pthread_cond_t condTick[MAX_CHANNEL];
int readAChar( int fifoFD )
{
char aChar;
int err = read( fifoFD , &aChar , 1);
if ( err ... | 0 |
#include <pthread.h>
volatile int cat_plays,dog_plays,bird_plays,cats,dogs,birds,n_cats,n_dogs,n_birds;
volatile int err;
struct monitor
{
pthread_mutex_t mutex;
pthread_cond_t is_occupied_cat;
pthread_cond_t is_occupied_dog;
pthread_cond_t is_occupied_bird;
};
MONITOR *monitorObj;
v... | 1 |
#include <pthread.h>
int get_id(void)
{
static int id = 59000;
int current_id = 0;
pthread_mutex_lock(&globals->id_lock);
current_id = id++;
pthread_mutex_unlock(&globals->id_lock);
return (current_id);
}
| 0 |
#include <pthread.h>
int row, col,total_threads;
double* mat;
double* vec;
double* result;
pthread_mutex_t pthread;
void *matrix_multiplication(void* rank) {
double t;
long local_rank = (long) rank;
int sz = row/total_threads;
int z=local_rank*sz*col;
int start_i = local_rank*sz... | 1 |
#include <pthread.h>
uint32_t inode[16];
uint32_t time[16];
uint8_t* path[16];
} hashbucket;
static hashbucket *symlinkhash = 0;
static pthread_mutex_t slcachelock = PTHREAD_MUTEX_INITIALIZER;
enum {
INSERTS = 0,
SEARCH_HITS,
SEARCH_MISSES,
LINKS,
STATNODES
};
static uint64_t *statspt... | 0 |
#include <pthread.h>
void *consumeTen();
void *consumeFifteen();
struct data
{
pthread_t threadID;
char name;
int pearlsTaken;
int *pearls;
};
int pearls = 1000;
pthread_mutex_t mutex;
pthread_cond_t full_cond;
pthread_cond_t empty_cond;
struct data threadData[4];
int main()
{
... | 1 |
#include <pthread.h>
static pthread_mutex_t astCount_lock;
static pthread_mutex_t first_lock;
static pthread_mutex_t second_lock;
static int astCount = 0;
void eventAst(void *arg, int len , char *buf ) {
printf("received event in thread %ld, name=%s\\n",
syscall(__NR_get... | 0 |
#include <pthread.h>
int map_minerals = 5000;
int minerals = 0;
int n = 0;
int m = 0;
int k = -1;
int command_centers_minerals[12] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
pthread_mutex_t mutex_workers;
pthread_mutex_t mutex_map_minerals;
pthread_mutex_t mutex_minerals;
pthrea... | 1 |
#include <pthread.h>
int g = 0;
pthread_mutex_t mutexsum;
void *myThreadFun(void *vargp)
{
int i = (int)vargp;
pthread_mutex_lock (&mutexsum);
printf("%i Global: %d\\n", i, ++g);
pthread_mutex_unlock (&mutexsum);
}
int threadCount(int num_threads)
{
int i;
pthread_t ti... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t mutex;
void* asyncFn(void* arg){
pthread_mutex_lock(&mutex);
printf("Hello!! %d\\n", count);
count++;
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
int main(int argc, const char* argv[]){
pthread_t tid[20];
pthr... | 1 |
#include <pthread.h>
void calcula_hash_senha(const char *senha, char *hash);
char* incrementa_senha(char *senha);
void* testa_senha (void *arg);
char hash_alvo[50];
char senha[1000][30];
} thread_arg, *ptr_thread_arg;
int num_pthread;
pthread_mutex_t bloqueio;
pthread_attr_t ttr;... | 0 |
#include <pthread.h>
pthread_mutex_t mt1, mt2;
int ok = 0;
void* first(void* param){
int i;
for(i =0 ; i<10 ;i++)
{
pthread_mutex_lock(&mt1);
printf("First thread: %d\\n", (int)pthread_self());
pthread_mutex_unlock(&mt2);
}
return 0;
}
void* second(void* param) {
int i;
for( i =... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int avail = 0;
static void *threadFunc(void *arg)
{
int cnt = *((int *)arg);
int j, ret;
for (j = 0; j < cnt; j++) {
pthread_mutex_lock(&mtx);
avai... | 0 |
#include <pthread.h>
static int noItemsToProduce = 10;
static int totalItemsToProduce = 100;
static int noItemsConsumed = 0;
static int done = 0;
static int queueEmpty = 0;
void *res;
static int *queueArray;
int front = 0;
int back = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
... | 1 |
#include <pthread.h>
extern FILE *fileout_basicmath_cubic;
extern pthread_mutex_t mutex_print;
int main_basicmath_cubic(void)
{
double a1 = 1.0, b1 = -10.5, c1 = 32.0, d1 = -30.0;
double a2 = 1.0, b2 = -4.5, c2 = 17.0, d2 = -30.0;
double a3 = 1.0, b3 = -3.5, c3 = 22.0, d3 = -31.0;
dou... | 0 |
#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(pthrea... | 1 |
#include <pthread.h>
static pthread_t thread;
static pthread_mutex_t delayMutex;
static int reading;
struct timespec delay;
static _Bool continueWatching = 1;
static void *watchPOT(void *args);
static struct timespec calculateDelay(void);
static const float PIECEWISE_READING[] = { 0, 500, 1000, ... | 0 |
#include <pthread.h>
int GLOBAL = 0;
int NB_AFFICHAGE = 0;
int NB_THREAD;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condFinAffichage = PTHREAD_COND_INITIALIZER;
void* attendre(void* arg) {
pthread_mutex_lock(&mutex);
while(NB_AFFICHAGE < NB_THREAD)
pthread_cond_wait(&c... | 1 |
#include <pthread.h>
int resource_count;
pthread_mutex_t resource_mutex;
void * handler()
{
while(1){
if (resource_count == 3)
pthread_mutex_unlock(&resource_mutex);
}
}
void * customer(void* arg)
{
int cust_no = *((int*)arg);
while(1){
if (resource_count>0)
{
resource_count--;
... | 0 |
#include <pthread.h>
static int uimled_uim_fd = -1;
static pthread_t uimled_uim_read_id = 0;
static char* uimled_uim_text = 0;
static pthread_mutex_t uimled_uim_text_mut = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t uimled_uim_text_cond = PTHREAD_COND_INITIALIZER;
void* uimled_uim_read_thre... | 1 |
#include <pthread.h>
int main_ConditionVariable();
static void* ConditionVariable_funcThread(void* a_pArg);
static void ConditionVariable_wait(int timeoutMs);
static int ConditionVariable_CreateThread();
static pthread_mutex_t m_mutex;
static pthread_cond_t mCondition;
static pthread_t vTreadID... | 0 |
#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) {
usleep(rand()%10000);
pthread_mutex_lock(& (pa... | 1 |
#include <pthread.h>
NEW,
PROCESSING,
DONE
}statuses;
int duration;
int id;
statuses status;
pthread_t worker;
} task_t;
pthread_mutex_t lock;
task_t tasks[100];
void* my_thread(void* var){
task_t * vart= (task_t*)var;
int frag = 0, k = vart->id;
long long unsigned worker =vart->wor... | 0 |
#include <pthread.h>
pthread_mutex_t console_mutex = PTHREAD_MUTEX_INITIALIZER;
int mallocNsetInt(int **toSet, int value) {
if((*toSet = (int *)malloc(sizeof(int))) != 0) {
**toSet = value;
return 0;
} else {
return 1;
}
}
int mtPrintf(const char* format, ...) {
va... | 1 |
#include <pthread.h>
int count[4];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t can_produce = PTHREAD_COND_INITIALIZER;
pthread_cond_t can_consume = PTHREAD_COND_INITIALIZER;
int buffer_len = 0;
char buffer[5000][1000 +1];
FILE *file;
int state = 0;
unsigned int total_count = ... | 0 |
#include <pthread.h>
int i = 0;
double x;
double y;
double z;
double acc;
double roll;
double pitch;
double yaw;
timespec_t time;
} attitude_t;
attitude_t attitude;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *read_attitude(void *ptr) {
... | 1 |
#include <pthread.h>
pthread_mutex_t rcv_list_mutex;
struct list_head rcv_list;
pthread_mutex_t snd_list_mutex;
struct list_head snd_list;
pthread_cond_t snd_cond;
pthread_cond_t rcv_cond;
extern int quit;
void *handle_snd_pkt(void *arg)
{
enter_func();
int i = 0;
while (!quit) {
pthread... | 0 |
#include <pthread.h>
pthread_mutex_t mt;
pthread_mutex_t wrt;
int readcount=0;
int val=0;
void *reader(int rn)
{
pthread_mutex_lock(&mt);
readcount++;
if(readcount==1)
pthread_mutex_lock(&wrt);
pthread_mutex_unlock(&mt);
printf("\\n==========================================\\n");
pr... | 1 |
#include <pthread.h>
void usage(){
fprintf(stderr,"Usage: ./make_threads <no_threads> <sum_up_to>\\n");
}
volatile unsigned long long global_sum;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
void * up_to_n(void *args){
int *n = args;
int i;
for (i =1 ; i <= *n; i++){
... | 0 |
#include <pthread.h>
int
pthread_setcanceltype (int type, int *oldtype)
{
struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
int newflags;
pthread_init();
switch (type)
{
default:
return EINVAL;
case PTHREAD_CANCEL_DEFERRED:
case PTHREAD_CANCEL... | 1 |
#include <pthread.h>
struct queue {
int *array;
int head;
int tail;
};
struct queue message_queue;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
sem_t message_count;
sem_t consumed_messages_count;
sem_t empty_space;
int producer_count;
int total_number_of_messages;
int message_queu... | 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 ret, signo;
for(;;)
{
ret = sigwait(&mask, &signo);
if(ret!=0)
{
perror("sigwait failed\\n");
exit(... | 1 |
#include <pthread.h>
struct foo * fh[29] = {0};
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 = (struct foo *... | 0 |
#include <pthread.h>
pthread_mutex_t main_chair, waiting_chair, checking_state;
pthread_mutex_t serving_chair;
int fre;
void *define_client(void* p){
printf("The client started\\n");
if(pthread_mutex_trylock(&main_chair) == 0){
printf("The barber is sleeping\\n");
pthread_mutex_unlock(&... | 1 |
#include <pthread.h>
{
unsigned char r;
unsigned char g;
unsigned char b;
} rgb;
{
double r;
double i;
} complex;
rgb * rtex;
int w;
int h;
complex center;
double scale;
int startiter;
int enditer;
int maxiter;
double er;
double eg;
double eb;
int renderworking = 0;
int rend... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t limite, verifica;
int counter=0;
int vetor[100];
void* imprime(void* p){
int i;
while(1){
pthread_mutex_lock(&mutex);
if(!counter || counter%10!=0){
printf("-------- AGUARDANDO ADICIONAR\\n");
pthread_cond_wait(&verifica,... | 1 |
#include <pthread.h>
struct node *next;
int refcount;
char *str;
} Node;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static Node *hashTable[32767] = {0};
static unsigned int hash(char *s) {
unsigned int ans = 0;
while (*s != '\\0')
ans = 101 * ans + *s... | 0 |
#include <pthread.h>
static pthread_t lslogging_thread;
static pthread_mutex_t lslogging_mutex;
static pthread_cond_t lslogging_cond;
static FILE *lslogging_file;
struct timespec ltime;
char lmsg[2048];
} lslogging_queue_t;
static lslogging_queue_t lslogging_queue[8192];
s... | 1 |
#include <pthread.h>
int count;
int pending_posts;
} sem_t;
sem_t sem_producer;
sem_t sem_consumer;
pthread_mutex_t mut_buf = {0,0};
pthread_mutex_t mut = {0,0};
pthread_mutex_t mutp = {0,0};
void sem_init(sem_t *sem, int pshared, unsigned int value) {
sem->count = value;
sem-... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.