text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int fd;
int flag=0;
pthread_mutex_t lock;
pthread_t even_thd,odd_thd;
pthread_cond_t cond;
void attr_func(pthread_attr_t *attr)
{
int ret=pthread_attr_init(attr);
if(ret!=0)
perror("pthread_attr_init");
ret=pthread_attr_setdetachstate(attr,PTHREAD_CREATE_JOINABLE);
if(ret... | 1 |
#include <pthread.h>
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(void *param) {
pthread_mutex_loc... | 0 |
#include <pthread.h>
const char *stristr(const char *haystack, const char *needle)
{
if(!*needle)
return haystack;
for(; *haystack; ++haystack) {
if(toupper(*haystack) == toupper(*needle)) {
const char *h, *n;
for (h = haystack, n = needle; *h && *n; ++h, ++n) {
if(toupper(*h)... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
... | 0 |
#include <pthread.h>
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
int head = 0;
int tail = 0;
int size = 0;
char queue [8][1023];
void inc(int* posi) {
if (*posi + 1 == 8) {
*posi = 0;
}
else {
++*posi;
}
}
void *send_msg(void* arg) {
int fake_t... | 1 |
#include <pthread.h>
struct jc_type_file_rand_null {
struct jc_type_file_comm_hash *comm_hash;
};
static struct jc_type_file_rand_null global_null;
static int jc_type_file_rand_null_init( struct jc_comm *jcc
)
{
return global_null.comm_hash->init(global_null.comm_hash, jcc);
}
static int
jc... | 0 |
#include <pthread.h>
void *Allen(void *arg);
void *Bob(void *arg);
pthread_mutex_t book1;
pthread_mutex_t book2;
pthread_cond_t Allenfinish;
int main() {
pthread_t tid1, tid2;
pthread_create(&tid1, 0, &Allen, 0);
pthread_create(&tid2, 0, &Bob, 0);
pthread_join(tid1, 0);
pthr... | 1 |
#include <pthread.h>
struct foo *fp[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITILIALIZER;
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 = ma... | 0 |
#include <pthread.h>
pthread_mutex_t sumLock;
int numWorkers;
int numArrived = 0;
int sums = 0;
int maxInd[3] = {0, 0, 0};
int minInd[3] = {32767, 0, 0};
void sum(int partialsum, int max, int maxI, int maxJ, int min, int minI, int minJ){
pthread_mutex_lock(&sumLock);
sums += partialsum;
if... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t prod[20],cons[20];
sem_t full,empty;
int buffer[20];
int size=10;
int counter=0,i;
int num[11]={0,1,2,3,4,5,6,7,8,9,10};
void * producer (void * x)
{
while(1){
int waittime,item;
int *i=x;
sem_wait(&empty);
pthread_mutex_lock(&mutex);
p... | 0 |
#include <pthread.h>
void *handle;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *
load (void *u)
{
pthread_mutex_lock (&m);
handle = dlopen ("$ORIGIN/tst-tls-atexit-lib.so", RTLD_LAZY);
if (!handle)
{
printf ("Unable to load DSO: %s\\n", dlerror ());
return (void *) (... | 1 |
#include <pthread.h>
struct monitor {
int count;
struct server_monitor ** m;
pthread_cond_t cond;
pthread_mutex_t mutex;
int sleep;
int quit;
};
struct worker_parm {
struct monitor *m;
int id;
};
static void
create_thread(pthread_t *thread, void *(*start_routine) (void *), void *arg)... | 0 |
#include <pthread.h>
int *a;
pthread_mutex_t *mutex;
} args;
void *thread(void *arg){
int *a = ((args*)arg)->a;
int i;
for(i=0; i < 1000; i++) {
pthread_mutex_lock(mutex);
(*a)++;
pthread_mutex_unlock(mutex);
}
pthread_exit(0);
}
int main(){
clock_t begin, end;
double time_spen... | 1 |
#include <pthread.h>
void
_ports_complete_deallocate (struct port_info *pi)
{
assert_backtrace ((pi->flags & PORT_HAS_SENDRIGHTS) == 0);
if (MACH_PORT_VALID (pi->port_right))
{
struct references result;
pthread_rwlock_wrlock (&_ports_htable_lock);
refcounts_references (... | 0 |
#include <pthread.h>
int **matrice = 0;
int minimo = 1000;
int rows = 0,cols = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *somma_col(void *col){
int colonna = *(int *)col;
printf("T: %d\\n COL: %d\\n",(int)pthread_self(),colonna);
for(int rig=0; rig<rows; rig++){
pthread_... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void thread_init(void)
{
pthread_key_create(&key, free);
}
char *
getenv(const char *name)
{
int i... | 0 |
#include <pthread.h>
static int n;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int cont = 0;
static pthread_cond_t cond_thread1 = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mutex_thread1 = PTHREAD_MUTEX_INITIALIZER;
static int cond = 0;
void *rand_thread(void *arg){
... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[8];
pthread_mutex_t mutexsum;
void *dotprod(void *arg){
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
le... | 0 |
#include <pthread.h>
void * thread_read_rx()
{
int ret_val =0;
unsigned char buffer;
sleep(1);
while(1)
{
while( ioctl(fd_spi,READ_GPIO,0) < 0)
{
printf("\\n GPIO FAILED");
sleep(1);
}
do
{
ret_val = read_data_spi(&buffer,1);
if(ret_val == -1)
{
printf("\\n GPI... | 1 |
#include <pthread.h>
int num=0;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
void *add(void *arg)
{
int i = 0,tmp = 0;
for(i=0;i<500;i++)
{
pthread_mutex_lock(&mylock);
tmp = num+1;
num = tmp;
printf("add+1,result is :%d\\n",num);
pthread_mutex_unlock(&mylock);
}
return... | 0 |
#include <pthread.h>
void pr_cpu_time(void);
void sig_int(int);
void * thread_start(void *);
pthread_t tid;
long nConn;
} Thread;
int cliSocks[32], cliGet, cliPut;
pthread_mutex_t cliMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cliCond = PTHREAD_COND_INITIALIZER;
static int nThreads;
... | 1 |
#include <pthread.h>
sem_t emptyPot;
sem_t fullPot;
void *savage (void*);
void *cook (void*);
static pthread_mutex_t servings_mutex;
static pthread_mutex_t print_mutex;
static int servings = 15;
int getServingsFromPot(void) {
int retVal;
if (servings <= 0)
{
sem_post (&... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int bottles = 99;
void *takeonedownandpassitaround(void *ptr) {
struct timespec sleeptime;
int *thread_id = (int *)ptr;
while (1) {
pthread_mutex_lock(&mutex);
if (bottles>0) {
fpr... | 1 |
#include <pthread.h>
int a[10], count = 0;
pthread_t thread[10];
pthread_mutex_t lock[10 + 1];
void *sort (void *index);
void *check (void * temp);
int main()
{
int i;
for(i = 0; i < 10; i++)
a[i] = i;
for(i = 0; i < 10; i++)
{
if (pthread_mutex_init(&lock... | 0 |
#include <pthread.h>
int q[2];
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 < 2)
... | 1 |
#include <pthread.h>
int val;
pthread_mutex_t mutex;
void updateVal(int d) {
int i;
int tmp = val;
for (i = 0; i < tmp + 100; i++);
tmp += d;
val = tmp;
}
void *readLetters(void *buffer) {
char *c = (char*)buffer;
while (*c != 0) {
if (isalpha(*c)) {
pthread_mutex_... | 0 |
#include <pthread.h>
sem_t customer_sem;
sem_t barber_sem;
sem_t leaving_sem;
pthread_cond_t barber_cv;
pthread_mutex_t seat_mutex;
pthread_mutex_t barber_mutex;
pthread_mutex_t print_mutex;
pthread_mutex_t count_mutex;
int barber_working;
int free_seat_count;
int max_seat_coun... | 1 |
#include <pthread.h>
void *piCalculate(void *ptr);
void *piPrint(void *ptr);
pthread_mutex_t mutexPi = PTHREAD_MUTEX_INITIALIZER;
double piVal = 0;
int iteration = 0;
bool print = 1;
int main(int argc, char *argv[])
{
if (argc != 3) {
printf("usage: %s iterations seconds.\\n", argv[... | 0 |
#include <pthread.h>
pthread_mutex_t gPresetsMutex = PTHREAD_MUTEX_INITIALIZER;
struct ae_preset gPresets[AE_BANK_COUNT][AE_PRESET_COUNT];
int aeffects_init(struct ae_preset presets[AE_BANK_COUNT][AE_PRESET_COUNT]) {
int ret;
PRINT("aeffects: Initializing library.\\n");
memcpy(gPresets, pr... | 1 |
#include <pthread.h>
struct arg{
int* pids;
int* replies;
int known;
int* toReply;
pthread_mutex_t* replyLock;
};
void Individual(struct arg* a){
int toSend = rand() % 5;
int sendTo;
int sleepTime;
int status = 0;
int received = 0;
int k;
for (k = toSend; k > 0; k--){
sendTo = ... | 0 |
#include <pthread.h>
int mediafirefs_write(const char *path, const char *buf, size_t size,
off_t offset, struct fuse_file_info *file_info)
{
printf("FUNCTION: write. path: %s\\n", path);
(void)path;
ssize_t retval;
struct mediafirefs_context_private *ct... | 1 |
#include <pthread.h>
void *Producer(void *);
void *Consumer(void *);
sem_t empty;
sem_t full;
pthread_mutex_t mutex;
int g_data[20];
int main (int argc, char *argv[]) {
int N = atoi(argv[1]);
printf("%d", N);
pthread_t pid[N], cid[N];
sem_init(&empty, 0, 20);
sem_init(&full, 0, 0);... | 0 |
#include <pthread.h>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 init(QType *q)
{
q->head=0;
... | 1 |
#include <pthread.h>
struct data_queue socket_queue;
char* OK = " OK\\n";
char* MISSPELLED = " MISSPELLED\\n";
char* NEXT_WORD = "Enter next word or EOF to quit.\\n";
char ** dictionary;
int main(int argc, char** argv)
{
socket_queue.current_pos = 0;
socket_queue.top = 0;
socket_queue.Q_co... | 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;
int main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0... | 1 |
#include <pthread.h>
int buffer[10];
int inicio = 0, final = 0, cont = 0;
pthread_mutex_t bloqueio;
pthread_cond_t nao_vazio, nao_cheio;
void* produtor(void *v) {
int i, aux;
for (i = 0; i < 2 * 10; i++) {
pthread_mutex_lock(&bloqueio);
while (cont == 10) {
pthread_cond_wait... | 0 |
#include <pthread.h>
int value;
int divisors;
} result_t;
int g_max;
int g_next;
pthread_mutex_t g_next_mtx;
int g_step = 1;
result_t g_best;
int g_processed;
pthread_mutex_t g_best_mtx;
pthread_cond_t g_best_cnd;
int num_divisors(int v) {
int cnt = 0;
for (int i = 1; i <= v; i++)
if... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex;
int count;
int buffer[100];
int produce_item() {
return rand();
}
void consume_item(int item) {
return;
}
void *producer() {
int item;
while(1) {
item = produce_item();
if(count < 100) {
pthr... | 0 |
#include <pthread.h>
void init_recursos_jugadores() {
ronda_jugada = 1;
poner_manos = 0;
quitar_manos = 0;
manos_en_centro = 0;
cartas_recogidas = 0;
pthread_mutex_init( &manotazo , 0 );
pthread_mutex_init( &poner_mano , 0 );
pthread_mutex_init( &quitar_mano , 0 );
pthr... | 1 |
#include <pthread.h>
enum pattern_status pattern_port_sched_init(struct pattern * p) {
pthread_mutex_init(&p->port.mutex_running, 0);
pthread_mutex_init(&p->port.mutex_yielded, 0);
return pattern_ok;
}
enum pattern_status pattern_port_create_task(struct pattern_task * t) {
struct... | 0 |
#include <pthread.h>
struct data_array {
int count;
pthread_mutex_t lock;
} data[5];
void *threadFunc(void *id){
int num = *((int*)id);
for(int a=0; a<5; a++){
int rand_count = (rand() %100);
int rand_ptr = (rand() %5);
pthread_mutex_lock(&data[rand_ptr].lock);
printf("[%d]: Locked ... | 1 |
#include <pthread.h>
int stack[100][2];
int size=0;
sem_t sem;
pthread_mutex_t mutex;
void ReadData1(void){
FILE *fp=fopen("1.dat","r");
while(!feof(fp)){
pthread_mutex_lock(&mutex);
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
printf("%d\\n", size);
sem_post(&sem);
++size;
pt... | 0 |
#include <pthread.h>
struct thread_info {
pthread_cond_t cond;
pthread_mutex_t mux;
void *p;
};
void *
thread_func(void *p)
{
struct thread_info *info = p;
for (;;) {
pthread_mutex_lock(&info->mux);
pthread_cond_wait(&info->cond, &info->mux);
free(info->p);
pthread_mutex_unlock(&inf... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void *
thr_fn(void *arg)
{
int err, signo;
fprintf(stdout, "cat interrupt thread id: %d\\n", (int )pthread_self());
fprintf(stdout, "process id: ... | 0 |
#include <pthread.h>
const int round_max = 50000;
const int readers_max = 5;
const int writers_max = 10;
const int sleep_ms = 100;
item_t value;
int readers;
pthread_mutex_t write_lock;
pthread_mutex_t read_lock;
} data_t;
data_t* data;
int id;
} thread_t;
void* read_loop (void* ... | 1 |
#include <pthread.h>
void exitfunc(int sig)
{
_exit(0);
}
void compfunc(int a,int b,int c){
printf("There are %d signals that have been changed.\\n",a);
printf("There are %d signals that have been changed from 0 to 1.\\n",b);
printf("There are %d signals that have been detected.\\n",c);... | 0 |
#include <pthread.h>
int Q[20];
int front = -1;
int rear = -1;
int c = 0;
pthread_mutex_t mutex;
sem_t full;
sem_t empty;
void *Supervisor(void *arg){
while( c < -5) {
int student = (int)arg;
pthread_detach(pthread_self());
sem_wait(&empty);
pthread_mutex_lock(&mutex);
rear = rear + 1... | 1 |
#include <pthread.h>
struct pp_thread_info {
int *msgcount;
pthread_mutex_t *mutex;
pthread_cond_t *cv;
char *msg;
int modval;
};
void *
pp_thread(void *arg)
{
struct pp_thread_info *infop;
int c;
infop = arg;
while (*infop->msgcount < 50) {
... | 0 |
#include <pthread.h>
struct library_context context;
pthread_mutex_t services_mutex, remotes_mutex;
uint8_t init() {
DEBUG("init %d", context.initialized);
if (context.initialized)
return 1;
srand(time(0));
memset(context.services, 0, UINT16_MAX * sizeof(struct s... | 1 |
#include <pthread.h>
int Buf1_num=0;
int Buf2_num=0;
int Buf1[10];
int Buf2[10];
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void *thread_fun1(void *args);
void *thread_fun2(void *args);
void *thread_fun3(void *args);
int main(void)
{
... | 0 |
#include <pthread.h>
void usage(){
fprintf(stderr,"Usage: ./make_threads <no_threads> <sum_up_to>\\n");
}
unsigned long long global_sum;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
void * up_to_n(void *args){
int *n = args;
int i;
unsigned long long local_sum = 0;
f... | 1 |
#include <pthread.h>
struct testdata
{
pthread_mutex_t mutex;
pthread_cond_t cond;
} td;
int t1_start = 0;
int signaled = 0;
void *t1_func(void *arg)
{
int rc;
struct timespec timeout;
struct timeval curtime;
if (pthread_mutex_lock(&td.mutex) != 0) {
fprintf(stderr,"Thread1: Fail to a... | 0 |
#include <pthread.h>
uint32_t hash64(uint64_t a)
{
a = a ^ (a>>32);
a = (a+0x7ed55d16) + (a<<12);
a = (a^0xc761c23c) ^ (a>>19);
a = (a+0x165667b1) + (a<<5);
a = (a+0xd3a2646c) ^ (a<<9);
a = (a+0xfd7046c5) + (a<<3);
a = (a^0xb55a4f09) ^ (a>>16);
return (uint32_t)a... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
void decrement_count(int iter);
void increment_count(int iter);
void * thread_body(void * param) {
int i;
pthread_mutex_lock(&lock);
for(i = 0; i <= 10; ++i){
pthread_cond_signal(&cond);
printf("Child ... | 0 |
#include <pthread.h>
void buffered_queue_init(struct buffered_queue *queue, int size){
queue->size = size+1;
queue->buf = malloc(sizeof(void *) * (size+1));
queue->start_index = 0;
queue->end_index = 0;
pthread_mutex_init(&(queue->lock), 0);
pthread_cond_init(&(queue->cond)... | 1 |
#include <pthread.h>
pthread_mutex_t chopstick_mutexes[PHIL_COUNT];
pthread_mutex_t footman_mutex = PTHREAD_MUTEX_INITIALIZER;;
pthread_cond_t footman_cond = PTHREAD_COND_INITIALIZER;
int footman_count = 0;
void Init(void) {
int i;
for (i=0;i<PHIL_COUNT;i++)
pthread_mutex_ini... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void *worker_task(void *args)
{
pthread_mutex_lock(&mutex);
int id = *(int *)(args);
pthread_mutex_unlock(&mutex);
void *context = zmq_ctx_new();
printf("%d zmq_ctx_new\\n", id)... | 1 |
#include <pthread.h>
struct tm *getIsoTm(const struct timeval *t) {
return localtime((time_t*)(&(t->tv_sec)));
}
int getHundredthOfSeconds(const struct timeval *t) {
return (int)(t->tv_usec / 10000);
}
static FILE *openCoverageFile() {
char timestamp[128];
char name[6 +... | 0 |
#include <pthread.h>
double pi = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *work(void *arg)
{
int start;
int end;
int i;
start = (2000000/2) * ((int )arg) ;
end = start + 2000000/2;
for (i = start; i < end; i++) {
pthread_mutex_lock(&mutex);
p... | 1 |
#include <pthread.h>
uint16_t timestamp;
uint16_t state;
uint16_t magic;
} Data;
uint16_t time;
uint16_t timestamp;
uint16_t last_timestamp;
uint16_t first_timestamp;
uint8_t event;
} Channel;
uint8_t recognized[MAX_SENSOR];
inline uint16_t calc_timestamp_diff ( uint16_t time, ... | 0 |
#include <pthread.h>
pthread_mutex_t m_lock;
void *t_func(void *data)
{
int *count = (int*)data;
int tmp;
pthread_t thread_id = pthread_self();
while(1)
{
pthread_mutex_lock(&m_lock);
tmp = *count;
tmp++;
sleep(1);
*count = tmp;
... | 1 |
#include <pthread.h>
double **A, **B, **C;
int number_of_threads = 1;
int* matrix_part_size;
int** matrix_part;
int rowsA, rowsB, columnsA, columnsB;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double matrix_norm;
void *ThreadFunction(void* arg)
{
int i, x;
int thread_id = *((int*)ar... | 0 |
#include <pthread.h>
long int n_threads=0,n_iter = 0,sum=0;
long int i;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* runner(void* arg) {
double x,y;
unsigned int value;
long int ctr = 0,k=0;
for(k=0;k<n_iter/n_threads;k++){
x = rand_r(&value)/(double)32767;
y = rand_r(&val... | 1 |
#include <pthread.h>
int nbr_wait=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
void wait_barrier(int n){
pthread_mutex_lock(&mutex);
nbr_wait++;
if (nbr_wait<10) {
pthread_cond_wait(&cond, &mutex);
}
else {
pthread_cond_broadcast(&co... | 0 |
#include <pthread.h>
pthread_mutex_t total_grade_mutex;
pthread_mutex_t total_bellcurve_mutex;
pthread_barrier_t barrier;
float total_grade = 0;
float total_bellcurve = 0;
float grades[10];
void * save_bellcurve(void * grade);
void * read_grades();
int main(void){
pthread_t tid[10];
pthre... | 1 |
#include <pthread.h>
static pthread_mutex_t mutexLock;
double v[100];
int i2c_fd;
void ctrl_c(int sig)
{
close(i2c_fd);
exit(-1);
}
void *function_media()
{
double total = 0;
while(1)
{
sleep(1);
pthread_mutex_lock(&mutexLock);
for (int i = 0; i < 100; i++)
total += v[i];
pthrea... | 0 |
#include <pthread.h>
int costumersWaiting = 0;
int barbeiroOcupado = 0;
pthread_cond_t loja_cheia = PTHREAD_COND_INITIALIZER;
pthread_cond_t loja_vazia = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *barbeiro(void *args) {
while(1) {
pthread_mutex_lock(... | 1 |
#include <pthread.h>
static char send_buffer[2][1024];
static char receive_buffer[1024];
static pthread_mutex_t send_buffer_access;
static pthread_cond_t send_buffer_0_cv;
static pthread_cond_t send_buffer_1_cv;
static int sock_fd = 0;
int check_parameters_count(int argc){
if(argc != 2)
... | 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++;
if (count == 12) {
pt... | 1 |
#include <pthread.h>
char username[32];
int fd;
pid_t tid;
} chat_client_t;
chat_client_t clients[5];
int usercount = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct client_handler_params {
int fd;
char username[32];
};
void show_client_list() {
int i;
pthread_mutex_... | 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 ** bigMatrix[200];
int producerTotal = 0;
int consumerTotal = 0;
int buffer[200];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;
int producerSum = 0;
int consumerSum = 0;
int loops = 1200000;
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t fill = PTHR... | 0 |
#include <pthread.h>
int fd, op;
char word[32];
pthread_t *tids;
size_t n, nrec;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
int sig_num;
void *thread_func(void *arg) {
if(op == 4) {
sigset_t set;
sigemptyset(&set);
sigaddset(&set, sig_num);
pthread... | 1 |
#include <pthread.h>
struct thd_s {
int running;
pthread_t thd;
void (*func)(void);
pthread_mutex_t mutex;
pthread_cond_t cond;
};
static struct thd_s thread_handle[YAB_NUM_THREADS];
static pthread_key_t hnd_key;
static pthread_once_t hnd_key_once;
static void make_key() {
... | 0 |
#include <pthread.h>
int producerTotal = 0;
int consumerTotal = 0;
int buffer[100];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;
int producerSum = 0;
int consumerSum = 0;
int loops = 10000;
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t fill = PTHREAD_COND_INITIALIZER... | 1 |
#include <pthread.h>
struct session_slot_table *new_session_slot_table()
{
int i;
struct session_slot_table *sst;
sst = malloc(sizeof(*sst));
if (!sst) {
return 0;
}
sst->free_slots = new_bitset(SESSION_SLOT_TABLE_CAPACITY);
if (!sst->free_slots) {
free(sst);
return 0;
}
... | 0 |
#include <pthread.h>
double ff_get_sync_clock(struct ff_clock *clock)
{
return clock->sync_clock(clock->opaque);
}
int64_t ff_clock_start_time(struct ff_clock *clock)
{
int64_t start_time = AV_NOPTS_VALUE;
pthread_mutex_lock(&clock->mutex);
if (clock->started)
start_time = clock->start... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void* thread_worker(void*);
void critical_section(int thread_num, int i);
int main(void) {
int rtn, i;
pthread_t pthread_id = 0;
rtn = pthread_create(&p... | 0 |
#include <pthread.h>
static int buffer[16];
static pthread_mutex_t lock;
static pthread_cond_t empty;
static pthread_cond_t full;
static int counter = 0;
static int number_of_items;
static int number_consumers;
static int number_producers;
int thread_number;
int number_produced;
} p... | 1 |
#include <pthread.h>
static pthread_t n_thread;
static pthread_t w_thread;
static pthread_t s_thread;
static pthread_t e_thread;
static pthread_mutex_t monitor;
static pthread_cond_t activeN;
static pthread_cond_t activeW;
static pthread_cond_t activeS;
static pthread_cond_t activeE;
static pt... | 0 |
#include <pthread.h>
float hypotenuse;
pthread_mutex_t mutexsum;
void *square_side (void *);
int main (int argc, char **argv)
{
int i;
float sides[2];
pthread_t *thr_ids;
switch (argc)
{
case 3:
sides[0] = atof (argv[1]);
sides[1] = atof (argv[2]);
if ((sid... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
struct free_mem * free_list;
int mymalloc_init() {
struct free_mem * head;
pthread_mutex_lock(&lock);
if ((head = sbrk(PAGE)) == (void *) -1){
pthread_mutex_unlock(&lock);
return 1;
}
else{
head->size ... | 0 |
#include <pthread.h>
extern FILE *fileout_basicmath_conversion;
extern pthread_mutex_t mutex_print;
int main_basicmath_conversion(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 = -3... | 1 |
#include <pthread.h>
pthread_mutex_t timer_mutex;
pthread_cond_t timer_expired_cv;
void *wait_thread(void *time)
{
int time_to_wait = *((int*)time);
printf("wait_thread started\\n");
while (time_to_wait > 0)
{
usleep(1000000);
pthread_mutex_lock(&timer_mutex);
--time_to... | 0 |
#include <pthread.h>
int needQuit(pthread_mutex_t *mtx) {
switch (pthread_mutex_trylock(mtx)) {
case 0:
pthread_mutex_unlock(mtx);
return 1;
case EBUSY:
return 0;
}
return 1;
}
void *thread_do(void *arg) {
pthread_mutex_t *mx = arg;
int i = 0;
while (!n... | 1 |
#include <pthread.h>
int main(int argc, char* argv[]) {
int out1 = 0;
int out2 = 0;
int id;
SharedMem *ptr;
id = shmget (atoi(argv[1]), 0, 0);
if (id == -1){
perror ("child shmget failed");
exit (1);
}
ptr = shmat (id, (void *) 0, 1023);
if (ptr == (void *) -1){
... | 0 |
#include <pthread.h>
struct file_counter {
char *filename;
int words_count;
int id;
};
struct file_counter *mailbox = 0;
pthread_mutex_t mailbox_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t mailbox_cond = PTHREAD_COND_INITIALIZER;
void *count_words(void *file_counter_a);
int m... | 1 |
#include <pthread.h>
FILE *logfile = 0;
int open_logfile(char *filepath) {
logfile = fopen(filepath, "we");
if(!logfile) {
print(ERROR, "fopen: %s", strerror(errno));
return -1;
}
return 0;
}
void file_logger(int level, char *fmt, ...) {
va_list argptr;
if(!logfil... | 0 |
#include <pthread.h>
struct foo* fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo
{
int f_count;
pthread_mutex_t f_lock;
int id;
struct foo* next;
};
struct foo* foo_alloc(int id)
{
int idx;
struct foo* fp;
if ((fp = malloc(sizeof(struct foo... | 1 |
#include <pthread.h>
int globalInt = 0;
sem_t mySem;
pthread_mutex_t lock;
int running = 1;
int var1 = 0;
int var2 = 0;
void processTestVFork()
{
globalInt = 0;
printf("%s\\n", "************vfork*************");
int localInt = 0;
pid_t pid = vfork();
if(pid == 0){
for (int i = 0; i < 10; ... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cv;
pthread_key_t key;
int jobInfo[50];
int jobAvail = 0;
int i = 0;
int jobCount = 0;
void *slave(void *threadID)
{
int threadNum = *(int *)threadID;
int *local_job;
while(jobCount < 25)
{
pthread_mutex_lock(&m);
while(jobAvail < 1 ... | 1 |
#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;
... | 0 |
#include <pthread.h>
static pthread_mutex_t mem_lock;
unsigned mem_request_tag[MAX_DUMP_MEM_NUM];
unsigned mem_response_tag[MAX_DUMP_MEM_NUM];
struct http_request_header *mem_request_header[MAX_DUMP_MEM_NUM];
struct http_response_header *mem_response_header[MAX_DUMP_MEM_NUM];
void init_mem_... | 1 |
#include <pthread.h>
buffer_item buffer[5];
pthread_mutex_t mutex;
sem_t full;
sem_t empty;
int start;
int end;
int insert_item(buffer_item item){
int pos;
sem_wait(&empty);
pthread_mutex_lock(&mutex);
pos = start;
start = (start + 1)%5;
pthread_mutex_unlock(&mutex);
... | 0 |
#include <pthread.h>
volatile int x;
volatile int y;
volatile int past_x;
pthread_mutex_t lock_one;
pthread_mutex_t lock_two;
pthread_barrier_t barrier;
pthread_t threads[2];
void random_hog()
{
volatile unsigned long i, x;
unsigned long count = random() / (1 << 20) + 10000;
... | 1 |
#include <pthread.h>
pthread_t fid[1],cid[20];
pthread_mutex_t cpu=PTHREAD_MUTEX_INITIALIZER,s[20];
int num;
int remain;
int state;
int prio;
}pcb;
int prio;
int index;
}temp;
pcb thread[20],nThread[20];
temp pcbIns[20];
int total=0;
int first=0;
int waitTime=0;
void insertionSort(n){
... | 0 |
#include <pthread.h>
int K;
struct Node
{
int data;
struct Node* next;
};
struct list
{
struct Node * header;
struct Node * tail;
};
pthread_mutex_t mutex_lock;
struct list *List;
struct Node* generate_data_node(int n)
{
struct Node *ptr;
ptr = (struct Node *... | 1 |
#include <pthread.h>
struct spectrum_buffer* spectrum_input_buffers_head;
struct spectrum_buffer* spectrum_input_buffers_tail;
sem_t spectrum_input_buffer_sem;
int spectrum_input_sequence=0;
int spectrum_input_buffers=0;
pthread_mutex_t spectrum_input_buffer_mutex;
struct spectrum_b... | 0 |
#include <pthread.h>
extern struct destroyerRocket destRocket;
static void animateDestRocket();
static void initDestRocket(struct destroyer *);
void *shootDestRocket(void *args) {
struct destroyer *ship = args;
srand(getpid());
while (1) {
if (!destRocket.isAlive && destRocket.hit <... | 1 |
#include <pthread.h>
sem_t sem1;
pthread_mutex_t m1;
int contador = 0;
void func(int i){
int tid;
tid = i;
printf("Soy el Hilo %d\\n", tid);
sleep(tid*2);
pthread_mutex_lock(&m1);
contador = contador + 1;
if(contador != 5){
pthread_mutex_unlock(&m1);
sem_wait(&sem1);
printf("So... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.