text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int tid;
double stuff;
} thread_data_t;
double shared_x;
pthread_mutex_t lock_x;
void *thr_func(void *arg) {
thread_data_t *data = (thread_data_t *)arg;
printf("hello from thr_func, thread id: %d\\n", data->tid);
pthread_mutex_lock(&lock_x);
shared_x += d... | 1 |
#include <pthread.h>
static const char* filePaths[] =
{
"out/1.txt",
"out/2.txt",
"out/3.txt",
"out/4.txt",
"out/5.txt"
};
static const char* outputPath = "out/out.txt";
char buffer[20971520];
size_t bufsize = 0;
void fileReader(pthread_mutex_t*);
void* fileWriter(void*... | 0 |
#include <pthread.h>
int fumando[3];
int recursos[3];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* agenteT (void* a){
int enUso = 1;
int i;
while (1){
for (i=0;i<3; ++i){
pthread_mutex_lock(&mutex);
if (!fumando[i]){
pthread_mutex_unlock(&mutex);
... | 1 |
#include <pthread.h>
struct job {
struct job* next;
int job_number;
};
struct job* job_queue;
pthread_t thread1_id;
pthread_t thread2_id;
void process_job (struct job* job)
{
printf("%s %d\\n", "Processing job number", job->job_number);
}
pthread_mutex_t job_queue_mutex = PTHREAD_MUT... | 0 |
#include <pthread.h>
int x;
int rst[1023];
} fourKB;
fourKB fourkb[256];
} BigMEMBlock;
size_t MEMBLOCKSIZE = sizeof(BigMEMBlock);
int numblocks = 1024 ;
int numworkers = 2;
int runtime = 15;
int prepare = 5;
BigMEMBlock *mempool;
pthread_t *tid;
pthread_mutex_t filelock;
FILE* logfd;
... | 1 |
#include <pthread.h>
int buffer[100];
int indice;
pthread_mutex_t mutex;
sem_t sem_espacios_vacios;
sem_t sem_espacios_ocupados;
void agregar(int n);
void quitar();
void * productor()
{
while(1)
{
int n = 5 +rand()*100;
agregar(n);
sleep(1);
}
}
void * consumidor()
{
while(1)... | 0 |
#include <pthread.h>
int timer = 0;
pthread_mutex_t mutex_timer;
pthread_cond_t timer_expired_cv;
void *watch_timer(void *timer){
int waiting_time = *((int*)timer);
printf("Starting watch_timer(), thread is waiting %d second(s):\\n", waiting_time);
while(waiting_time > 0){
sleep... | 1 |
#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 = l... | 0 |
#include <pthread.h>
pthread_mutex_t mutex,mutex2 ;
void *my_thread_process(void *arg){
int c;
for(c='a';c<='z';c++){
pthread_mutex_lock(&mutex);
printf("%c\\n",c);
pthread_mutex_unlock(&mutex2);
}
pthread_exit(0);
}
void *my_thread_process2(void *arg){
int c;
for(c='A';c<='Z... | 1 |
#include <pthread.h>
void count3s_thread(int id);
pthread_t tid[8];
int t;
int *my_array;
int length;
int count;
struct padded_int
{
int value;
char padding[60];
} private_count[8];
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void count3s()
{
int i;
count = 0;
for(i = 0; i < ... | 0 |
#include <pthread.h>
void error(char *msg) {
fprintf(stderr, "%s: %s\\n", msg, strerror(errno));
exit(1);
}
int beers = 2000000;
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void *drink_lots(void *a) {
int i;
for (i = 0; i < 100000; i++) {
pthread_mutex_lock(&... | 1 |
#include <pthread.h>
void Emergency_exit (int signum)
{
land();
close_commands_socket();
exit(signum);
}
void * navdata_thread()
{
int result = 1;
printf("[NAV] Init\\n");
result = init_navdata_reception();
printf("[NAV] Init OK\\n");
if (result != 0) {
printf("[N... | 0 |
#include <pthread.h>
int buffer[100];
int count = 0;
int in = -1, out = -1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t buffer_has_space = PTHREAD_COND_INITIALIZER;
pthread_cond_t buffer_has_data = PTHREAD_COND_INITIALIZER;
void producer(void){
int i;
for(i=0 ; i<1000 ; ... | 1 |
#include <pthread.h>
static struct {
int value;
pthread_mutex_t mutex;
pthread_cond_t cond;
} money;
static void *print_money(void *arg)
{
pthread_mutex_lock(&money.mutex);
++money.value;
pthread_mutex_unlock(&money.mutex);
if (0 < money.val... | 0 |
#include <pthread.h>
void *threadA_main(void *arg);
void *threadB_main(void *arg);
static int counter=0;
static pthread_mutex_t mutex;
int main(int argc, char **argv)
{
pthread_t thread_id_1,thread_id_2;
int res;
pthread_mutex_init(&mutex,0);
pthread_create(&thread_id_1,0,threadA_main,0);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_exist = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_enter = PTHREAD_COND_INITIALIZER;
char text[20][10];
int val;
int pro_cnt=0, cons_cnt=0;
int cou... | 0 |
#include <pthread.h>
static void *serial_monitor(void *arg);
pthread_mutex_t lock;
pthread_cond_t nonfull;
pthread_cond_t nonempty;
int count;
int last;
int first;
char elements[256];
} Buffer;
static pthread_t pthread_receiver;
static Buffer RX_buffer;
static int serial_fd;
void zb_... | 1 |
#include <pthread.h>
int reader_count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t resource = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t service = PTHREAD_MUTEX_INITIALIZER;
void *reader(void *_)
{
pthread_detach(pthread_self());
for (;;) {
pthread_mut... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
void *system_call(void* s) {
long i;
int fd;
char* tmp = (char*) s;
if ((fd=open("write.out",O_WRONLY|O_CREAT,0644)) < 0) {
fprintf(stderr,"Can't open %s. Bye.\\n","write.out");
exit(1);
}
for (i=0; i<50000; i++) {
if (write(f... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t cond;
void * thread1(void * arg)
{
pthread_cleanup_push(pthread_mutex_unlock, &mutex);
while(1)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread1 is appliedx the condition\\n");
pthread_mu... | 0 |
#include <pthread.h>
extern char **environ;
static char envbuf[4096];
pthread_mutex_t g_env_mutex;
static pthread_once_t g_init_done = PTHREAD_ONCE_INIT;
static void thread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHRE... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t empty, full, done;
int no_cycles = 2;
int no_consumers = 4;
int counter = 0;
char *input = "Hello!";
char* buffer = '\\0';
int totalReads = 0;
int totalWrites = 0;
void writeToFile(int type, int num_cores, double time, int loop ){
... | 0 |
#include <pthread.h>
int arr[1024];
pthread_mutex_t semaphore = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t can_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t can_write = PTHREAD_COND_INITIALIZER;
int n_reading = 0, n_writing = 0;
void *escritor(void *arg){
int i;
int num = *((int *)a... | 1 |
#include <pthread.h>
extern struct Thread_List_Item *controlprogram_threads;
extern pthread_mutex_t controlprogram_list_lock,exit_lock;
extern char *controlprogram_list_lock_buffer,*exit_lock_buffer;
extern int verbose;
void timeout_exit(void *arg)
{
pthread_t tid;
tid = pthread_self();
}
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int valoresA[16], valoresB[16], separacao = 16 / 4, indiceFim;
int indiceInicio = 0, sum = 0, i = 0;
void *calculo(void *arg){
pthread_mutex_lock(&mutex);
long int numeroThread = (long int)arg;
int indiceFim = indiceInicio + separacao;
if(indiceF... | 1 |
#include <pthread.h>
pthread_t a_lock,b_lock,c_lock, d_lock;
static int a;
unsigned int b = 100000;
unsigned int c = 200000;
void *func0(void * arg,...)
{
unsigned int x = 100000;
pthread_mutex_lock(&a_lock);
pthread_mutex_lock(&a_lock);
while (x--)
{ ++a; }
pthread_mutex_unloc... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[400];
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>
pthread_cond_t cond;
pthread_mutex_t mutex;
pthread_t thid[4];
int ocupado=1;
void *t0( void *arg){
int dormir, *id;
id = (int*)(arg);
printf("[th %d] Inicio\\n",*id);
dormir = rand()%3 + 1;
printf("[th %d] Duerme %d\\n",*id,dormir);
sleep(dormir);
printf("[th... | 0 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main() {
int res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if (res != 0) {
perror("Mutex initialization failed");
... | 1 |
#include <pthread.h>
int recordSize = 1024;
int threadsNr;
char *fileName;
int fd;
int numOfRecords;
int creatingFinished = 0;
char *word;
int rc;
int someonefound = 0;
int detachedNr = 0;
pthread_key_t key;
pthread_t *threads;
int *wasJoin;
pthread_mutex_t mutexForRecords = PTHREAD_MUTEX_INI... | 0 |
#include <pthread.h>
int buffer[10];
int bufferindicator = 0;
int readbufferindex = 0;
pthread_mutex_t cmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cempty = PTHREAD_COND_INITIALIZER;
pthread_cond_t cfull = PTHREAD_COND_INITIALIZER;
void* writer_thread(void *arg)
{
int lo... | 1 |
#include <pthread.h>
FILE *__log_out_file = 0;
int __log_out_priority = 0;
static int write_count = 0;
static int flag_fflush = 0;
static unsigned int file_max_sizes = 0;
static pthread_mutex_t log_mtx = PTHREAD_MUTEX_INITIALIZER;
static unsigned int threshold_switch = 10000;
static unsigne... | 0 |
#include <pthread.h>
int value;
int divisors;
} result_t;
result_t vals[5];
int size;
pthread_mutex_t mutex;
pthread_cond_t cond;
} stack_t;
stack_t stack;
int g_max;
int g_next;
pthread_mutex_t g_next_mtx;
int num_divisors(int v) {
int cnt = 0;
for (int i = 1; i <= v; i++)
if (v %... | 1 |
#include <pthread.h>
const char *names[5] = { "Aristoteles", "Kant", "Platon", "Marx", "Aquin" };
pthread_mutex_t forks[5];
const char *topic[5] = { "Spaghetti!", "Life", "Universe", "Everything", "Bathroom" };
void print(int y, int x, const char *fmt, ...)
{
static pthread_mutex_t screen... | 0 |
#include <pthread.h>
void * mujer_quiere_entrar();
void * hombre_quiere_entrar();
void mujer_sale();
void hombre_sale();
pthread_mutex_t mutex_bano = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_hombres = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_mujeres = PTHREAD_MUTEX_INITIALIZER;
p... | 1 |
#include <pthread.h>
int count = 0;
int K;
pthread_mutex_t my_mutex;
struct timeval start, end;
void error(char *msg)
{
perror(msg);
exit(0);
}
void *connection_handler(void *socket_desc);
int main(int argc, char *argv[])
{
int i,N,global_time;
void *res;
count = 0;
N = at... | 0 |
#include <pthread.h>
char buf[128];
size_t pos;
size_t len;
int write_closed;
pthread_mutex_t mutex;
} bbuffer;
bbuffer* bbuffer_new(void) {
bbuffer* bb = (bbuffer*) malloc(sizeof(bbuffer));
bb->pos = 0;
bb->len = 0;
bb->write_closed = 0;
pthread_mutex_in... | 1 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t mutex;
void * func(void * n)
{
printf("thread %ld start\\n", pthread_self());
int *mark = (int *) n;
for (int i = 0; i < 10000000; i++)
{
pthread_mutex_lock(&mutex);
if (*mark == 1)
sum++;
else
... | 0 |
#include <pthread.h>
char * compressMe = 0;
char * finalFileName = 0;
pthread_mutex_t lock;
int compressT_LOLS(char * fileName, int numOutputs)
{
FILE * file = fopen(fileName, "r");
if(!file)
{
printf("The file could not be found.\\nName:\\t%s\\n", fileName);
printf("The file must be in ... | 1 |
#include <pthread.h>
char* string;
struct list* next;
} List;
pthread_mutex_t synchronzer;
List* list;
} headList;
headList* create_list(headList* head){
head = (headList*)malloc(sizeof(headList));
pthread_mutex_init(&head->synchronzer, 0);
head->list = 0;
return head;
}
void new_no... | 0 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int ... | 1 |
#include <pthread.h>
int tasks = 0, done = 0;
pthread_mutex_t lock;
char localdate[9];
char locallogNo[7];
char localTime[7];
int a;
}tBfans;
void dummy_task(void *arg) {
usleep(100);
pthread_mutex_lock(&lock);
tBfans *tfans;
tfans = (tBfans *)arg;
prin... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void *thread_func1(void *ignored_argument)
{
int s;
s = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
if (s != 0) {
perror("pthread_setcancelstate");
exit(1);
}
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int shared = 0;
void init()
{
wiringPiSetup();
pinMode(7, OUTPUT);
pinMode(0, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
}
void reset()
{
digitalWrite(7, LOW);
digitalWrite(0, LOW);
digitalWrite(2, LOW);
digitalWrite(3, LO... | 0 |
#include <pthread.h>
pthread_mutex_t sum_mutex1;
pthread_key_t psum_key;
int a[1000], sum;
void initialize_array(int *a, int n) {
int i;
for (i = 1; i <= n; i++) {
a[i-1] = i;
}
}
void print_partial_sum (int thread_no) {
int *psum;
psum = pthread_getspecific(psum_... | 1 |
#include <pthread.h>
struct ve_mem
{
struct cedrus_mem pub;
struct ve_mem *next;
};
struct ve_allocator
{
struct cedrus_allocator pub;
int fd;
struct ve_mem first;
pthread_mutex_t lock;
};
static struct cedrus_mem *cedrus_allocator_ve_mem_alloc(struct cedrus_allocator *allocator_pub, s... | 0 |
#include <pthread.h>
struct conduct *conduct_create(const char *name, size_t a, size_t c){
struct conduct * conduit = 0;
if ( name != 0) {
int fd_cond;
if( access( name, F_OK ) != -1 ){
printf("[WARNING] File already exist\\n");
return 0;
}
... | 1 |
#include <pthread.h>
int xs[10][100];
int sum[10];
pthread_t threads[7];
pthread_mutex_t mutexes[10];
void *solve(void *arg) {
while(1) {
pthread_mutex_lock(&mutexes[5]);
if(xs[5][0] >= 5) {
pthread_mutex_unlock(&mutexes[5]);
return 0;
}
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
unsigned long long main_counter, counter[3];
void* thread_worker(void*);
int main(int argc,char* argv[])
{
int i, rtn, ch;
pthread_t pthread_id[3] = {0};
for (i=0; i<3; i++)
{
pthread_create(&pthread_id[i],0,thread_worker... | 1 |
#include <pthread.h>
void * p_result(void * arg) {
char * m = malloc(sizeof(char) * 3);
m[0] = 'A';
m[1] = 'B';
m[2] = 'C';
return m;
}
void test_get_result() {
pthread_t thread_id;
void * exit_status ;
pthread_create(&thread_id, 0, p_result, 0);
pthread_join... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condConsumer;
pthread_cond_t condProducer;
int bufferSize = 2;
int buffer = 0;
void *producer1(void *ptr)
{
printf("pro1\\n");
for(int i = 0; i < 10; i++)
{
pthread_mutex_lock(&the_mutex);
while(buffer == bufferSize)
{
pri... | 1 |
#include <pthread.h>
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
}TO_INFO;
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
void *timeout_helper(void *arg)
{
TO_INFO *tip;
tip = (TO_INFO *)arg;
nanosleep(&tip->to_wait, 0);
(*tip->to_fn)(tip->to_arg);
return ... | 0 |
#include <pthread.h>
pthread_mutex_t midisync_lock = PTHREAD_MUTEX_INITIALIZER;
static unsigned short midi_periods[4] = { 0, 0, 0, 0 };
static short next_idx = 0;
static unsigned long total_time = 0;
void midi_report_period(unsigned long midi_period)
{
pthread_mutex_lock(&midisync_lock);
... | 1 |
#include <pthread.h>
static pthread_cond_t dump_cond;
static pthread_mutex_t dump_mtx;
static pthread_t raw_dump_thread;
unsigned char * dump_buffer;
char *dump_mode;
long long *dump_time;
int *dump_size;
char *dump_string;
static volatile short new_pkt_idx=0, pkt_to_dump_idx=0;
static ... | 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>
pthread_mutex_t lock;
void alarm_handler(int arg)
{
pthread_mutex_lock(&lock);
printf("%s, called.\\n", __func__);
pthread_mutex_unlock(&lock);
}
int main(int argc, char *argv[])
{
signal(SIGALRM, alarm_handler);
alarm(1);
pthread_mutex_init(&... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int translation_initialized = 0;
void bg_translation_init()
{
pthread_mutex_lock(&mutex);
if(!translation_initialized)
{
bg_bindtextdomain (PACKAGE, LOCALE_DIR);
translation_initialized = 1;... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum, mutexlvl;
void *dotprod(void *thdarg)
{
pthread_mutex_lock (&mutexlvl);
printf("Sync to start level: %ld\\n", (long... | 0 |
#include <pthread.h>
pthread_mutex_t mutexsum;
int *a, *b;
long sum=0.0;
void *dotprod(void *arg)
{
int i, start, end, offset, len;
long tid;
tid = (long)arg;
offset = tid;
len = 100000;
start = offset*len;
end = start + len;
printf("thread: %ld starting. start=%d... | 1 |
#include <pthread.h>
int _mosquitto_log_printf(struct mosquitto *mosq, int priority, const char *fmt, ...)
{
va_list va;
char *s;
int len;
assert(mosq);
assert(fmt);
pthread_mutex_lock(&mosq->log_callback_mutex);
if(mosq->on_log){
len = strlen(fmt) + 500;
s = _mosquitto_malloc(len*si... | 0 |
#include <pthread.h>
int x = 10;
pthread_mutex_t test;
void *thread1(void *arg)
{
pthread_mutex_lock(&test) ;
int n = 100;
while(n--)
{
x++;
}
printf("\\n");
pthread_mutex_unlock(&test);
}
void *thread2(void *arg)
{
pthread_mutex_lock(&test) ;
... | 1 |
#include <pthread.h>
pthread_t philosopher[5];
pthread_mutex_t chopstick[5] = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER};
struct philosopher_t {
int nr;
int left;
... | 0 |
#include <pthread.h>
pthread_cond_t CV[6];
pthread_mutex_t M;
int state[6];
int n, rounds = 0;
int eat_count[6];
int update_state(int i) {
if (state[i] == 2 && state[(i+6 -1)%6] != 3 && state[(i+1)%6] != 3) {
state[i] = 3;
pthread_cond_signal(&CV[i]);
}
return 0;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t pmutex;
pthread_cond_t cond[5];
enum {THINKING, HUNGRY, EATING} state[5];
int forks[5] = {0, 0, 0, 0, 0};
void *run(void *);
void pickup_forks(int);
void putdown_forks(int);
void test(int);
int main(int argc, char *argv[]) {
pthread_t ... | 0 |
#include <pthread.h>
pthread_mutex_t sinal[10000000];
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
int nArquivos, nThreads, nProdutos, cont = 1;
int armazena[10000000];
void ler (int a){
FILE* va;
int n, aux, pos;
char nome[14];
int leitura;
nome[10]='.';
nome[11]='i';
nome[12]... | 1 |
#include <pthread.h>
pthread_mutex_t mutexmesa;
pthread_t* filosofos;
pthread_cond_t* cond;
char* estado;
} MESA;
int num;
MESA* mesa;
void imprimeEstado(void);
void *filosofo (void *);
void hungry (int);
void eat (int);
void think (int);
int main(int argc, char *argv[])
{
if(argc < 2){
... | 0 |
#include <pthread.h>
int Number = 0;
pthread_mutex_t NMutex;
pthread_cond_t NCond;
void *thread1(void *arg)
{
struct timespec waiting_time;
int cond_wait_count = 0;
int cond_wait_return = 0;
sleep(2);
pthread_mutex_lock(&NMutex);
printf("Thread get lock\\n");
do
{
... | 1 |
#include <pthread.h>
uint8_t type;
uint8_t len_first_name;
uint8_t len_last_name;
} joker_request;
uint8_t type;
uint32_t len_joke;
} joker_response;
const short SERVER_PORT = 2345;
pthread_mutex_t comm_lock;
int setUpSocket();
void listenForRequests();
void error(char *msg);
char * make... | 0 |
#include <pthread.h>
int main(int argc, char *argv[])
{
if(argc!=2)
{
printf("Usage: %s <MSG_SIZE>\\n", argv[0]);
exit(0);
}
int fd;
size_t MSG_SIZE;
void *send_buf_temp;
char name[] = "/my_shmsname";
MSG_SIZE=atoi(argv[1]);
printf("Size : %ld\\n", MSG_SIZE);
fd = shm_open(... | 1 |
#include <pthread.h>
void *buffer;
volatile uint32_t user;
volatile uint32_t server;
uint32_t user_base;
uint32_t server_base;
uint32_t frame_count;
uint32_t frame_size;
pthread_mutex_t lock;
pthread_cond_t cond;
}buffer_cblk_t;
static buffer_cblk_t g_buffer_cblk;
static int g_clie... | 0 |
#include <pthread.h>
char *level_long_str[]={
"EMERGENCY",
"ALERT",
"CRITICAL",
"ERROR",
"WARNING",
"NOTICE",
"INFO",
"DEBUG",
};
static pthread_mutex_t xlog_mutex=PTHREAD_MUTEX_INITIALIZER;
int xlog_rollout(char *filename, int bac... | 1 |
#include <pthread.h>
int socketid;
char msg[35];
int S;
int pid;
char *queue[3];
char *seq[3];
}process;
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
char ch;
void *sendMessage(void * sock);
void *listenMessage(void * sock);
int pid;
int nprocess;
process p[4];
struct hostent *server;
... | 0 |
#include <pthread.h>
pthread_t sutaziaci[5];
pthread_t gen_cisla;
int cislo = 0;
int gen_cislo = 0;
int bignum = 0;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_gen = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_hrac = PTHREAD_COND_INITIALIZER;
void * generator(void * ... | 1 |
#include <pthread.h>
const char year_monthdays[2][13] = {
{0,31,28,31,30,31,30,31,31,30,31,30,31},
{0,31,29,31,30,31,30,31,31,30,31,30,31}
};
char int2bcd(int num)
{
char result;
result = 0xF0 & ((num/10)<<4);
result += (0x0F&(num%10));
return result;
}
int get_rtctime(unsigned char *rx_... | 0 |
#include <pthread.h>
int volatile active = 0;
int volatile error = 0;
pthread_mutex_t mutex;
int use_mutex = 0;
long wait(int id) {
long cnt = 10;
cnt *= id;
do{
if (active != id) {
error = 1;
}
thread_sleep(1);
cnt--;
} while (cnt != 0);
return cnt;
}
void worker... | 1 |
#include <pthread.h>
int arr[10 * 5];
int aindex;
pthread_mutex_t mutex;
void *hello(void *thread_id)
{
int i;
int *id = (int *) thread_id;
for (i=1; i<=10 ; i++) {
pthread_mutex_lock(&mutex);
arr[aindex] = (*id)*100+ i;
sle... | 0 |
#include <pthread.h>
extern int fd_hof1[2];
extern _Bool saida;
extern _Bool debug;
extern pthread_mutex_t all_full;
extern pthread_mutex_t espera_top;
extern pthread_mutex_t d_activos;
extern unsigned int desafios_activos;
int func_interface_serv(char *funcionalidade,char *desaf);
int valida_... | 1 |
#include <pthread.h>
int* find_primes(int *t);
void perror_and_exit(char *msg);
void usage();
int num_workers;
int max_prime;
int prime_count;
pthread_mutex_t mtx;
Boolean verbose = FALSE;
int main(int argc, char **argv) {
int i = 0;
int c;
int t = 0;
double seconds;
time_t start... | 0 |
#include <pthread.h>
pthread_mutex_t readlock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t writelock = PTHREAD_MUTEX_INITIALIZER;
void* Producteur() {
int c;
for(;;){
pthread_mutex_lock(&readlock);
c = getchar();
if ( c == EOF ){
pthread_mutex_unlock(&... | 1 |
#include <pthread.h>
char buffer[65536];
int ascii[128];
pthread_mutex_t lock;
int thread_num;
int bounds;
} thread_info;
void *thread_funct(void *thread_infos) {
int threadStartPos;
int i;
thread_info ti = *(thread_info*) thread_infos;
threadStartPos = ti.thread_num * ti.bounds;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int thread_num;
int* counter;
pthread_t *thread;
int r[1000];
int s[1000];
int res = 0;
void vector_multiply(void* arg) {
printf("In thread\\n");
int i = 0;
int n = *((int*) arg);
for (i = n; i < 1000; i += thread_num) {
pthread_mut... | 1 |
#include <pthread.h>
pthread_mutex_t buffer_mutex;
int fill = 0;
char buffer[100][50];
char *fetch(char *link) {
int fd = open(link, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "failed to open file: %s", link);
return 0;
}
int size = lseek(fd, 0, 2);
assert(size >= 0);
ch... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex;
static void packet_receive(int sock_fd, void *eloop_ctx, void *sock_ctx)
{
ssize_t res;
struct pkthdr pkthdr;
unsigned char buf[2300];
struct smartconfig *sc = (struct smartconfig *)eloop_ctx;
memset(buf, 0, sizeof(buf));
res = recv(sock_... | 1 |
#include <pthread.h>
int
sigaltstack (const stack_t *restrict stack, stack_t *restrict old)
{
int err = 0;
struct signal_state *ss = &_pthread_self ()->ss;
pthread_mutex_lock (&ss->lock);
if (old)
*old = ss->stack;
if (stack)
{
if (stack->ss_size < MINSIGSTKSZ)
{
err... | 0 |
#include <pthread.h>
struct timespec st,en;
double runtime;
int n,m,p;
int **matrix1, **matrix2, **matrix3;
int Row = 0,Col = 0;
int threadCount;
pthread_t * threads;
pthread_mutex_t mutex_Row = PTHREAD_MUTEX_INITIALIZER;
void *multiply(int d){
int i,j,myCol,myRow;
while(1){
p... | 1 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing1(void *arg)
{
int j = 0;
printf("%s entering...", __func__);
fflush(stdout);
while(j < 10)
{
pthread_mutex_lock(&lock);
printf("%s done\\n", __func__);
if(j == ... | 0 |
#include <pthread.h>
void *thread_function(void *);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
main()
{
pthread_t thread_id[10];
int i, j;
for(i=0; i < 10; i++)
{
pthread_create( &thread_id[i], 0, thread_function,... | 1 |
#include <pthread.h>
static pthread_mutex_t mymutex1;
static pthread_mutex_t mymutex2;
static int th_cnt;
void *bodyA(void *arg)
{
int i,j,k,p,q,r;
int sum;
printf("%s - lock(mutex1)\\n",arg);
for (i=0;i<100;i++)
{
sum=0;
for (p=0;p<1000000; p++) {
... | 0 |
#include <pthread.h>
int cond;
pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_pcond = PTHREAD_COND_INITIALIZER;
void *t1_main(void *unused);
void *t2_main(void *unused);
void *t1_main(void *unused) {
for (int i = 0; i < 3; i++) {
cond = cond ? 0 : 1;
sleep... | 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){
int frag = 0, k = 0;
while(k <= 100){
task_t *copy = (task_t*)var;
pthread_mutex_lock(&lock... | 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;
struct foo *f_next;
int f_id;
};
struct foo *foo_alloc(void){
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) != 0){
... | 1 |
#include <pthread.h>
int64_t size;
struct nu_free_cell* next;
} nu_free_cell;
static const int64_t CHUNK_SIZE = 65536;
static const int64_t CELL_SIZE = (int64_t)sizeof(nu_free_cell);
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static nu_free_cell* nu_free_list = 0;
void*... | 0 |
#include <pthread.h>
int sharedData = 0;
pthread_mutex_t mutex;
void delay(int secs) {
time_t beg = time(0), end = beg + secs;
do ; while (time(0) < end);
}
void *add1000(void *n) {
pthread_mutex_lock(&mutex);
int j = sharedData;
delay(rand() % 6);
sharedData = j + 1000;
pth... | 1 |
#include <pthread.h>
int q[5];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
int i = 0;
printf2 ("prod: trying\\n");
while (done == 0)
{
i++;
pthread_mutex_lock (&mq);
... | 0 |
#include <pthread.h>
FILE *fp1,*fp2;
int file_size;
char buf[100];
volatile char read_size=0;
volatile char buf_ready =0;
volatile char end_file =0;
pthread_mutex_t pthread_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t pthread_cond = PTHREAD_COND_INITIALIZER;
int buf_compare(cha... | 1 |
#include <pthread.h>
long int left;
long int left_updated = 0;
long int right;
long int right_updated = 0;
pthread_mutex_t lock;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void handle_values(long int new_left, long int new_right) {
if (abs(new_right) < 10000) {
new_right = 0;
... | 0 |
#include <pthread.h>
static pthread_mutex_t lock;
static char *g_str = "";
static int g_length = 0;
unsigned long fib(unsigned long n)
{
if (n == 0)
return 0;
if (n == 1)
return 2;
return fib(n-1)+fib(n-2);
}
void *
worker1(void *v)
{
int input = (int)v;
pthread_mutex_lock(&lo... | 1 |
#include <pthread.h>
static unsigned char inited = 0;
static unsigned char openned = 0;
static pthread_mutex_t operate_lock;
unsigned short BluetoothInit() {
if (inited) {
return 0;
}
system("mount -t usbdevfs none /proc/bus/usb");
if (ftdi_init()) {
inited = 1;
pthread_mutex_init(&oper... | 0 |
#include <pthread.h>
void pks_global_init(unsigned int log_mask) {
memset(&pk_state, 0, sizeof(struct pk_global_state));
pthread_mutex_init(&(pk_state.lock), 0);
pthread_cond_init(&(pk_state.cond), 0);
pk_state.log_ring_start = pk_state.log_ring_end = pk_state.log_ring_buffer;
pk_state... | 1 |
#include <pthread.h>
struct thread_data{
int shmid;
pthread_mutex_t *mutex_ptr;
pthread_cond_t *cond_ptr;
};
void *second_thread(void *this_data)
{
time_t childTime;
char *shm;
struct thread_data *data;
data = (struct thread_data *)this_data;
pthread_mutex_lock(data->mutex_ptr);
sleep(5... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.