text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static struct list_node **list_head;
static struct list_node **free_head;
static pthread_mutex_t *mutex;
long value;
struct list_node *next;
}list_node;
static struct list_node **list_head;
static struct list_node **free_head;
static pthread_mutex_t *mutex;
void ... | 1 |
#include <pthread.h>
int init_sockets()
{
return 0;
}
void done_sockets()
{
}
int get_last_socket_error()
{
return get_errno();
}
static char socket_error_buf[1024];
static pthread_mutex_t socket_error_buf_lock = PTHREAD_MUTEX_INITIALIZER;
void begin_get_socket_er... | 0 |
#include <pthread.h>
int run = 1;
int chopsticks[5] = {0 ,0 ,0 ,0 ,0};
pthread_mutex_t mutex ,mutexc;
pthread_cond_t cond[5];
void roundtime() {
sleep(30);
pthread_mutex_lock(&mutex);
run = 0;
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
void philosophers(int *id) {
int i = *id;
whil... | 1 |
#include <pthread.h>
int fd_pwm,fd_pwm2;
int fd_setpin;
int server_sockfd, client_sockfd;
char *server_ip;
char global_buf[50];
unsigned int global_buf_len;
unsigned int flag_buf=0;
unsigned int flag_new_data=0;
unsigned int flag_socket=0;
int pwm[2];
int pwm_qian=10;
pthread_mutex_t lock_p... | 0 |
#include <pthread.h>
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
int gArr[16];
void *produce();
void *consume();
pthread_t tid;
pthread_attr_t attr;
int size;
int tNum;
int counter;
}Producers;
pthread_t tid;
pthread_attr_t attr;
int size;
}Consumers;
int main(int... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
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 = ... | 0 |
#include <pthread.h>
void Qaullib_Msg_LL_Init (void)
{
qaul_msg_LL_first = 0;
}
int Qaullib_Msg_LL_FirstItem (struct qaul_msg_LL_node *node, int id)
{
int count, max_count;
if(id == 0)
max_count = MAX_MSG_FIRST;
else
max_count = MAX_MSG_COUNT;
if(qaul_msg_LL_first == 0 || qaul_... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int n = 200000000;
void *func(void *data)
{
int i=2;
int flag=0;
int num=0;
while(1)
{
flag=0;
pthread_mutex_lock(&lock);
num=n;
if(n==200000401)
{
pthre... | 0 |
#include <pthread.h>
char keys[242][20];
FILE *data;
pthread_mutex_t mutex;
void print_stamp(){
time_t now;
char *ti = (char *)malloc(100);
time(&now);
strcpy(ti, (char *)ctime(&now));
ti[strlen(ti) - 1] = '\\0';
pthread_mutex_lock(&mutex);
fprintf(data, "\\n%s : ", ti);
fflush(dat... | 1 |
#include <pthread.h>
int32_t rpicamera_logger(int32_t log_level, const char *format, ...){
va_list args;
int32_t status = 0;
__builtin_va_start((args));
pthread_mutex_lock(&logging_mutex);
status = vsprintf(RPICAMERA_MODULE_LOGGER_MSG, format, args);
;
if (status < ... | 0 |
#include <pthread.h>
int myglobal = 0;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_function(void *arg) {
int i;
for ( i=0; i<20; i++ ) {
pthread_mutex_lock(&mymutex);
myglobal++;
printf(".");
fflush(stdout);
sleep(1);
pthread_mutex_unlock(&mymutex);
}... | 1 |
#include <pthread.h>
int buffer[8];
int bufin = 0;
int bufout = 0;
pthread_mutex_t buffer_lock = PTHREAD_MUTEX_INITIALIZER;
unsigned int sum = 0;
sem_t hay_datos;
sem_t hay_sitio;
void obten_dato(int *itemp)
{
*itemp = buffer[bufout];
printf("Consumidor lee %d desde posición %... | 0 |
#include <pthread.h>
extern struct protoent_data _protoent_data;
struct protoent *
getprotobyname(const char *name)
{
struct protoent *p;
pthread_mutex_lock(&_protoent_mutex);
p = getprotobyname_r(name, &_protoent_data.proto, &_protoent_data);
pthread_mutex_unlock(&_protoent_mutex);
ret... | 1 |
#include <pthread.h>
int ridersServed = 0;
int queueCount = 0;
int IDRider[5 +1000];
int IDDriver[5 +1000];
int waitingQueue[5];
int threadCountRiders = 0;
int threadCountDrivers = 5;
pthread_mutex_t lock;
void exitfunc(int sig)
{
printf("Number of Riders Served: %i\\n",ridersServed);
prin... | 0 |
#include <pthread.h>
pthread_mutex_t Device_mutex;
struct VirtualPCB
{
int tid;
char state;
int priority;
int arrivetime;
int cpuburst;
int runnedtime;
}PCB[20];
void thread_init()
{
int n;
srand(time(0));
for(n=0; n<20; n++)
{
PCB[n].tid = n+1;
PCB[n].state = 'F';
PCB[n].prio... | 1 |
#include <pthread.h>
struct udpsrvsession_l
{
struct udpsrvsession_s *current;
struct udpsrvsession_l *next;
};
struct udpsrvsession_l *udpsrvsessions = 0;
struct udpsrvsession_l *udpsrvsessions_last = 0;
pthread_mutex_t udpsrvsessions_mutex = PTHREAD_MUTEX_INITIALIZER;
struct udpsrvsession_... | 0 |
#include <pthread.h>
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: ;
goto ERROR;
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(void)
{
retu... | 1 |
#include <pthread.h>
int states[5];
int eaten_meal_count[5];
pthread_mutex_t m;
pthread_mutex_t s[5];
pthread_t pN[5];
void grab_forks(int i);
void release_forks(int i);
void test(int i);
void *philosopher_procedure(void* i);
int main(){
int i;
pthread_mutex_init(&m, 0);
for (i=0; i<5; i++... | 0 |
#include <pthread.h>
int sum = 0;
sem_t items;
sem_t slots;
pthread_mutex_t my_lock = PTHREAD_MUTEX_INITIALIZER;
int producer_done = 0;
void *producer(void *arg1)
{
int i;
for(i = 1; i <= 100; i++) {
sem_wait(&slots);
put_item(i*i);
sem_post(&items);
}
pthread_mutex_loc... | 1 |
#include <pthread.h>
void* handle_clnt(void *arg);
void send_msg(char *msg, int len);
void error_handling(char *msg);
int clnt_cnt = 0;
int clnt_socks[256];
pthread_mutex_t mutex;
int main(int argc, char *argv[]){
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
in... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int var = 0;
void *func2()
{
while(var < 10)
{
printf("thread2 is runninig\\n");
pthread_mutex_lock(&mutex);
if(var%2 != 0)
pthread_cond_wait(&cond,&mutex);
... | 1 |
#include <pthread.h>
void* IncrementCounter(void*);
static int _count;
static pthread_mutex_t _incrementLock = PTHREAD_MUTEX_INITIALIZER;
int main()
{
pthread_t thr1, thr2, thr3, thr4;
_count = 0;
pthread_create(&thr1, 0, IncrementCounter, 0);
pthread_create(&thr2, 0, IncrementCounter,... | 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(... | 1 |
#include <pthread.h>
struct zbtree *zbtree_init(int (*compar) (const void *, const void *))
{
struct zbtree *t = calloc(1,sizeof(struct zbtree));
pthread_mutex_init(&t->mutex, 0);
t->tree = 0;
t->compar = compar;
return t;
}
void *zbtree_find(struct zbtree *t, void *key, int lock)
{
... | 0 |
#include <pthread.h>
static void send_route_update(char *input, int action) {
char *cmd = &(*input);
int from_msu_id, to_msu_id, runtime_sock, from_msu_type, to_msu_type, to_msu_locality;
char *ip_str;
long total_msg_size = 0;
int to_ip = 0;
int ret;
debug("DEBUG: ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t tid;
int count_hit=0;
int thread(){
pthread_mutex_lock(&mutex);
printf("And now we're in pthread!\\n");
count_hit++;
sleep(3);
pthread_mutex_unlock(&mutex);
while(1){
pthread_mutex_lock(&mutex);
if(count_hit==2){
prin... | 0 |
#include <pthread.h>
long long int number_in_circle = 0;
long long int number_of_tosses_per_thread = -1;
int thread_count = -1;
pthread_mutex_t mut;
int get_max_threads()
{
int max_string_size = 10;
FILE *fp;
char* ret;
int max = -1;
char str[max_string_size];
fp = fopen("/proc/sys/kernel/t... | 1 |
#include <pthread.h>
pthread_mutex_t mutexAB = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexBC = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexCD = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexCE = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexBF = PTHREAD_MUTEX_INITIALIZER;
void* ... | 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++;
... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void* thr_fn(void* arg) {
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0) {
perror("sigwait:");
... | 0 |
#include <pthread.h>
static struct PWM_Shared_Mem *PWM_ptr;
void PWM_CreateSharedMemory( void )
{
key_t key;
int shmid;
int fd;
fd = open(PWM_KEY_FILE, O_CREAT | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO);
close(fd);
key = ftok(PWM_KEY_FILE, PWM_MEM_KEY);
if (key == -1) {
... | 1 |
#include <pthread.h>
void *subrotina_montecarlo(void *);
inline double get_random(long int *, double, double);
pthread_mutex_t mc_mutex;
long double total_over = 0.0;
long double total_under = 0.0;
int main(int argc, char *argv[])
{
long double pi;
long int i;
struct timeval tv1, tv2;
doubl... | 0 |
#include <pthread.h>
void* f_sav(void *v){
int i;
int id = *(int*) v;
while (1) {
pthread_mutex_lock (&pot);
if (servings == 0) {
sem_post (&emptyPot);
if(enable_log)
printf("prato vazio\\n");
sem_wait (&fullPot);
... | 1 |
#include <pthread.h>
pthread_mutex_t sum_mutex1;
int a[1000], sum;
void initialize_array(int *a, int n) {
int i;
for (i = 1; i <= n; i++) {
a[i-1] = i;
}
}
void *thread_add(void *argument) {
int i, thread_sum, arg;
thread_sum = 0;
arg = *(int *)argument;
fo... | 0 |
#include <pthread.h>
char* id_a = "A thread(process)";
char* id_b = "B thread(process)";
int num = 0;
int iter = 1;
pthread_mutex_t mtxA;
pthread_mutex_t mtxB;
void* myfunc1(void* arg){
char* id = (char*)arg;
int i;
while(1){
if(id == id_a)
pthread_mutex_lock(&mtxA);
else
pthread_... | 1 |
#include <pthread.h>
uint32_t count;
pthread_mutex_t lock;
pthread_cond_t cond;
} semaphore;
void* sem_new(uint32_t resources) {
semaphore *s;
s = (semaphore*)malloc(sizeof(semaphore));
s->count = resources;
pthread_mutex_init(&(s->lock),0);
pthread_cond_init(&(s->cond),0);
return s;
}... | 0 |
#include <pthread.h>
pthread_mutex_t a;
pthread_mutex_t b;
pthread_mutex_t c;
int k;
int j;
void* fn1(void * args){
pthread_mutex_lock(&a);;
if( k == 25 ){
pthread_mutex_lock(&b);;
j = 1-j;
if( j )
printf("hola\\n");
else
printf("adios\\n");
} else {
pthread_mutex_l... | 1 |
#include <pthread.h>
struct jack_buffer* jack_input_buffers_head;
struct jack_buffer* jack_input_buffers_tail;
sem_t jack_input_buffer_sem;
int jack_input_sequence=0;
int jack_input_buffer_underruns=0;
pthread_mutex_t jack_input_buffer_mutex;
struct jack_buffer* jack_free_buffers_head;
s... | 0 |
#include <pthread.h>
float y;
sem_t sem_y;
sem_t sem_signal;
pthread_mutex_t mutex_y;
void part_2(struct udp_conn *connection){
printf("---------- PART 2 ---------- \\n");
sem_init(&sem_y, 0, 1);
sem_init(&sem_signal, 0, 1);
pthread_mutex_init(&mutex_y, 0);
pthread_t thread_receiver;
pthr... | 1 |
#include <pthread.h>
char *nombre;
struct amigos *friends;
struct lista *sig;
}LISTA;
char *amigo;
struct amigos *sig;
}AMIGOS;
char *tupla;
struct amigos *primero;
struct amigos *segundo;
struct comparacion *sig;
}COMPARACION;
struct lista *argumento1;
struct comparacion *argume... | 0 |
#include <pthread.h>
void * collectManager() {
int a;
trashesToEmpty = initList(sizeof(int));
pthread_mutex_lock(&mutexListToEmpty);
for(int i = 0; i < NB_TRASHES; i++) {
arrayTrashInList[i] = 0;
}
while(1) {
pthread_cond_wait(&addTrashListToEmpty, &mutexListToEmpty);
if(isEm... | 1 |
#include <pthread.h>
int buffer;
int count = 0;
pthread_cond_t empty, fill;
pthread_mutex_t mutex;
void put(int value) {
assert(count == 0);
count = 1;
buffer = value;
}
int get() {
assert(count == 1);
count = 0;
return buffer;
}
void *producer(void *arg) {
int i;
... | 0 |
#include <pthread.h>
extern struct mansession *sessions;
int _read(struct mansession *s, struct message *m) {
int res;
for (;;) {
res = get_input(s, m->headers[m->hdrcount]);
if (strstr(m->headers[m->hdrcount], "--END COMMAND--")) {
if (debug) debugmsg("Found END COMMAND");
m->in... | 1 |
#include <pthread.h>
void *handleCliReq(void *arg)
{
char sendBuffer[SEND_BUFFER_SIZE];
char recvBuffer[RECV_BUFFER_SIZE];
char tmpRecvBuffer[RECV_BUFFER_SIZE];
char *fileNameToken;
char *getFileCmdToken;
char *getToken;
char *tmpFilePath;
char *sendFilePath;
ssize_t recvBytes... | 0 |
#include <pthread.h>
extern void __VERIFIER_error() ;
int __VERIFIER_nondet_int(void);
void ldv_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
pthread_t t1, t2;
pthread_mutex_t mutex;
int pdev;
void ath9k_flush(void) {
pthread_mutex_lock(&mutex);
pdev = ... | 1 |
#include <pthread.h>
int bankerFunc(int id, int requesting, int resources[])
{
int i;
for (i = 0; i < NUMBER_OF_RESOURCES; ++i)
pthread_mutex_init(&mutex[i], 0);
for (i = 0; i < NUMBER_OF_RESOURCES; ++i)
{
if (!requesting)
release(&mutex[i], id, resources[i], i);
else i... | 0 |
#include <pthread.h>
void event_counter_init(struct Event_Counter *ev, int c)
{
pthread_mutex_init(&ev->mute, 0);
pthread_cond_init(&ev->signal, 0);
ev->event_val = c;
}
int count_read(struct Event_Counter *ev)
{
return ev->event_val;
}
void advance(struct Event_Counter *ev)
{... | 1 |
#include <pthread.h>
int num = 0;
pthread_t pthread[2];
pthread_mutex_t mux_num;
pthread_cond_t cond_ok = PTHREAD_COND_INITIALIZER;
void * taskA(void * arg){
int i;
for(i=0; i<5; i++){
pthread_mutex_lock(&mux_num);
num++;
printf("taskA : num :%d\\n", nu... | 0 |
#include <pthread.h>
FILE *io_ahrs;
static pthread_t thread_recv;
static int (*handler_recv)();
void io_ahrs_init(char const *path)
{
io_ahrs = fopen(path, "r+");
if (!io_ahrs)
{
DEBUG("Failed to open %s", path);
}
return;
}
void io_ahrs_clean()
{
fclose(io_ahrs);
return;
}
stat... | 1 |
#include <pthread.h>
int liStart, liEnd, colStart, colEnd;
} macroBloco;
KIND** matrix;
int primeNumber;
pthread_mutex_t mutexPrimeNumber;
int subAvailable;
pthread_mutex_t mutexSubAval;
void countPrimesSerial(KIND** mat, int li, int col);
void *countPrimesThread(void *threadid)... | 0 |
#include <pthread.h>
int process_IPC_request(int server_sockfd,
struct http_request_info_t *proxy_request,
struct connection *conn)
{
struct shared_data_t *sh_data = acquire_shared_segment();
fill_IPC_request(proxy_request, sh_data->shm_id);
size_t buf_sz = 8192;
char request_... | 1 |
#include <pthread.h>
long iterasyon_sayisi, birthread_kaciterasyon;
int thread_sayisi,sayac=0;
float pi;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* runner(void* arg) {
long i;
int icerdemi=0;
unsigned int seedp = rand();
for(i=0;i<birthread_kaciterasyon;i++){
... | 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*), *consume( void*);
int main( int argc, char** argv)
{
int i, nthreads, count[ 100];
pthread_t tid_produce[ 100... | 1 |
#include <pthread.h>
char achData[1024];
char achSendData[1024];
int iCount,iSocketfd,iConfd,iLen,iCharCount,c;
FILE *fp;
pthread_t thread[5];
struct sockaddr_in serv_addr;
pthread_mutex_t lock;
void *sendd();
int main()
{
iSocketfd=socket(AF_INET,SOCK_STREAM,0);
serv_addr.sin_family=AF_INET;... | 0 |
#include <pthread.h>
int A [2][3] = {{1, 4, 3}, {2, 5, 2}};
int B [3][3] = {{8, 7, 6}, {5, 4, 3}, {1, 2, 2}};
int C [2][3];
int i;
int j;
} matrix_t;
static matrix_t *data;
pthread_mutex_t lock;
void *worker(void *parameter);
static void dispatcher(int horizontal_element,... | 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;
for (;;) {
memset(&tip->m, 0, s... | 0 |
#include <pthread.h>
int mediafirefs_create(const char *path, mode_t mode,
struct fuse_file_info *file_info)
{
printf("FUNCTION: create. path: %s\\n", path);
(void)mode;
int fd;
struct mediafirefs_openfile *openfile;
struct mediafirefs... | 1 |
#include <pthread.h>
int value;
pthread_mutex_t mutex;
pthread_cond_t cond;
} sema_t;
void sema_init(sema_t *sema, int value)
{
sema->value = value;
pthread_mutex_init(&sema->mutex, 0);
pthread_cond_init(&sema->cond, 0);
}
void sema_wait(sema_t *sema)
{
pthread_mutex_... | 0 |
#include <pthread.h>
void myhandle_init(){
pthread_mutex_init(&shMap.mutex,0);
shMap.cap = INIT_MAP_ITEM_NUM;
shMap.head = 0;
shMap.tail = shMap.cap-1;
servicehandle = malloc(sizeof(struct serviceHandleItem)*INIT_MAP_ITEM_NUM);
}
int myhandle_getIdleHandle(){
return 0;
}
void myhandl... | 1 |
#include <pthread.h>
struct node {
int datum;
struct node *next;
};
struct head {
pthread_mutex_t lock;
struct node *first;
struct head *next;
} *list;
pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER;
void init_node (struct node *p, int x) {
p->datum = x;
p->next = 0;
}
vo... | 0 |
#include <pthread.h>
double grid[1024][1024];
double new[1024][1024];
double globalMax;
long gridSize;
long numIters;
long numThreads;
long rows;
long modulo;
long barrier_counter1, barrier_counter2, barrier_counter3;
long rowCounter = 1;
struct timeval start, end;
pthread_mutex_t barrier;... | 1 |
#include <pthread.h>
int memory[(2*32+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top = 0;
void __VERIFIER_atomic_acquire() {
pthread_mutex_lock(&m);
}
void __VERIFIER_atomic_release() {
pthread_mutex_unlock(&m);
}
void __VERIFIER_atomic_index_malloc(int *curr_alloc_idx)
{
... | 0 |
#include <pthread.h>
int * T;
sem_t * sem;
pthread_mutex_t * lock;
pthread_cond_t * cond;
pthread_mutex_t * row_lock, * other_lock;
pthread_cond_t * k_cond;
int * row, * running, * k;
int number_of_vertices;
void wtc_proc_bt_init(int * initial_matrix, int n, int number_of_processes) {
sem_... | 1 |
#include <pthread.h>
int threadCount,
n,
sieve,
prime[1000000];
pthread_mutex_t sieveLock = PTHREAD_MUTEX_INITIALIZER;
pthread_t threads[100];
void crossOut(int k, int mark);
int findNextSieve(int current);
void *worker(int threadNumber);
int main(int argc, char **argv){
... | 0 |
#include <pthread.h>
int value;
pthread_cond_t rc;
pthread_mutex_t rm;
int r_wait;
pthread_cond_t wc;
pthread_mutex_t wm;
int w_wait;
}Storage;
void set_data(Storage *s,int value){
s->value=value;
}
int get_data(Storage *s){
return s->value;
}
void * set_th(void *arg){
Storage *s =(St... | 1 |
#include <pthread.h>
char** array;
int left;
int right;
} SortParams;
static int maximumThreads;
int threadsLeft;
pthread_mutex_t mut;
static void insertSort(char** array, int left, int right) {
int i, j;
for (i = left + 1; i <= right; i++) {
char* pivot = array[i];
j = i - 1;
w... | 0 |
#include <pthread.h>
pthread_mutex_t mutexLastTrame = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexEtats[12];
pthread_cond_t pourLire = PTHREAD_COND_INITIALIZER;
pthread_cond_t pourEcrire = PTHREAD_COND_INITIALIZER;
int lastTrame = -1;
int buf[12];
Etat etats[12];
int nbElements;
int ecri... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
struct node {
int n_number;
struct node *n_next;
} *head=0;
static void cleanup_handler(void*arg) {
printf("Clean up handler of second thread.\\n");
fr... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int sillas[5] = {0, 0, 0, 0, 0};
int ubicarSilla();
int ubicarSilla() {
for (int i = 0; i < 5; ++i) {
if (sillas[i] == 0 && sillas[(i+1)%5] == 0 ) {
return i;
}
}
ret... | 1 |
#include <pthread.h>
pthread_t g_treads[thread_num];
pthread_cond_t g_work_done;
pthread_mutex_t g_general_mutex = PTHREAD_MUTEX_INITIALIZER;
int g_work_amount = 0;
static inline void update_picture(void)
{
SDL_UpdateTexture(g_sdl.texture, 0, g_sdl.pixels, ww * sizeof(int32_t));
SDL_RenderCo... | 0 |
#include <pthread.h>
struct donut_ring shared_ring;
int space_count[NUMFLAVORS];
int donut_count[NUMFLAVORS];
pthread_mutex_t prod[NUMFLAVORS];
pthread_mutex_t cons[NUMFLAVORS];
pthread_cond_t prod_cond[NUMFLAVORS];
pthread_cond_t cons_cond[NUMFLAVORS];
pthread_t thread_id[NUMCONSUMERS+NUMPRODUCER... | 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>
int lastrow,lastcol;
int win=0;
int end=0;
int row =5;
int col= 15;
pthread_cond_t cv;
pthread_mutex_t mu;
int map[6][30];
int getch (void)
{
int ch;
struct termios oldt, newt;
tcgetattr(STDIN_FILENO, &oldt);
memcpy(&newt, &oldt, sizeof(newt));
newt.c_lfla... | 1 |
#include <pthread.h>
int MAX = 20001;
int p_sleep;
int c_sleep;
int producer_count;
int consumer_count;
int item_p;
int item_c;
bool isproducersleeping = 0;
bool isconsumersleeping = 0;
pthread_mutex_t lock;
pthread_cond_t cond_consume;
pthread_cond_t cond_produce;
struct Queue
{
int fr... | 0 |
#include <pthread.h>
int numero = 100;
pthread_mutex_t mutex;
int n;
} param;
void *duplica(void *);
void *divide(void *);
int main() {
pthread_t thread1;
pthread_t thread2;
param p;
p.n = 5;
pthread_create(&thread1, 0, duplica, &p);
pthread_create(&thread2, 0, divide, &p);
pthread... | 1 |
#include <pthread.h>
static pthread_mutex_t vu_name_mutex = PTHREAD_MUTEX_INITIALIZER;
static char vu_name[_UTSNAME_LENGTH];
void set_vu_name(char *name) {
pthread_mutex_lock(&vu_name_mutex);
memset(vu_name, 0, _UTSNAME_LENGTH);
strncpy(vu_name, name, _UTSNAME_LENGTH);
pthread_mutex_unlock(&v... | 0 |
#include <pthread.h>
pthread_mutex_t sum_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *functionAdd1();
void *functionAdd2();
int sum = 0;
int count=0;
int main()
{
pthrea... | 1 |
#include <pthread.h>
static int run_light = 0;
static pthread_mutex_t light_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t wait_light = PTHREAD_COND_INITIALIZER;
void turn_on_light( void )
{
pthread_mutex_lock( &light_mutex );
run_light = 1;
pthread_cond_broadcast( &wait_lig... | 0 |
#include <pthread.h>
int left, right, angle;
int sensi = 1;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t cnd_mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cnd = PTHREAD_COND_INITIALIZER;
FILE * can;
int can_open(char * host, char * port)
{
int fd;
if ((fd = getsockf... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char ** palabras;
int * contadas;
int numero_lineas(char *ruta, int *tam_lineas){
if(ruta != 0){
FILE *ar = fopen(ruta,"r");
int lineas =0;
int tam_linea;
while(!feof(ar)){
tam_l... | 0 |
#include <pthread.h>
void fun(void);
pthread_mutex_t mutex;
void *thread_func(void *args)
{
printf("%lu locking mutex\\n",pthread_self());
pthread_mutex_lock(&mutex);
printf("%lu locked mutex\\n",pthread_self());
fun();
sleep(2);
pthread_mutex_unlock(&mutex);
}
void fun(void)
{
if(pthread... | 1 |
#include <pthread.h>
int x = 0,contador=0;
pthread_mutex_t x_mutex;
pthread_cond_t x_cond;
void barreira(int nthreads){
pthread_mutex_lock(&x_mutex);
contador++;
while(contador != nthreads){
pthread_cond_wait(&x_cond,&x_mutex);
pthread_mutex_unlock(&x_mutex... | 0 |
#include <pthread.h>
int arr[1024];
pthread_mutex_t s = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;
int escribiendo = 0;
int leyendo = 0;
int escritor_esperando = 0... | 1 |
#include <pthread.h>
struct dns_discovery_args {
FILE * report;
char * domain;
int nthreads;
};
struct dns_discovery_args dd_args;
pthread_mutex_t mutexsum;
void
error (const char * msg)
{
perror (msg);
exit (1);
}
FILE *
ck_fopen (const char * path, const char * mode)
{
FILE * file =... | 0 |
#include <pthread.h>
struct foo
{
int id;
pthread_mutex_t f_lock;
int f_count;
};
struct foo* foo_alloc(int id)
{
struct foo* fp;
if ((fp = malloc(sizeof(struct foo))) != 0)
{
fp->id = id;
fp->f_count = 1;
if (pthread_mutex_init(&fp->f_lock, 0) != 0)... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int scholarship = 4000;
int total = 0;
void *A(void);
void *B(void);
void *C(void);
void *totalCalc(void);
int main(void)
{
pthread_t tid1,
tid2,
tid3;
pthread_create(&tid1, 0, (void *(*)(void *))A, 0);
pthre... | 0 |
#include <pthread.h>
int nbr_of_thread;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char** array;
int left;
int right;
} SortParams;
static int maximumThreads = 1;
static void insertSort(char** array, int left, int right) {
int i, j;
for (i = left + 1; i <= right... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
void *is_prime(void *p)
{
int i, n, flag;
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 m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
char *ts="[??:??:??]";
struct tm * now;
time_t nw;
pthread_mutex_lock(&m_trace);
nw = time(0);
now = localt... | 1 |
#include <pthread.h>
int waiting = 0;
int chairs = 0;
sem_t customers;
sem_t barbers;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void *barber_func(void *arg);
void *customer_func(void *arg);
void cut_hair(void);
void *barber_func(void *arg)
{
pthread_detach(pthread_self());... | 0 |
#include <pthread.h>
static pthread_mutex_t s_logMutex = PTHREAD_MUTEX_INITIALIZER;
uint64_t ril_nano_time() {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return now.tv_sec * 1000000000LL + now.tv_nsec;
}
int64_t elapsedRealtime() {
struct timeval tv;
getti... | 1 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
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)
{
printf("parent unlocking l... | 0 |
#include <pthread.h>
struct tenedor
{
int id;
pthread_mutex_t mutex;
pthread_cond_t cond;
};
struct filosofo
{
int id;
struct tenedor *tDer,*tIzq;
};
char *estado;
pthread_mutex_t mutexImprimir=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t fakeMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t fak... | 1 |
#include <pthread.h>
void usage(char *prog) {
fprintf(stderr, "usage: %s [-v] [-n num]\\n", prog);
exit(-1);
}
int verbose;
int nthread=2;
int shutdown;
char *dir="/tmp";
char *file;
struct work_t *next;
} work_t;
work_t *head,*tail;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthr... | 0 |
#include <pthread.h>
int somme_alea;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_rand(void * arg){
int random_val = (int) ((float) 10 * rand() /(32767 + 1.0));
printf("Mon num d'ordre : %d \\t mon tid %d \\t valeur generee : %d\\n", (*(int *)arg), (int)pthrea... | 1 |
#include <pthread.h>
int readerCount;
pthread_mutex_t readerCountMutex;
int isWriterWaiting;
pthread_cond_t readerWait;
pthread_mutex_t bufferMutex;
int sharedBuffer;
void* writerCode(void* a)
{
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 25000;
int count;
for (... | 0 |
#include <pthread.h>
struct local_file_rcv {
struct htrace_rcv base;
struct htracer *tracer;
FILE *fp;
char *path;
pthread_mutex_t lock;
};
static void local_file_rcv_free(struct htrace_rcv *r);
static struct htrace_rcv *local_file_rcv_create(struct htrace... | 1 |
#include <pthread.h>
static struct ubus_context *ubus_ctx = 0;
static const char *ubus_sock;
static void seriald_ubus_add_fd(void);
static void seriald_ubus_connection_lost_cb(struct ubus_context *ctx);
static void seriald_ubus_reconnect_timer(struct uloop_timeout *timeout);
static int seriald_... | 0 |
#include <pthread.h>
int stoj = 0;
int minute_vedra = 0;
int cakajuci_na_prestavku = 0;
pthread_mutex_t mutex_minute_vedra = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_pocet_cakajucich = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_turniket = PTHREAD_MUTEX_INITIALIZER;
sem_t sem_ca... | 1 |
#include <pthread.h>
void *func(int n);
pthread_t philosopher[5];
pthread_mutex_t chopstick[5];
int main()
{
int i,k;
void *msg;
for(i=1;i<=5;i++)
{
k=pthread_mutex_init(&chopstick[i],0);
if(k==-1)
{
printf("\\n Mutex initialization failed");
exit(1);
}
}
for(i=1;i<=5;i++)
{
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.