text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int32_t payload[] = {0x01, 0x02, 0x03, 0x04, 0x05};
struct fgevent event = {ABI, 0, 0, 1, 5, &(payload[0])};
struct test_struct {
int has_been_rejected;
int has_answered;
sem_t *sem;
pthread_mutex_t *mutex;
struct fg_events_data *client_to_disable;
};
... | 1 |
#include <pthread.h>
struct Philosopher {
int courses_left;
};
struct State {
struct Philosopher *philo;
pthread_mutex_t locks[3];
pthread_cond_t conds[3];
bool *forks;
int id;
int num;
};
void *PrintHello(struct State *state) {
int id;
id = state->id;
while (state->philo->c... | 0 |
#include <pthread.h>
int id;
int arrival_time;
int processing_time;
int cpu_done_so_far;
int queue_no;
int create_flag;
int turnaround;
int quantum_used;
} process;
int time_slice;
} queue;
int num_queue;
int priority_boost;
int num_processes;
} details;
details * conf=0;
int c... | 1 |
#include <pthread.h>
unsigned int count;
unsigned int data[12];
int in;
int out;
pthread_mutex_t mutex;
pthread_cond_t empty;
pthread_cond_t full;
} buffer_t;
static buffer_t shared_buffer = {
.count = 0,
.in = 0,
.out = 0,
.mutex = PTHREAD_MUTEX_INIT... | 0 |
#include <pthread.h>
void add_opened_fork(struct afp_volume * volume, struct afp_file_info * fp)
{
pthread_mutex_lock(&volume->open_forks_mutex);
fp->largelist_next=volume->open_forks;
volume->open_forks=fp;
pthread_mutex_unlock(&volume->open_forks_mutex);
}
void remove_opened_fork(struct... | 1 |
#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 f_id;
struct foo * f_next;
};
struct foo *
foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) != 0) {
... | 0 |
#include <pthread.h>
void * alarm_func( void * arg );
int sec;
char msg[256];
FILE * fp;
pthread_t pt;
struct alarm_str * prev;
struct alarm_str * next;
} alarm_t;
alarm_t * head = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main( int argc, char ** argv ) ... | 1 |
#include <pthread.h>
pthread_t thread1, thread2;
static pthread_mutex_t verrou1, verrou2;
int var=5, N=10, i=1,j=1;
void *lire(void *nom_du_thread) {
pthread_mutex_lock(&verrou1);
printf(">lire variable = %d\\n",var);
for (i=0;i<N-1;i++) {
pthread_mutex_unlock(&verrou2);
pthread_mutex_... | 0 |
#include <pthread.h>
static void Hub_catchSignal(int sig);
static int _Hub_close(void);
static void Hub_close(void);
static void Hub_usage(char* arg0);
void Hub_exitError(void) {
Hub_Logging_log(INFO, "Terminating hub due to error condition");
exit(1);
}
void Hub_exit(void) {
... | 1 |
#include <pthread.h>
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cvFull = PTHREAD_COND_INITIALIZER, cvEmpty = PTHREAD_COND_INITIALIZER;
int queue[4], fll = 0, *tmpP = queue, *tmpC = queue;
void *producerFunction()
{
while(1)
{
pthread_mutex_lock(&mx);
prin... | 0 |
#include <pthread.h>
int sumaTiempos[2];
float prom[2];
pthread_mutex_t count_mutexs[2];
int tid;
double stuff;
} thread_data_t;
void *thr_func(void *arg) {
struct timeval startTime, finishTime;
int i=0;
thread_data_t *data = (thread_data_t *)arg;
printf("hello from thr_func, th... | 1 |
#include <pthread.h>
long data_type;
char data[1024];
} t_data;
int number;
int fd;
} tide;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *snd_message(void *arg);
void *rcv_message(void *arg);
int main(int argc,char *argv[]){
pthread_t snd... | 0 |
#include <pthread.h>
struct SharedData {
int isopen;
unsigned int front;
unsigned int count;
unsigned int bufsize;
char buf[16];
pthread_mutex_t mutex;
pthread_cond_t dataAvailable;
pthread_cond_t spaceAvailable;
};
void
initialize( struct SharedData * sptr )... | 1 |
#include <pthread.h>
int buf_1=0;
int buf_2=0;
pthread_mutex_t l1;
pthread_mutex_t l2;
int buf_3=0;
int buf_4=0;
pthread_mutex_t l3;
pthread_mutex_t l4;
void *prod1()
{
int aux=0;
while(1){
pthread_mutex_lock(l1);
if(buf_1 < 6){
aux=buf_1;
buf_... | 0 |
#include <pthread.h>
FILE *arq, *arqSaida;
int nThreads;
pthread_mutex_t arq_mutex;
void insereCaracteres(long int* cnt, char* s);
void merge(long int* a, long int* b);
void print(long int* c, FILE* arq);
void* ContaChar(void* arg)
{
char aux[1023 + 1];
size_t n = 0;
long int tem... | 1 |
#include <pthread.h>
int pthread_setspecific(pthread_key_t key, const void* value_const)
{
void* value = (void*) value_const;
struct pthread* thread = pthread_self();
if ( key < thread->keys_length )
return thread->keys[key] = value, 0;
pthread_mutex_lock(&__pthread_keys_lock);
assert(k... | 0 |
#include <pthread.h>
int total_num_eats = 100, exclusiveVar;
pthread_mutex_t chopstick[5];
pthread_cond_t cond_var;
void *eat(void *i);
int main()
{
int i;
for(i = 0; i < 5; i++)
{
if(pthread_mutex_init(&chopstick[i], 0) < 0)
{
fprintf(stderr, "Error: cold not initialize semaphore... | 1 |
#include <pthread.h>
volatile int shared_counter = 0;
pthread_t people[100];
pthread_mutex_t lock;
void* returnToChair() {
for(int i=0; i<1000;i++) {
pthread_mutex_lock(&lock);
shared_counter++;
pthread_mutex_unlock(&lock);
}
return 0;
}
int main(void) {
... | 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 f_id;
struct foo f_next;
};
struct foo * foo_alloc (int id )
{
struct foo * fp;
int idx;
if ((fp = (struct foo *) malloc (sizeof ... | 1 |
#include <pthread.h>
void *suma(void *rango);
pthread_mutex_t mtx;
pthread_cond_t cond;
int obtenidoRango;
pthread_attr_t attr;
int f=0;
pthread_t thread[10];
int main() {
int i=0, n=0, rango=0, *estado, pestado=0, nbytes=0, nreg=0;
estado=&pestado;
pthread_attr_init(&attr);
if(... | 0 |
#include <pthread.h>
union mynum {
long long longlong;
double flonum;
};
int nthreads;
int pleasequit=0;
long long maxiterations=0;
pthread_mutex_t maxiter_mutex=PTHREAD_MUTEX_INITIALIZER;
void * calculate(void *param) {
double localpi=0.0;
long long threadno=((union... | 1 |
#include <pthread.h>
int counter;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
void *doit(void *);
int main(int argc, char **argv)
{
pthread_t tidA, tidB;
pthread_create(&tidA, 0, doit, 0);
pthread_create(&tidB, 0, doit, 0);
pthread_join(tidA, 0);
pthread_join(tidB, 0);
ret... | 0 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t my_mutex[5];
pthread_cond_t cond[5];
void *test_mutex(void *tid)
{
int thread_id;
int rnd;
int *tt;
tt = tid;
thread_id = (int) *tt;
rnd = rand() % 5;
sleep(rnd);
printf(" starting %d \\n",thread_id);
pthread_... | 1 |
#include <pthread.h>
int ticketcount = 10;
pthread_mutex_t lock;
pthread_cond_t cond;
void* salewinds1(void* args)
{
while(1)
{
pthread_mutex_lock(&lock);
if(ticketcount > 0)
{
printf("windows1 start sale ticket!the ticket is:%d\\n",ticketcount);
ticketcount --;
if(ticketcount == 0... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[800];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
... | 1 |
#include <pthread.h>
pthread_mutex_t destination_lock;
int mutex_init(){
pthread_mutex_init(&destination_lock, 0);
return 1;
}
int set_global_stop_array(int floor, int value){
global_stop_array[floor]=value;
return 1;
}
int get_global_stop_array(int floor){
return global_stop_array[flo... | 0 |
#include <pthread.h>
bool isTimer = 0;
uint32_t g_ucsecond = 0;
bool bTImerStart = 0;
pthread_mutex_t timermutex;
void* timercounter(void* p) {
time_t old;
time_t new;
while(1) {
if(bTImerStart) {
pthread_mutex_lock(&timermutex);
old = time(0);
... | 1 |
#include <pthread.h>
int num;
pthread_t tid[256];
pthread_mutex_t count_mutex[256];
void *philosopher(void *arg)
{
int i = *(int *)arg;
int left_i, right_i;
if (i == 0)
left_i = num-1;
else
left_i = i-1;
right_i = i;
while (1)
{
sleep(rand... | 0 |
#include <pthread.h>
int stoj = 0, daryLovci = 0, daryZberaci = 0, ludiaVChrame = 0;
int VOLNY_CHRAM = 1, ZBERACI_DNU = 0, LOVCI_DNU = 0;
pthread_mutex_t mutexSynchronizacia = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condChram = PTHREAD_COND_INITIALIZER;
pthread_cond_t condLovci = PTHREAD_C... | 1 |
#include <pthread.h>
pthread_cond_t stable,
workshop,
santaSleeping,
elfWaiting,
santaWaitElf;
pthread_mutex_t elfAndReindeerCount,
elfwWaitingLock;
int minWait, maxWait;
int elfCount;
int reindeerCount;
int elfDoor;
void *reindeerThread(void *args)
{
while(1)
{
reindeerHelpe... | 0 |
#include <pthread.h>
static volatile int run_flag = 1;
pthread_mutex_t m ;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
pthread_cond_t w = PTHREAD_COND_INITIALIZER;
int done=0;
int sent=1;
float pitch_buffer[151];
float roll_buffer[151];
float avg_val[2]={0,0};
void do_when_interrupted()
{
ru... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
void *func(void *arg)
{
while (1)
{
pthread_mutex_lock(&mutex);
usleep(100);
if (pthread_mutex_trylock(&mutex2) == 0)
{
printf("Thread 1 surpassed\\n");
pthread_mu... | 0 |
#include <pthread.h>
int ticket = -1;
int usedTickets[100000000];
int lockValue = 0;
pthread_mutex_t mutex;
void *lock(void)
{
pthread_mutex_lock(&mutex);
}
void *unlock(void)
{
pthread_mutex_unlock(&mutex);
}
void *grabATicket(void *unused) {
lock();
int i;
bool... | 1 |
#include <pthread.h>
int playersDone = 0;
int playTimes[10];
pthread_mutex_t entryMutex = PTHREAD_MUTEX_INITIALIZER;
void* runClient(void*);
int main(int argc, char** argv)
{
int i;
char playTimeStr[80];
pthread_t clientThreads[3];
for(i = 0; i < 10; i++){
scanf("%d", &pla... | 0 |
#include <pthread.h>
pthread_mutex_t mut1=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mut2=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond4 = PTHREAD_CO... | 1 |
#include <pthread.h>
void add_to_global();
int global = 0;
pthread_mutex_t lock;
int main() {
int i;
int return_value;
pthread_t tid[10];
void *arg;
printf("Create threads with sleep().\\n");
return_value = pthread_mutex_init(&lock, 0);
if(return_value < 0) {
... | 0 |
#include <pthread.h>
static pthread_cond_t vsync;
static pthread_mutex_t vsync_lock = PTHREAD_MUTEX_INITIALIZER;
static int vsync_enabled = 0;
static struct timespec vsync_time;
static int fb_fd = -1;
static struct timespec ts_add_nsec(struct timespec* lhs, long nsec)
{
struct timespec resul... | 1 |
#include <pthread.h>
int m_error;
unsigned char *mapHead;
unsigned char *arenaHead;
int numBits;
int bmSize;
int memAvailable;
int numBlocksFree;
int scanner=0;
pthread_mutex_t lock;
int numNodesFreeList=0;
int memAvailable=0;
int Mem_Init(int size) {
static int initialized=0;
int pa... | 0 |
#include <pthread.h>
char atravessar_corda(int num, char monte);
char atravessar_a_pra_b (int num);
char atravessar_b_pra_a (int num);
pthread_mutex_t lock_atravessar = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_macacos_a_b_cont = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_macac... | 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>
void list_init(struct list_descriptor *list) {
list->head = list->tail = 0;
list->list_len = 0;
pthread_mutex_init(&(list->list_lock),0);
pthread_cond_init(&(list->list_newnode),0);
}
void *list_head(struct list_descriptor *list) {
void *ret;
struct list_node *ne... | 1 |
#include <pthread.h>
pthread_mutex_t I2Clock;
int i2c_device = 0;
int i2c_init(uint8_t addr) {
if(pthread_mutex_init(&I2Clock, 0)) {
printf("ERROR : cannot create mutex\\n");
return -2;
}
i2c_device = wiringPiI2CSetup(addr);
return i2c_device;
}
uint8_t I2Cread8(uint8_t addr, uint8_t... | 0 |
#include <pthread.h>
static int tun_open(void)
{
if (!*server.tundev)
return -1;
if ((server.tunfd = open(server.tundev, O_RDWR)) < 0)
return -1;
return 0;
}
struct in6_ifreq {
struct in6_addr ifr6_addr;
__u32 ifr6_prefixlen;
int ifr6_ifindex;
};
static int tun_alloc(void)
{
s... | 1 |
#include <pthread.h>
int global=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void*wait1(void*p){
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
global=1;
pthread_mutex_unlock(&mutex);
}
void*wait2(void*p){
pthrea... | 0 |
#include <pthread.h>
char buf[4];
int occupied;
int nextin, nextout;
pthread_mutex_t mutex;
pthread_cond_t more;
pthread_cond_t less;
} buffer_t;
buffer_t buffer;
void * producer(void *);
void * consumer(void *);
pthread_t tid[2];
main( int argc, char *argv[] )
{
int i;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
pthread_key_t key;
int counter;
void print(void)
{
char *string = (char*)pthread_getspecific(key);
printf("%s", string);
}
void *thread(void *arg)
{
int number;
pthread_mutex_lock(&mutex);
num... | 0 |
#include <pthread.h>
int balance = 1000;
pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER;
void *deposit(void *arg)
{
int amt = 50, i;
for(i=0; i<50; i++)
{
pthread_mutex_lock(&mutx);
balance = balance + amt;
pthread_mutex_unlock(&mutx);
}
return 0;
... | 1 |
#include <pthread.h>
unsigned int read_load = 0;
unsigned int write_load = 0;
pthread_mutex_t read_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t write_mutex = PTHREAD_MUTEX_INITIALIZER;
void * disk_load_checker(void * dev)
{
int last_read_bytes, last_write_bytes;
int old_state, old_type;... | 0 |
#include <pthread.h>
char buf[200] = {0};
pthread_mutex_t mutex;
pthread_cond_t cond;
unsigned int flag = 0;
void *func(void *arg)
{
while (flag == 0)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("本次输入了%d个字符\\n", strlen(buf));
memset(buf, 0, sizeof(bu... | 1 |
#include <pthread.h>
int producer_keep_running = 1;
pthread_mutex_t lock;
pthread_cond_t emptycond;
pthread_cond_t filledcond;
struct pid_node{
char* pid_str;
struct pid_node *next_node;
};
struct the_queue{
pid_node head_node;
int queue_current_size;
int queue_max_si... | 0 |
#include <pthread.h>
char **P;
pthread_mutex_t m;
pthread_cond_t cond;
} Est;
Est *E = 0;
void myInit(){
if(E == 0){
E = (Est*)malloc(sizeof(Est));
pthread_mutex_init(&E->m, 0);
pthread_cond_init(&E->cond, 0);
E->P = (char**)malloc(5*sizeof(char*));
}
}
int ubicar(char *nom, int k... | 1 |
#include <pthread.h>
int verbosity;
pthread_mutex_t mutex;
} __plugin_logging_t__;
static __plugin_logging_t__ __plugin_loging_data__;
int __lock_plugin_logging__(void)
{
pthread_mutex_lock(&__plugin_loging_data__.mutex);
return __plugin_loging_data__.verbosity;
}
void __unlo... | 0 |
#include <pthread.h>
pthread_mutex_t print_mutex;
pthread_mutex_t wait_chairs_mutex;
int wait_chairs_open = 5;
pthread_cond_t wait_chairs_cv;
sem_t customer;
sem_t barber;
void getHairCut (void *t) {
long my_id = *(long *)t;
pthread_mutex_lock (&print_mutex);
printf ("Customer: ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
static void *start(void *str)
{
char buffer[1024];
snprintf(buffer, sizeof (buffer), "thread in %s\\n", str);
printf("%s", buffer);
pthread_mutex_lock(&mutex);
return 0;
}
int main(int argc, char **argv)
{
char buffer[1024];
pthread_mut... | 0 |
#include <pthread.h>
void *Fvis1();
void *Fvis2();
void *Fvis3();
void *Fboss();
int nbotle_refr = 10;
int vis[3][2];
bool bossdo=0;
int i;
pthread_mutex_t refr;
pthread_t vis1,vis2,vis3, boss;
int main()
{
initscr();
pthread_create(&boss, 0, Fboss, 0);
pthread_create(&vis1, 0, Fvis1,... | 1 |
#include <pthread.h>
buffer_t buffer[10];
int buffer_index;
pthread_mutex_t buffer_lock;
pthread_cond_t full_cond, empty_cond;
void insertbuffer(buffer_t value) {
if (buffer_index < 10) {
buffer[buffer_index++] = value;
} else {
printf("Buffer overflow\\n");
}
}
buffe... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void sys_err(char *s,int ret)
{
fprintf(stderr,"%s error: %s\\n",*s,strerror(ret));
exit(1);
}
void *pthrd_fun(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
printf("hello ");
sleep(rand()%3);
p... | 1 |
#include <pthread.h>
int musicd_av_lockmgr(void **mutex, enum AVLockOp operation) {
switch (operation) {
case AV_LOCK_CREATE:
*mutex = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t));
pthread_mutex_init((pthread_mutex_t *)(*mutex), 0);
break;
case AV_LOCK_OBTAIN:
pthread_... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int shmid;
key_t key;
int SHMSZ = sizeof(int);
struct Stuff {
int* shm_ptr;
int tid;
};
enum { STATE_A, STATE_B, STATE_C, STATE_D } state = STATE_A;
pthread_cond_t condA = PTHREAD_COND_INITIALIZER;
pthread_cond_t con... | 1 |
#include <pthread.h>
struct prodcons {
int buffer[2];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct prodcons *prod) {
pthread_mutex_init(&prod->lock, 0);
pthread_cond_init(&prod->notempty, 0);
... | 0 |
#include <pthread.h>
pthread_t * ids;
int fl;
bool threadFlag = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int iloscRekordow;
int iloscWatkow;
void * threadFunc(void *);
void atexitFunc();
struct rekord{
int id;
char * txt;
};
int main(int argc, char const *argv[])
{
atexit(atex... | 1 |
#include <pthread.h>
int variable_global=0;
pthread_mutex_t verrou = PTHREAD_MUTEX_INITIALIZER;
struct data {
int *Tab1;
int *Tab2;
int i;
};
void * Mul(void * par){
pthread_t moi = pthread_self();
int resultat;
struct data *mon_D1 = (struct data*)par;
pthread_mutex... | 0 |
#include <pthread.h>
int rang;
int typeMsg;
int nbFois;
} Parametres;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
void thdErreur(int codeErr, char *msgErr, int valeurErr) {
int *retour = malloc(sizeof(int));
*retour = valeurErr;
fprintf(stderr, "%s: %d soit %s \\n", msgErr, c... | 1 |
#include <pthread.h>
void sfwrite(pthread_mutex_t *lock, FILE* stream, char *fmt, ...){
va_list ap;
__builtin_va_start((ap));
pthread_mutex_lock(lock);
vfprintf(stream, fmt, ap);
fflush(0);
pthread_mutex_unlock(lock);
;
}
| 0 |
#include <pthread.h>
bool
receiver_data_zlib(struct mux *mx, uint8_t chnum)
{
struct muxbuf *mxb = &mx->mx_buffer[MUX_IN][chnum];
struct mux_stream_zlib *stream = mx->mx_stream;
z_stream *z = &stream->ms_zstream_in;
uint16_t mss;
uint8_t *cmd = mx->mx_recvcmd;
size_t len, len1, len2, ta... | 1 |
#include <pthread.h>
struct FileLock* next;
FILE* file;
pthread_mutex_t mutex;
} FileLock;
pthread_mutex_t lock;
FileLock* buckets[ 32 ];
} LockTable;
static LockTable* _lockTable;
static pthread_once_t _lockTable_once = PTHREAD_ONCE_INIT;
static void
lock_table_init(... | 0 |
#include <pthread.h>
{
int index, pocetak, kraj, stupci;
pthread_mutex_t lock;
char *matrica;
}thr_struct;
void* thr_fun(void *arg)
{
int index = ((thr_struct*)arg)->index;
int pocetak = ((thr_struct*)arg)->pocetak;
int kraj = ((thr_struct*)arg)->kraj;
pthread_mutex_t... | 1 |
#include <pthread.h>
int value;
struct List* next;
} List;
List* head = 0;
List* tail = 0;
int elem_num;
pthread_mutex_t my_mutex;
sem_t my_sem;
void push_back(int value)
{
List* node = malloc(sizeof(List));
node->value = value;
node->next = 0;
if(head == 0) {
head = node;
tail = ... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer[5];
int in = 0, out = 0;
void *producer(void *ptr) {
int i;
for (i = 0; i < 100; i++) {
pthread_mutex_lock(&the_mutex);
while (((in + 1) % 5) == out)
pthread_cond_wait(... | 1 |
#include <pthread.h>
char buffer[9][18];
FILE *infile;
FILE *outfile;
int flag = 0;
int slot = 0;
int item_buff=0;
pthread_t produce;
pthread_t consume;
pthread_mutex_t buf_lock =PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t empty_slot=PTHREAD_COND_INITIALIZER;
pthread_cond_t avail_item=PTHRE... | 0 |
#include <pthread.h>
pthread_mutex_t balance_mutex;
int balance = 100;
int withdraw(int amount)
{
pthread_mutex_lock(&balance_mutex);
if (balance >= amount)
{
balance -= amount;
pthread_mutex_unlock(&balance_mutex);
return amount;
}
else
{
pthread_mutex_unlock(&balance_mute... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t empty = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t empty2 = PTHREAD_MUTEX_INITIALIZER;
int numInQ2,numInQ;
int size = 300000;
void putOnQ(int x) {
pthread_... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int a = 0;
void* testThreadPool(int *t) {
printf("thread start: %d\\n", *t);
for (;;) {
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
}
return (void*) 0;
}
int main() {
int thread_num = 5;
pthre... | 1 |
#include <pthread.h>
void *ft_overninethousand(void)
{
ft_putendl("oh no");
return (0);
}
void print_mem(void *mem)
{
int i;
char *str;
pthread_mutex_lock(&g_lock);
i = -1;
str = (char *)mem;
while (++i < 16)
{
if (str[i] > 33 && str[i] < 127)
write(1, &str[i], 1);
else
write(... | 0 |
#include <pthread.h>
{
int id;
int noproc;
int dim;
} parm;
{
int cur_count;
pthread_mutex_t barrier_mutex;
pthread_cond_t barrier_cond;
} barrier_t;
barrier_t barrier1;
double *finals;
int rootn;
void barrier_init(barrier_t * mybarrier)
{
pthread_mutexattr_t attr;
pthre... | 1 |
#include <pthread.h>
static pthread_mutex_t *ssl_lock_array = 0;
static void lock_callback(int mode, int type, char *file, int line) {
(void)file;
(void)line;
if(mode & CRYPTO_LOCK) {
pthread_mutex_lock(&(ssl_lock_array[type]));
}
else {
pthread_mutex_unlock(&(ssl_lock_array[typ... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int comeco = 0;
int tamanho = 0;
int buffer[10] = 0;
void imprimeBuffer(void){
int i;
}
void *producer(void *ptr)
{
int i;
for (i = 1; i <= 1000000000; i++) {
pthread_mutex_lock(&the_mutex);... | 1 |
#include <pthread.h>
char __resource[32 + 1];
unsigned long __resource_len = 0;
unsigned long __reader_count = 0;
pthread_mutex_t __write_mutex;
pthread_mutex_t __read_mutex;
void write_resource(unsigned long tid) {
char ch = 'a' + __resource_len % 26;
__resource[__resource_len] = ch;
... | 0 |
#include <pthread.h>
double now()
{
struct timeval tv;
gettimeofday(&tv, 0);
return tv.tv_sec * 1000000ll + tv.tv_usec;
}
FILE * fd;
char *file = "test_thread";
pthread_mutex_t input_queue;
void do_work(unsigned long buf)
{
}
void * work(void * data)
{
unsigned long line;
char buf... | 1 |
#include <pthread.h>
static pthread_mutex_t mtxCpt;
static FILE* f;
static pthread_mutex_t mtxAffichage;
static void print_prime_factors(uint64_t n)
{
uint64_t factors[MAX_FACTORS];
int j,k;
k=insererNombre(n,factors);
pthread_mutex_lock(&mtxAffichage);
printf("%ju: ",n);
for(j=0; j<k; j... | 0 |
#include <pthread.h>
static const int MAX_QUEUE_SIZE = 10;
static const int MAX_ITERATIONS = 100000;
pthread_mutex_t mutex;
pthread_cond_t cv_queue_not_full, cv_queue_not_empty;
struct node
{
int data;
struct node * next;
};
struct queue
{
int size;
struct node * head;
struc... | 1 |
#include <pthread.h>
int glob = 0;
pthread_mutex_t mtx;
void* threadFunc1(void *arg)
{
int loops = *((int *)arg);
int loc, j;
for(j=0;j<loops;j++)
{
pthread_mutex_lock(&mtx);
pthread_mutex_trylock(&mtx);
loc = glob;
loc++;
glob = loc;
pthread_mutex_unlock(&mtx);
}
}
void* t... | 0 |
#include <pthread.h>
int threadRunCounts[3] = {0};
int producerSleep = 0;
int consumerSleep = 0;
int queueMaxSize = 45;
int queue = 0;
pthread_mutex_t queueMutex;
int checkFinished() {
if((threadRunCounts[0] || threadRunCounts[1]) && threadRunCounts[2] > 1000)
return 0;
else
return 1;
}
... | 1 |
#include <pthread.h>
sem_t mutexOccupied;
sem_t mutexFree;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int slots[5];
int nrOfItems = 0;
void processArgs(unsigned* producers, unsigned* consumers, int argc, char* argv[]);
void rest(int duration);
void* consumer(void* arg);
void* produ... | 0 |
#include <pthread.h>
int hAliviados =0;
int mAliviadas=0;
int hTotal = 0;
int mTotal=0;
int numeroPessoasTotais;
int homens;
int homensEsperando;
int mulheres;
int mulheresEsperando;
pthread_mutex_t mutex;
pthread_cond_t condHomens;
pthread_cond_t condMulheres;
}dados;
static dados sharedD... | 1 |
#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_to... | 0 |
#include <pthread.h>
extern pthread_mutex_t __sfp_mutex;
extern pthread_cond_t __sfp_cond;
extern struct glue __sglue;
extern int __sfp_state;
static void __swalk_lflush()
{
register FILE *fp, *savefp;
register int n, saven;
register struct glue *g, *saveg;
pthread_mutex_lock(&__s... | 1 |
#include <pthread.h>
int comptador;
pthread_t ntid[100];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void barrera()
{
pthread_mutex_lock(&mutex);
comptador = comptador - 1;
if (comptador == 0) {
comptador = 100;
pthread_cond_b... | 0 |
#include <pthread.h>
sem_t clientes, foiChamado;
pthread_mutex_t mutex;
pthread_cond_t atendentes;
int proximoCliente, ultimoCliente;
void *Atendentes(void *arg){
int i, pid = * (int *) arg;
proximoCliente = pid;
while(1){
sem_wait(&clientes);
printf("Tem clientes na padaria!\\n")... | 1 |
#include <pthread.h>
{
struct aahdr *prev;
struct aahdr *next;
char fun[64];
char what[64];
size_t size;
unsigned short dummy;
unsigned short magic;
} AAHDR;
static pthread_mutex_t aa_mtx;
static AAHDR *top = 0;
static int aa_debug = 0;
static inline int
aahdr_... | 0 |
#include <pthread.h>
static const int min_eat_ms[5] = {10, 10, 10, 10, 10};
static const int max_eat_ms[5] = {20, 20, 20, 20, 20};
static const int min_think_ms[5] = {10, 10, 10, 10, 10};
static const int max_think_ms[5] = {20, 20, 20, 20, 20};
static int times_eaten[5];
static void philos... | 1 |
#include <pthread.h>
int available_resources = 5;
pthread_mutex_t mtx;
int increase_count(int arg) {
pthread_mutex_lock(&mtx);
available_resources += arg;
printf("Released %d resources, %d remaining.\\n", arg, available_resources);
pthread_mutex_unlock(&mtx);
return 0;
}... | 0 |
#include <pthread.h>
int divisor = 2;
int totalThread = 0;
pthread_mutex_t totalThreadMutex= PTHREAD_MUTEX_INITIALIZER;
struct threadInfo{
int threadNum;
int parentThreadCount;
};
int min(int a, int b){
if(a<=b){
return a;
}
else{
return b;
}
}
voi... | 1 |
#include <pthread.h>
pthread_t ntid1;
pthread_t ntid2;
pthread_t ntid3;
pthread_mutex_t f_lock;
char c = 'c';
void
printids(const char *s)
{
pid_t pid;
pthread_t tid;
pid = getpid();
tid = pthread_self();
printf("%s pid %u tid %u (0x%x)\\n", s, (unsigned int)pid,
(unsigned int)tid,... | 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->notempty,0);
pthread_cond_init(&b-... | 1 |
#include <pthread.h>
int arr[1000][1000];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void initArray()
{
int i = 0;
int j = 0;
for (i = 0; i < 1000; i++)
{
for (j = 0; j < 1000; j++)
{
srand(time(0));
arr[i][j] = rand() % 2;
... | 0 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t sum_lock;
int** matrix;
{
int rows;
int cols;
int p;
int id;
}thread_arg;
void *threadSum(void *threadargs){
thread_arg* my_args;
my_args = (thread_arg*) threadargs;
int my_rows = my_args->rows;
int my_cols = my_args->cols;
int my_p = my... | 1 |
#include <pthread.h>
void *TRAIN_SIMA(){
struct Seg *B = blocks2[8][5];
struct Seg *N = blocks2[8][5];
struct Seg *A = blocks2[0][0];
int i = 0;
B->blocked = 1;
B->change = 1;
while(!stop){
while(1){
if(train_link[1] && train_link[1]->halt == 0){
break;
}
usleep(1000);
}
pthread_mutex_loc... | 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>
pthread_t t[7];
pthread_mutex_t mtx[10], m;
int sum[10];
int val[10][1000];
int cnt;
void * doIt(void *arg) {
while(cnt < 5) {
pthread_mutex_lock(&m);
if(cnt >= 5) {
pthread_mutex_unlock(&m);
break;
}
pthread_mutex_un... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.