text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
void * watek_klient (void * arg);
int l_kf;
pthread_mutex_t mutex_kf, mutex_kr;
main(){
pthread_t *tab_klient;
int *tab_klient_id;
int l_kl, l_kr, i;
pthread_mutex_init(&mutex_kf, 0);
pthread_mutex_init(&mutex_kr, 0);
printf("\\nLiczba klientow: "); scanf("%d... | 1 |
#include <pthread.h>
int tests_run = 0;
int threadpool_should_be_initialized(void);
int task_should_be_submitted(void);
static void *test_thread_func(void *arg);
static uint16_t task_processed = 32;
static pthread_mutex_t task_processed_mutex;
static pthread_cond_t task_processed_cv;
int t... | 0 |
#include <pthread.h>
void *philosopher(void *);
void think(int);
void pickUp(int);
void eat(int);
void putDown(int);
pthread_mutex_t chopsticks[5];
pthread_t philosophers[5];
pthread_attr_t attributes[5];
int main() {
int i;
srand(time(0));
for (i = 0; i < 5; ++i) {
pthread_mutex_init(&ch... | 1 |
#include <pthread.h>
struct resend_queue *firefly_resend_queue_new()
{
struct resend_queue *rq;
rq = malloc(sizeof(*rq));
if (rq) {
rq->next_id = 1;
rq->first = 0;
rq->last = 0;
pthread_cond_init(&rq->sig, 0);
pthread_mutex_init(&rq->lock, 0);
}
return rq;
}
void firefly_res... | 0 |
#include <pthread.h>
struct producers
{
int buffer[4];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct producers *b)
{
pthread_mutex_init(&b->lock,0);
pthread_cond_init(&b->n... | 1 |
#include <pthread.h>
extern int identifier;
extern int SPF_INTERVAL;
extern int NUMBER_OF_ROUTERS;
extern int MAX_POSSIBLE_DIST;
extern int*** every_node_lsa_details;
extern int* every_node_neighbors;
extern int NUMBER_OF_NEIGHBORS;
extern int** actual_link_costs;
extern FILE* ofp;
extern char out... | 0 |
#include <pthread.h>
void SayiUret();
void *Siralama(void *parametre);
void *Birlesme(void *parametre);
void ThreadYarat();
void DosyayaYaz();
pthread_mutex_t lock;
int liste[1000];
int sonuc[1000];
FILE *dosya;
{
int baslangic;
int bitis;
} parametreler;
int main (int argc, const c... | 1 |
#include <pthread.h>
{
int value;
struct cell *next;
}
*cell;
{
int length;
cell first;
cell last;
}
*list;
list add (int v, list l)
{
cell c = (cell) malloc (sizeof (struct cell));
c->value = v;
c->next = 0;
if (l == 0){
l = (list) malloc (sizeof (struct list)... | 0 |
#include <pthread.h>
char *
strtok(s, delim)
register char *s;
register const char *delim;
{
static pthread_mutex_t strtok_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_key_t strtok_key = -1;
char **lasts;
pthread_mutex_lock(&strtok_mutex);
if (strtok_key < 0) {
if (pthread_key_creat... | 1 |
#include <pthread.h>
int MaxLoop = 50000;
int NumProcs;
volatile int startCounter;
pthread_mutex_t threadLock;
unsigned sig[33] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31... | 0 |
#include <pthread.h>
int stoj = 0;
int zameranie[4] = {0, 0, 1, 1};
int pocetVypisov[4] = {0};
int cakaju = 0;
int vsetciCakaju = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condCakaju = PTHREAD_COND_INITIALIZER;
void hadz(int murar) {
pthread_mutex_l... | 1 |
#include <pthread.h>
int PBSD_manager(
int c,
int function,
int command,
int objtype,
char *objname,
struct attropl *aoplp,
char *extend,
int *local_errno)
{
int rc;
struct batch_reply *reply;
rc = PBSD_mgr_put(
c,
function,
command,
... | 0 |
#include <pthread.h>
void *thread_function(void *);
pthread_mutex_t mutex1;
int counter = 0;
main() {
pthread_mutex_init(&mutex1, 0);
pthread_t thread_id[10];
int i, j;
printf("EBUSY:%d", EBUSY);
for (i = 0; i < 10; i++) {
pthread_create(&thread_id[i], 0, thread_function, 0);
}
for... | 1 |
#include <pthread.h>
int graph[100][100];
int dist[100][100];
int n,m;
int k;
pthread_mutex_t read_mutex;
pthread_mutex_t write_mutex;
int readers = 0;
int checker;
void *check_func(void *t)
{
long i = (long)t;
for(int j=0;j<n;j++)
{
pthread_mutex_lock(&read_mutex);
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
volatile int eR1 = 1;
volatile int eR2 = 0;
void* travail(void* _num){
int ressource;
pthread_mutex_lock(&mutex);
while (!eR1 && !eR2) {
pthread_co... | 1 |
#include <pthread.h>
static pthread_mutex_t s_mutex;
static void cleanup_handler(void* param)
{
fprintf(stderr, "Cleanup handler has been called.\\n");
pthread_mutex_unlock(&s_mutex);
}
static void* f(void *p)
{
if (pthread_mutex_lock(&s_mutex) != 0)
{
fprintf(stderr, "pthrea... | 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_t... | 1 |
#include <pthread.h>
int done;
pthread_cond_t *conds;
pthread_mutex_t *mtxs;
void *f( void *p )
{
long i = (long)p;
pthread_mutex_lock( &mtxs[i] );
while( !done )
{
pthread_cond_wait( &conds[i], &mtxs[i] );
}
pthread_mutex_unlock( &mtxs[i] );
}
int main( int argc,... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
pthread_mutex_t mutexsum;
DOTDATA dotstr;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
len = dotstr.veclen;
start =... | 1 |
#include <pthread.h>
enum log_level {
DEBUG = 0,
INFO = 1,
ERROR = 2
};
pthread_t tid[1];
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int g_isRunning = 1;
int g_logLevel = DEBUG;
struct mpd_connection *conn;
void
INT_handler(){
g_isRunning = 0;
}
void
log_message(int level, char... | 0 |
#include <pthread.h>
int nitems;
struct
{
pthread_mutex_t mutex;
int buff[100000];
int nput;
int nval;
}shared = {PTHREAD_MUTEX_INITIALIZER};
void *produce(void *);
void *consume(void *);
int main(int argc, char const *argv[])
{
int i,nthreads,count[100];
pthread_t tid_produce[100],t... | 1 |
#include <pthread.h>
void eroare (int check, char* mesaj) {
if (check < 0) {
printf("%s\\n", mesaj);
exit(1);
}
}
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
char sir[105];
int len = 0;
int checkSolve(){
if (strstr(sir,"succes"))
return 1;
return 0;
}
void* deservireClient(void*... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *pthread_fun(void *arg)
{
void *ret;
int i;
int j;
pthread_mutex_lock(&mutex);
for(j = 0; j < 3; j++)
{
if(0 == (int)arg)
{
printf("thread %d is working.\\n", (int)arg);
sleep(1);
}
else if(1 == (int)arg)
{
printf("thre... | 1 |
#include <pthread.h>
static int top=0;
static unsigned int arr[(6)];
pthread_mutex_t m;
int flag=(0);
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(void)
{
return top;
}
int stack_empty(void)
{
(top==0) ? (1) : (0);
}
int push(unsigned int *stack, int x... | 0 |
#include <pthread.h>
struct servent *getservbyname(const char *name, const char *proto)
{
char *buf = _serv_buf();
if (!buf)
return 0;
return getservbyname_r(name, proto, (struct servent *) buf,
buf + sizeof(struct servent), SERV_BUFSIZE);
}
struct servent *getservbyname_r(const ch... | 1 |
#include <pthread.h>
struct screen_gtk_t {
const struct screen_ops_t *ops;
pthread_t thread;
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int ev;
} event;
};
static void *screen_gtk_thread(void *parm);
static struct screen_t *screen_gtk_new(int *argcp, char **argv)
{... | 0 |
#include <pthread.h>
struct Seller* createSeller(char priority, int ordinal, struct BuyerQueue* bqs, struct Seatmap* map)
{
struct Seller* s = (struct Seller*)malloc(sizeof(struct Seller));
s->priority = priority;
s->ordinal = ordinal;
s->q = bqs;
strcat(s->name, &s->priority);
char cord[2... | 1 |
#include <pthread.h>
struct circqueue {
unsigned int head;
unsigned int tail;
unsigned int count;
unsigned int max_entries;
unsigned int array_elements;
void **entries;
};
struct event_mq {
int push_fd;
int pop_fd;
int unlock_between_callbacks;
struct event qu... | 0 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
void *thread1(void *args)
{
pthread_mutex_lock(&m1);
sleep(1);
pthread_mutex_lock(&m2);
pthread_mutex_unlock(&m1);
pthread_mutex_unlock(&m2)... | 1 |
#include <pthread.h>
int mutex_get_int(pthread_mutex_t *mutex, int *i)
{
int ret;
pthread_mutex_lock(mutex);
ret = *i;
pthread_mutex_unlock(mutex);
return (ret);
}
| 0 |
#include <pthread.h>
char* key;
char* value;
size_t value_len;
struct hash_item** pprev;
struct hash_item* next;
} hash_item;
hash_item* hash[1024];
pthread_mutex_t hash_mutex[1024];
hash_item* hash_get(const char* key, int create) {
unsigned b = string_hash(key) % 1024... | 1 |
#include <pthread.h>
int fibonacci(int);
int factorial(int);
int greater(int);
int less(int);
void * parallel_kernel(void * arg);
int (*function)(int);
int result;
} Register;
struct repository {
Register * registers;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int SHAR... | 0 |
#include <pthread.h>
int available[3];
int maximum[5][3];
int allocation[5][3];
int need[5][3];
pthread_mutex_t mutex;
void sleep_rand(void) {
sleep(rand() % 5 + 1);
}
int is_safe(void) {
int work[3], finish[5], i, j;
for (i = 0; i < 3; i++) {
work[i] = available[i];
}
for (i = 0... | 1 |
#include <pthread.h>
sem_t tofu, bread, BBQSauce, agent_semaphore, tofu_semaphore, bread_semaphore, BBQSauce_semaphore;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int loaves = 0, bottles = 0, tofu_blocks = 0;
void eat_sandwich(void) {
sleep(4);
}
void *bread_baker(void *_ ) {
while (1)... | 0 |
#include <pthread.h>
int nthreads = 4;
char buffer[10000000][40];
int b = 20;
int iProduced = 0;
int iConsumed = 0;
pthread_mutex_t mutexP[4] = {PTHREAD_MUTEX_INITIALIZER};
int bufferSize;
int count[4] = {0};
int max = 0;
char *key;
int count;
struct word *next;
} word;
word* linkedListArra... | 1 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
} *A, *B;
void init (struct s *p, int x) {
p -> datum = x;
p -> next = 0;
}
pthread_mutex_t A_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t B_mutex = PTHREAD_MUTEX_INITIALIZER;
void *t_fun(void *arg) {
pthread_mutex_lock... | 0 |
#include <pthread.h>
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_priority = priority;
return pthread_setschedparam(pthread_self(), policy, ¶m);
}... | 1 |
#include <pthread.h>
static long seed = 123456789;
double dt, dt_old;
double Random(void)
{
const long Q = 2147483647 / 48271;
const long R = 2147483647 % 48271;
long t;
t = 48271 * (seed % Q) - R * (seed / Q);
if (t > 0)
seed = t;
else
seed = t + 2147483647;
retu... | 0 |
#include <pthread.h>
struct file
{
int f_fd;
int f_flags;
pthread_t f_tid;
}file[1 +2];
struct thread_args
{
struct file *fptr;
struct SMAP* map;
};
void stop_thr(struct file *fptr);
void *getmap(void *argv);
void *insert_map(void *argv);
void *del_map(void *argv);
int ndone;
pthread_mutex_... | 1 |
#include <pthread.h>
int estado_filosofo[5];
int palillo[5];
pthread_mutex_t mutex;
pthread_cond_t espera[5];
char comiendo[] = "comiendo";
char pensando[] = "pensando";
char esperando[] = "esperando";
char *estado(int i)
{
if(i == 0)
return pensando;
if(i == 1)
return esperando;
if(i =... | 0 |
#include <pthread.h>
struct x11_state {
Display *display;
pthread_mutex_t lock;
int display_opened_here;
int ref_num;
bool initialized;
};
struct x11_state *get_state(void);
struct x11_state *get_state() {
struct x11_state *state;
rm_... | 1 |
#include <pthread.h>
struct BO_ITEM_FIFO_OUT {
char ip[16];
char val[BO_FIFO_ITEM_VAL];
int size;
};
static struct FIFO {
int itemN;
struct BO_ITEM_FIFO_OUT *mem;
int head;
int tail;
int last;
int count;
int free;
} fifo = {0};
static int bo_getPos_fifo_out(char *ip);
static pthre... | 0 |
#include <pthread.h>
pthread_attr_t attr;
pthread_mutex_t stdout_lock, fileout_lock;
struct Node {
Node *next;
char *data;
};
Node *stdout_tail, *stdout_head;
Node *fileout_tail, *fileout_head;
bool finished_reading = 0;
void print_and_free_node(Node *node) {
if(node->data ... | 1 |
#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,thread2,(void*)0);
pthread_create(&... | 0 |
#include <pthread.h>
void
_libc_private_storage_lock(mutex)
pthread_mutex_t *mutex;
{
if (__isthreaded && pthread_mutex_lock(mutex) != 0)
PANIC("_libc_private_storage_lock");
}
void
_libc_private_storage_unlock(mutex)
pthread_mutex_t *mutex;
{
if (__isthreaded && pthrea... | 1 |
#include <pthread.h>
sig_atomic_t directions[N_PLAYERS] = {RIGHT, LEFT};
sem_t can_we_play[N_PLAYERS];
sem_t can_continue;
pthread_t threads[N_PLAYERS+2];
struct key_map
{
int player;
int key;
sig_atomic_t direction;
};
const struct key_map mapping[] = {
{1, 'w', UP},
{1, 's', DOWN},
{1... | 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( &thread2, 0, &functionCount2, 0);
pt... | 1 |
#include <pthread.h>
int sum = 0;
pthread_cond_t slots = PTHREAD_COND_INITIALIZER;
pthread_cond_t items = PTHREAD_COND_INITIALIZER;
pthread_mutex_t slot_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t item_lock = PTHREAD_MUTEX_INITIALIZER;
int nslots = 8;
int producer_done = 0;
int nitems =... | 0 |
#include <pthread.h>
struct TErrNode {
struct TErrNode *next;
pthread_t thread;
size_t used;
size_t size;
struct LineInfo {
char file[64];
char function[64];
size_t line;
} *stack;
} ;
static struct TErrNode *top = 0;
static pthread_mutex_t mutex;
static struct TErrNode ... | 1 |
#include <pthread.h>
struct queue* new_queue(size_t capacity, int mt) {
struct queue* queue = xmalloc(sizeof(struct queue));
queue->capacity = capacity;
queue->data = xmalloc((capacity == 0 ? 1 : capacity) * sizeof(void*));
queue->rc = capacity == 0 ? 1 : 0;
queue->start = 0;
queue->... | 0 |
#include <pthread.h>
const int thread_count = 20;
int item;
pthread_cond_t produce_ok, consume_ok;
pthread_mutex_t mutex;
int consumed_array[20];
int consumed = 20 -1;
int produced = 0;
unsigned int seed;
void* thread_work(void* rank);
int main(int argc, char *argv[])
{
long thread;
pth... | 1 |
#include <pthread.h>
void *wolfThread(){
int i;
int color[3] = {0xFF1F05,0xAF2A00,0xDF3800};
int setcolor;
int lednum = 0;
int ledcolor = 0;
int sleeptime = 1;
int sleepmin = 2000000;
int sleepmax = 3000000;
for(i=0;i<(LEDANZ-1);i=i+2){
setcolor = color[rand()%3];
setLED(i,setcolo... | 0 |
#include <pthread.h>
pthread_mutex_t mx;
int x=0;
void *thread1() {
pthread_mutex_lock(&mx);
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=x+1;
x=... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void enter_main_lock()
{
pthread_mutex_lock(&mutex);
}
void worker_enter_main_lock()
{
pthread_mutex_lock(&mutex);
}
int worker_try_enter_main_lock()
{
if(!pthread_mutex_trylock(&mutex))
return 1;
else
return 0;
}
void leave_main_lock(... | 0 |
#include <pthread.h>
int start;
int len;
char* a;
int n;
pthread_mutex_t* mutex;
} thr_struct;
void* thr_func(void* arg) {
int start = ((thr_struct*)arg)->start;
char* a = ((thr_struct*)arg)->a;
int n = ((thr_struct*)arg)->n;
pthread_mutex_t* mutex = ((thr_s... | 1 |
#include <pthread.h>
pthread_mutex_t recordlock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t recordcon=PTHREAD_COND_INITIALIZER;
int readr=0,writer=0;
int *record;
struct nodeInfo *array;
pthread_barrier_t barrier;
char *filename;
char *path;
int scale;
int filesize;
char *recordpath;
int recordfil... | 0 |
#include <pthread.h>
pthread_mutex_t m_start;
pthread_cond_t start_info_updater;
int task_type;
unsigned int task_value;
pthread_mutex_t m_result;
pthread_cond_t result_info_updater;
unsigned long long result;
int task_completet;
unsigned long long calc_factorial(unsigned what){
unsigned l... | 1 |
#include <pthread.h>
{
long int timeout;
void *(*func)(void*);
void *arg;
} timeout_func_t;
static pthread_mutex_t mutex;
static void register_timeout(timeout_func_t *func)
{
pthread_t thid;
struct timespec spec = {0};
clock_gettime(CLOCK_REALTIME, &spec);
spec.tv_... | 0 |
#include <pthread.h>
int evict_time = 2;
void evict_from_cache(struct file_cache* cache){
pthread_mutex_lock(&(cache->fc_mutex_lock));
int free_files = cache->max_entries - (cache->num_files_pinned_dirty + cache->num_files_pinned_clean + cache->num_files_unpinned_clea... | 1 |
#include <pthread.h>
void pickup(int j);
void putdown(int i);
void test(int k);
void philosopher(int * id);
pthread_mutex_t lock;
char state[50];
pthread_cond_t self;
int num_phil;
int main(int argc,char *argv[]){
int n, *who;
pthread_t phils[50];
void * retval;
if(argc != 2) {
... | 0 |
#include <pthread.h>
void *Producer();
void *Consumer();
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 1;
int numIters;
int main(int argc, char **argv) {
double begin, end, time_spent;
begin = clock();
pthread_t pid, cid;
numIters = atoi(argv[1]);
pthre... | 1 |
#include <pthread.h>
struct propset {
char *str;
int row;
int col;
int delay;
int dir;
int vert;
int prevr;
};
pthread_mutex_t myLock = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, const char *argv[])
{
void *animate(void *);
int setup(int, char **, struct ... | 0 |
#include <pthread.h>
int _RW = 0;
pthread_mutex_t clk_mtx;
pthread_cond_t pulse;
pthread_mutex_t pause_mtx = PTHREAD_MUTEX_INITIALIZER;
void init();
void shutdown_cpu();
void pause_cpu();
void *cpu_clock(void *arg);
void disp__IWRF();
int main(int argc, char **argv)
{
FILE *stderr_out;
... | 1 |
#include <pthread.h>
int ret_count;
void *producer (void *args);
void *consumer (void *args);
int buf[10];
long head, tail;
int full, empty;
pthread_mutex_t *mut;
pthread_cond_t *notFull, *notEmpty;
} queue;
queue *queueInit (void);
void queueDelete (queue *q);
v... | 0 |
#include <pthread.h>
void
netfs_nrele (struct node *np)
{
struct references result;
int locked = FALSE;
refcounts_demote (&np->refcounts, &result);
if (result.hard == 0)
{
pthread_mutex_lock (&np->lock);
netfs_try_dropping_softrefs (np);
locked = TRUE;
}
refc... | 1 |
#include <pthread.h>
struct LOGUTIL_THREAD *pnext;
pthread_t tid;
char tag[LOGUTIL_TAG_LENGTH];
} LOGUTIL_THREAD_T;
LOGUTIL_THREAD_T arr[64];
LOGUTIL_THREAD_T *tids_free;
LOGUTIL_THREAD_T *tids;
pthread_mutex_t mtx;
} LOGUTIL_THREAD_CTXT_T;
static LOGUTIL_THREAD_CTXT_T _g_logut... | 0 |
#include <pthread.h>
struct timeval start, end;
long mtime, seconds, useconds;
pthread_mutex_t mutex;
pthread_cond_t waitBarber;
pthread_cond_t waitCustomers;
pthread_cond_t waitCutting;
int waiting = 0;
int customer_cutting;
void cutHair() {
pthread_cond_wait(&waitCutting,&mutex);
pthread_... | 1 |
#include <pthread.h>
double suma;
pracuji,
ukoncen,
prazdne
}stavVlakna;
int dejVolnyIndexZeSeznamu(stavVlakna* stavyVlaken,int size);
int pridejVlaknoDoSeznamu(stavVlakna* stavyVlaken,pthread_t** vlakna,pthread_t* vlakno, int size, int indexVlakna);
void inicializujSeznam(stavVlakna* stavyV... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t can_write = PTHREAD_COND_INITIALIZER;
pthread_cond_t can_read = PTHREAD_COND_INITIALIZER;
char arr[10] = {0};
int in_pos = 0;
int out_pos = 0;
void* do_it_a(void* p)
{
char c = 'a';
for(; c <= 'z'; c++)
{
... | 1 |
#include <pthread.h>
double start_time, end_time;
long size;
int *inputArray;
int size;
struct thread_data nextTask;
} thread_data;
thread_data * nextTaskInLine;
void *quickSort(void *);
void swap(int *inputArray, int leftIndex, int rightIndex);
double read_timer();
thread_data m... | 0 |
#include <pthread.h>
pthread_mutex_t mutexOne;
pthread_mutex_t mutexTwo;
void *lockMutexOne(void *args)
{
pthread_mutex_lock(&mutexOne);
sleep(1);
pthread_mutex_lock(&mutexTwo);
pthread_mutex_unlock(&mutexOne);
pthread_mutex_unlock(&mutexTwo);
return 1;
}
void *lockMutexTwo(void *args)... | 1 |
#include <pthread.h>
long thread_count;
long long n;
double sum;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double Serial_pi(long long n);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handl... | 0 |
#include <pthread.h>
int sharedvar;
int count = 0;
pthread_mutex_t sumlock;
pthread_mutex_t countlock;
void simplethread(int argc, char** argv)
{
int numthreads = parseargs(argc, argv);
int i;
pthread_t * pthreads = malloc(sizeof(pthread_t) * numthreads);
for(i = 0 ; i < numthreads ; i++... | 1 |
#include <pthread.h>
int b[10];
int cont = 0;
pthread_cond_t prod_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cons_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mp = PTHREAD_MUTEX_INITIALIZER;
int prod_pos = 0;
int cons_pos = 0;
void * produtor(void * arg){
while(1){
printf... | 0 |
#include <pthread.h>
int x = 0;
pthread_mutex_t x_mutex;
pthread_cond_t x_cond;
void *A (void *t) {
int i; int my_id = (int)t;
int boba1, boba2;
printf("A: Comecei: thread %d\\n", my_id);
for (i=0; i < 10; i++) {
printf("A: thread %d vai pedir mutex\\n", my_id);
pthre... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t more_pizza = PTHREAD_COND_INITIALIZER;
pthread_cond_t pizza_available = PTHREAD_COND_INITIALIZER;
int size = 0;
void* all_night_long_pizza(void *arg) {
int slices;
slices = *( (int *) arg );
printf("A... | 0 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void pthread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthre... | 1 |
#include <pthread.h>
static void thread_create(pthread_t *tid,void *(*fun)(void *));
static void thread_wait(pthread_t tid);
void * fun1(void *arg);
void * fun2(void *arg);
pthread_mutex_t lock;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int sum = 0;
int main(int argc, char const *argv[]... | 0 |
#include <pthread.h>
pthread_cond_t condQEmpty, condQFull;
pthread_mutex_t taskQCondLock;
int taskAvailable, tasksCount, tasksFinished;
void* producer(void*);
void* consumer(void*);
int main(int argc, char **argv) {
int i;
int numThreads;
int* data = (int*) 0;
pthread_t pThreads[5... | 1 |
#include <pthread.h>
void xerror(const char *msg);
static void *thread_main(void *arg);
static void thread_cleanup(void *arg);
{
int thread_num;
FILE *fp;
} thread_info;
static pthread_t threadId[10];
static pthread_mutex_t threadMutex[10];
static thread_info *threadInfo;
int m... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void default_http_response(const int client_sockfd, const char * msg)
{
static char outbuf[out_to_browser_buf_size] = { 0 };
static char method[accept_method_buf_size] = { 0 };
static char url[accept_url_buf_si... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
int flag = 1;
void *thread1 (void *arg);
void *thread2 (void *arg);
void *thread3 (void *arg);
void *thread1 (void *arg)
{
int ret;
pthread_t th;
(void) arg;
ret = pthread_create (&th, 0, thread3, 0);
pth... | 0 |
#include <pthread.h>
{
struct D_CRITICAL_SECTION *next;
pthread_mutex_t cs;
} D_CRITICAL_SECTION;
static D_CRITICAL_SECTION *dcs_list;
static D_CRITICAL_SECTION critical_section;
static pthread_mutexattr_t _criticals_attr;
void _STI_critical_init(void);
void _STD_critical_term(void);
voi... | 1 |
#include <pthread.h>
int table[128];
pthread_mutex_t cas_mutex[128];
pthread_t tids[13];
int cas(int * tab, int h, int val, int new_val)
{
int ret_val = 0;
pthread_mutex_lock(&cas_mutex[h]);
if ( tab[h] == val ) {
tab[h] = new_val;
ret_val = 1;
}
pthread_mutex_unlock(&c... | 0 |
#include <pthread.h>
pthread_mutex_t cupcake_mutex;
pthread_mutex_t donut_mutex;
int cupcakes = 1;
int donuts = 1;
void removeCupcake(){
pthread_mutex_lock(&cupcake_mutex);
printf("A customer purchases a cupcake.\\n");
printf("The number of cupcakes was %d\\n", cupcakes);
cupcakes = cupca... | 1 |
#include <pthread.h>
struct workqueue
{
int item[64];
int idx;
int cnt;
pthread_mutex_t mutex;
pthread_cond_t cv;
} *wq;
void *tfunc_a(void *);
void *tfunc_b(void *);
void *start_sigthread(void *);
struct thread_arg
{
pthread_t tid;
int idx;
void *(*func)(void *);
} t_arg[10] = {
{ ... | 0 |
#include <pthread.h>
struct job{
double data;
struct job* next;
};
struct job* job_queue;
unsigned int job_queue_count;
pthread_mutex_t job_queue_count_mutex;
pthread_mutex_t job_queue_mutex;
pthread_cond_t pcond_var;
void initialize_vars()
{
job_queue_count = 0 ;
pthread_mutex_init... | 1 |
#include <pthread.h>
int aleatorio (int range, int teste)
{
int x;
if (teste)
{
while (range < 2)
{
printf("função random: o range %d passado é inválido, por favor digite um valor < 2 para range:\\n", range);
scanf("%d", &range);
}
}
else if (range < 2)
{
range = 10;
}
whi... | 0 |
#include <pthread.h>
pthread_attr_t thrd_attr;
pthread_mutex_t mtx_one;
pthread_mutex_t mtx_two;
pthread_cond_t cnd_one;
pthread_cond_t cnd_two;
int one_run, two_run;
int tmp_cnt;
int main_started;
void message_handler(const char *str);
void init();
void uninit();
void * agent_one(void *ar... | 1 |
#include <pthread.h>
static pthread_cond_t *cv = 0;
static pthread_mutex_t *mutex = 0;
static volatile long solution = 0;
static volatile int resources_available = 0;
static volatile int cv_hits = 0;
static void print_solution() {
printf("Solution is: %ld\\n", solution);
}
static void in... | 0 |
#include <pthread.h>
int ring[128];
sem_t sem_space;
sem_t sem_data;
pthread_mutex_t pro_lock;
pthread_mutex_t con_lock;
void* product(void* arg)
{
int index = 0;
while (1)
{
sem_wait(&sem_space);
int val = rand() % 100;
pthread_mutex_lock(&pro_lock);
ring[index++] = val;
pthrea... | 1 |
#include <pthread.h>
int q[4];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 4)
... | 0 |
#include <pthread.h>
int global_value = 0;
pthread_mutex_t global_value_mutex;
void *t1_main(void *arg);
void *t2_main(void *arg);
int main(int argc, char **argv)
{
pthread_t t1, t2;
int code;
pthread_mutex_init(&global_value_mutex, 0);
code = pthread_create(&t1, 0, t1_main, 0)... | 1 |
#include <pthread.h>
pthread_mutex_t * ssl_locks;
int ssl_num_locks;
static unsigned long
get_thread_id_cb(void)
{
return (unsigned long)pthread_self();
}
static void
thread_lock_cb(int mode, int which, const char * f, int l)
{
if (which < ssl_num_locks) {
if (mode & CRYPT... | 0 |
#include <pthread.h>
{
WDOG_IDLE,
WDOG_BUSY,
WDOG_DESTROY,
} dog_stat_t;
{
pthread_t thread_loop;
pthread_mutex_t cmd_mutex;
dog_stat_t stat;
int snap_cnt;
long long last_tickle_time;
char last_tickle_info[128];
} dog_t;
static void *watch_dog_loop(void *para... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_cond_t go;
int numWorkers;
int numArrived = 0;
struct Partial {
int value[10];
int column[10];
int row[10];
};
void Barrier() {
pthread_mutex_lock(&barrier);
numArrived++;
if (numArrived == numWorkers) {
numArrived = 0;
p... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students = 0;
int ta_asleep = 0;
int seeds[5] = {12315, 36462, 63252, 87273, 21573};
pthread_t student_threads[4];
pthread_t ta_thread_ptr;
void *student_thread(void *num);
void *ta_thread(void *sta... | 1 |
#include <pthread.h>
int queue[50];
int rear=-1;
int front=-1;
pthread_mutex_t m;
void *insert()
{
int num,i;
if (rear==50 -1)
printf("Queue Overflow \\n");
else
{
if(front==-1)
front=0;
for(i=0;i<49;i++)
{
queue[rear]=i;
rear=rear+1;
... | 0 |
#include <pthread.h>
extern unsigned char dev_led_mask;
extern int dev_led_fd;
extern pthread_mutex_t mutex_led;
extern pthread_cond_t cond_led;
void *pthread_led (void *arg)
{
int led_no;
char * buff = 0;
unsigned char led_set;
if ((dev_led_fd = open ("/sys/class/leds/led2/brightnes... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int y;
void *inc_x(void *x_void_ptr)
{
int *x_pt = (int *)x_void_ptr;
while(y < 10000) {
pthread_mutex_lock(&mutex);
if(y < 10000) {
y++;
}
pthread_mutex_unlock(&mutex);
}
return 0;
}
in... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.