text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static pthread_mutex_t sync_lock = PTHREAD_MUTEX_INITIALIZER;
void
mos_atomic_add_32(uint32_t *dst, int32_t delta) {
pthread_mutex_lock(&sync_lock);
*dst += delta;
pthread_mutex_unlock(&sync_lock);
}
uint32_t
mos_atomic_add_32_nv(uint32_t *dst, int32_t delta) {
uint32_t... | 1 |
#include <pthread.h>
int max(int a, int b){
return ((a > b) ? a : b);
}
struct header {
unsigned short free;
struct header *next;
};
static const short W_SIZE = (sizeof (void *));
static const short H_SIZE = (sizeof (struct header));
static struct header *start = 0;
static long hea... | 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 initi... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int i = 0;
void* someThreadFunction1(){
for(int a = 0; a < 1000000; a++){
pthread_mutex_lock(&mutex);
i++;
pthread_mutex_unlock(&mutex);
}
return 0;
}
void* someThreadFunction2(){
for(int a = 0; a < 999999; a++){
pthread_mutex_lock(&... | 0 |
#include <pthread.h>
char *read_text;
pthread_mutex_t mutex_lock;
int result_counter = 0;
void *write_read_text(void *YouCantWorkWithoutME){
int write_status = 1;
int is_end = 0;
while(is_end != 1){
pthread_mutex_lock(&mutex_lock);
printf("xaxa");
write_status = write(STDOUT_FILENO,read... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
char *test ="send";
char *test2 =".";
char *test3= "Type the name of the file u want to receive\\n";
char *message= "Iste su extensions mozemo da nastavimo sa slanjem\\n";
char ... | 0 |
#include <pthread.h>
static int
open_communication (void)
{
int soc;
struct sockaddr_in addr;
if ((soc = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
my_printf("%s: socket failed %s\\n", __FUNCTION__, strerror(errno));
return -1;
}
my_printf("%s:... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int count = 0;
void* consume( void *arg)
{
while(1 )
{
pthread_mutex_lock(&mutex );
printf("************************consumebegin lock\\n");
printf("************************consumed%d\\n",count );
sleep(2);
co... | 0 |
#include <pthread.h>
int min(int a, int b) {
if(a > b) return b;
else return a;
}
struct input {
int num;
int cT;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int divisor = 2;
int curThread = 0;
int timecount = 0;
void *createThread(void *input) {
struct input *in = input;
int act... | 1 |
#include <pthread.h>
pthread_t *threads;
pthread_mutex_t mutex;
int threads_count, records_count, fd;
char* word;
void* thread_func(void *data){
pthread_t self;
int read_count,i,j,record_id,actual_read_count,word_len;
char *buf,*ptr;
int k;
buf=malloc(1024*records_count);
pthread_setc... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_x= PTHREAD_MUTEX_INITIALIZER;
static char *pindex[10];
static int ind = 0;
void initarray()
{
int i=0;
pindex[0] = (char*)malloc(10*32);
for(i=1;i<10;i++)
pindex[i] = pindex[i-1]+32;
for(i=0;i<10;i++)
printf("%d=%p\\n",i,pindex[i]);
... | 1 |
#include <pthread.h>
struct thread_pool_queue_node {
struct thread_pool_task *task;
struct thread_pool_queue_node *next;
};
struct thread_pool_queue {
unsigned int n_tasks;
struct thread_pool_queue_node *head_node;
struct thread_pool_queue_node *tail_node;
pthread_... | 0 |
#include <pthread.h>
int ticket=20;
pthread_mutex_t lock;
void* salewinds1(void* args){
while(1){
pthread_mutex_lock(&lock);
if(ticket>0){
sleep(1);
printf("windows1 start sale ticket!the ticket is:%d\\n",ticket);
sleep(2);
ticket--;
printf("w1 sale ticket finish!the last tick... | 1 |
#include <pthread.h>
const int RMAX = 100;
void Usage(char* prog_name);
void Get_args(int argc, char* argv[], int* n_p, char* g_i_p);
void Generate_list(int a[], int n);
void Print_list(int a[], int n, char* title);
void Read_list(int a[], int n);
void Bubble_sort(void * voi);
int block_size=... | 0 |
#include <pthread.h>
struct sprite_listnode
{
struct tb_sprite *sprite;
struct sprite_listnode *next;
};
static enum tb_color sprite_color(struct tb_sprite *sprite, int x, int y);
static struct sprite_listnode *sprites;
static pthread_mutex_t list_lock = PTHREAD_MUTEX_INITIALIZER;
static pthre... | 1 |
#include <pthread.h>
char *inet_ntoa(struct in_addr in)
{
static pthread_mutex_t inet_ntoa_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_key_t inet_ntoa_key = -1;
char *buf, *inet_ntoa_r();
if (inet_ntoa_key < 0) {
pthread_mutex_lock(&inet_ntoa_mutex);
if (inet_ntoa_key < 0) {
if (... | 0 |
#include <pthread.h>
const int DEF_THREAD_COUNT = 4;
const int DEF_FIB_MAX = 40;
{
int n;
int result;
pthread_mutex_t *access;
int work;
} fib_params_t;
int fib(int n)
{
if (n <= 0)
return 0;
else if (n == 1)
return 1;
return fib(n - 1) + fib(n - 2);
}
void *fib_thread(void *param... | 1 |
#include <pthread.h>
void comprar_baraja(int cartas[]) {
int i , j , k = 0 , l;
for(l = 0; l < BARAJAS; ++l){
for(i = 0; i < PINTAS; ++i){
for(j = 0; j < CARTAS_EN_PINTA; ++j){
cartas[k] = j;
++k;
}
}
}
}
void barajar_cartas(int cartas[],int num_cartas) {
... | 0 |
#include <pthread.h>
struct timer_mem_t
{
timer_t timerid;
struct sigevent sev;
unsigned int dspip;
int clifd;
unsigned short recvport;
};
static pthread_mutex_t timer_lock = PTHREAD_MUTEX_INITIALIZER;
static struct timer_mem_t * dsp_timer[128] = {0};
static int dsptimer_stor... | 1 |
#include <pthread.h>
int shops[5];
pthread_mutex_t m1=PTHREAD_MUTEX_INITIALIZER;
void shoping(int*need){
int buy, namber;
while((*need)!=0){
pthread_mutex_lock(&m1);
namber=rand()%5;
buy=450+rand()%51;
if(shops[namber]>buy){
shops[namber]-=buy;
(*need)-=buy;
if((*... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
int num;
pthread_mutex_t m;
pthread_cond_t empty, full;
void * thread1(void * arg)
{
pthread_mutex_lock(&m);
while (num > 0)
pthread_cond_wait(&empty, &m);
num++;
pthread_mutex_unlock(&m);
pthread_cond_signal(&full);
}
... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int num;
pthread_mutex_t m;
pthread_cond_t empty, full;
void * thread1(void * arg)
{
pthread_mutex_lock(&m);
while (num > 0)
pthread_cond_wait(&empty, &m);
num++;
pthread_mutex_unlock(&m);
pthread_cond_signal(&full);
}
... | 0 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
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... | 1 |
#include <pthread.h>
void all_or_nothing_put(char data[], char file_to_write[], int tid)
{
char data_to_write[MAX];
strcpy(data_to_write, data);
struct FileSector obj1;
find_sectors(file_to_write, &obj1);
check_and_repair(&obj1);
printf("Update...Check And Repair Passed\\n\\n");
printf("U... | 0 |
#include <pthread.h>
struct {
int exit;
int run;
const struct silly_config *conf;
pthread_mutex_t mutex;
pthread_cond_t cond;
} R;
static void *
thread_timer(void *arg)
{
(void)arg;
for (;;) {
silly_timer_update();
if (R.exit)
break;
usleep(5000);
if (silly_worker_msgsize() >... | 1 |
#include <pthread.h>
void* producer(void *ptr);
void* consumer(void* ptr);
static char buffer[1024];
pthread_mutex_t mutexA = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexB = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexC = PTHREAD_MUTEX_INITIALIZER;
int main(){
pthread_t proThread, con... | 0 |
#include <pthread.h>
int sem_trywait(sem_t *sem)
{
int result = 0;
if (!sem)
{
result = EINVAL;
}
else if (!pthread_mutex_lock(&sem->mutex))
{
if (sem->value > 0)
(sem->value)--;
... | 1 |
#include <pthread.h>
int sum;
pthread_mutex_t mtx, mt[2];
pthread_t t[2];
struct package {
pid_t pid;
int sum;
};
void* doIt(void *arg) {
int i, id = *(int *)arg;
for(i = 0; i < 5; ++ i) {
pthread_mutex_lock(&mt[id]);
int x = rand() % 100;
sum += x;... | 0 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void
thread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
pthread_mutex_... | 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){
printf("sigwai... | 0 |
#include <pthread.h>
int
timer_settime (timer_t timerid, int flags, const struct itimerspec *value,
struct itimerspec *ovalue)
{
struct timer_node *timer;
struct thread_node *thread = 0;
struct timespec now;
int have_now = 0, need_wakeup = 0;
int retval = -1;
timer = timer_... | 1 |
#include <pthread.h>
struct mt {
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
void sys_error(const char* des,int exitNum){
perror(des);
exit(exitNum);
}
int main(){
int fd,i,nReturnValue;
struct mt *m;
pid_t pid;
umask(0);
if( -1 == (fd=open("mt_test",O_CREAT |... | 0 |
#include <pthread.h>
pthread_mutex_t cntr_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cntr_cond = PTHREAD_COND_INITIALIZER;
long protVariable = 0L;
void *producer(void *arg) {
int i;
for (i=0;i<10000;i++) {
pthread_mutex_lock(&cntr_mutex);
printf("Producer:make %d, product:%d\\n", i,... | 1 |
#include <pthread.h>
void* whattodo(void* arg);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main()
{
pthread_t tid[8];
int i, rc;
int *t;
for (i = 0; i < 8; i++) {
t = malloc(sizeof(int));
*t = 2+(i*2);
rc = pthread_create( &tid[i], 0, whattodo, t);
if (rc != 0) ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t even = PTHREAD_COND_INITIALIZER;
pthread_cond_t odd = PTHREAD_COND_INITIALIZER;
void *printfun1(void *pnt);
void *printfun2(void *pnt);
int main(void)
{
pthread_t pthread1, pthread2;
int ret1, ret2;
... | 1 |
#include <pthread.h>
struct lock_value{
int count;
pthread_mutex_t lock1;
pthread_mutex_t lock2;
};
void *thr_fn1(void *arg)
{
struct lock_value *lock;
lock = (struct lock_value*)arg;
pthread_mutex_lock(&(lock->lock1));
printf("pthread 1 get the lock1\\n");
sleep(2);
lock->count ++;
pr... | 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 queu... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_t... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
long long total_tosses;
long long total_in_circle;
pthread_mutex_t mutex;
void* Monte_Carlo (void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
int main(int argc, char* argv[])
{
long thread... | 1 |
#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);;
if( j )
printf("hola\\n");
else
printf("adios\\n");
} else {
pthread_mutex_lock(&c);;
}... | 0 |
#include <pthread.h>
static pthread_mutex_t *mutex_arr= 0;
void locking_function (int mode, int n, const char * file, int line)
{
(void) file;
(void) line;
if (mode & CRYPTO_LOCK)
pthread_mutex_lock(&(mutex_arr[n]));
else
pthread_mutex_unlock(&(mutex_arr[n]));
}
unsi... | 1 |
#include <pthread.h>
int num;
unsigned long total;
int flag;
pthread_mutex_t m;
pthread_cond_t empty, full;
void *thread1(void *arg) {
int i;
i = 0;
while (i < 4) {
pthread_mutex_lock(&m);
while (num > 0)
pthread_cond_wait(&empty, &m);
num++;
printf("produce ....%... | 0 |
#include <pthread.h>
int * thread_counter;
int total_counter = 0;
int * test_array;
int i, length, t;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * count3s(void * arg){
int id = *((int *) arg); id--;
int length_per_thread = length/t;
int start = id *length_per_thread;
for... | 1 |
#include <pthread.h>
static pthread_mutex_t gAtExitLock = PTHREAD_MUTEX_INITIALIZER;
void _thread_atexit_lock( void )
{
pthread_mutex_lock( &gAtExitLock );
}
void _thread_atexit_unlock( void )
{
pthread_mutex_unlock( &gAtExitLock );
}
| 0 |
#include <pthread.h>
const unsigned int MAX_BUFF_SIZE = 1024;
const unsigned int MAX_WORD_LEN = 128;
const unsigned int MAX_FNAME_LEN = 256;
{
eFILE_NOT_FOUND = -1,
eGENERIC_FAILURE = 0,
eGENERIC_SUCCESS = 1,
}_ERROR_CODES;
unsigned int getNumOfWordsinParag(char *inputFileName);
void *pr... | 1 |
#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_to... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void* th(void* p) {
int i;
sleep(4);
for (i = 0; i < 10; i++) {
pthread_mutex_lock(&mutex);
printf("thread %d : wait signal\\n", (int) pthread_self());
pthread_cond_wait(&cond, &mutex);
... | 1 |
#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) {... | 0 |
#include <pthread.h>
char string[100];
pthread_t thr_id_1;
pthread_t thr_id_2;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond, cond1;
int read = 0;
void *thread_1()
{
pthread_mutex_lock(&lock);
while (1) {
pthread_cond_wait(&cond, &lock);
printf("t... | 1 |
#include <pthread.h>
const int BUFFER_LENGTH = 100;
int buffer[BUFFER_LENGTH];
int front = 0, rear = -1;
int size = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t empty_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t full_cond = PTHREAD_COND_INITIALIZER;
bool producer_wait... | 0 |
#include <pthread.h>
double bank_balance = 0.0;
double ivan_account = 0.0;
double petar_account = 0.0;
pthread_mutex_t mutex;
void deposit(double amount, double *to) {
*to += amount;
bank_balance += amount;
}
void withdraw(double amount, double *from) {
*from -= amount;
bank_balance -= a... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void ThreadClean(void *arg)
{
pthread_mutex_unlock(&mutex);
}
void * child1(void *arg)
{
while(1){
printf("thread 1 get running \\n");
printf("thread 1 pthread_mutex_lock returns %d\\n", pthread_mutex_lock(&mutex));
p... | 0 |
#include <pthread.h>
int var;
pthread_mutex_t mymutex;
void *my_thread(void *arg)
{
int n = 10000, i = 0, m = 0;
pthread_mutex_lock(&mymutex);
m = var;
m++;
var = m;
for(i = 0; i < n; i++);
m = var;
m--;
var = m;
pthread_mutex_unlock(&mymutex);
pthread_exit(0);
}
int main(void)... | 1 |
#include <pthread.h>
int read_cnt = 0;
int write_flag = 1;
pthread_mutex_t read_m, access_m, write_m;
int cnt = 3;
void* read_rt(void *arg);
void* write_rt(void* arg);
int main()
{
pthread_t read_tid, write_tid;
pthread_mutex_init(&read_m, 0);
pthread_mutex_init(&access_m, 0);
pthre... | 0 |
#include <pthread.h>
float width;
float rsum = 0.0;
pthread_mutex_t mutex1;
void *trapeziod(void *thing)
{
float partial_sum = 0.0;
int me = *((int *)thing);
double h1;
double h2;
h1 = sqrt(4.0 - me*width*me*width);
h2 = sqrt(4.0 - (me*width +width)*(me*width+width));
partial_sum = ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t roomEmpty;
int n_lectores=0;
void *escritor(){
while(1){
sem_wait(&roomEmpty);
printf("Escribiendo\\n");
sem_post(&roomEmpty);
sleep(1);
}
}
void *lector(){
while(1){
sem_post(&roomEm... | 0 |
#include <pthread.h>
void* handle_clnt(void *arg);
void send_msg(char *msg, int len);
void error_handling(char *msg);
int clnt_cnt = 0;
char message[1024];
int clnt_socks[256];
pthread_mutex_t mutx;
int main(int argc, char *argv[])
{
int serv_sock,clnt_sock;
struct sockaddr_in serv_adr, clnt_... | 1 |
#include <pthread.h>
char buf[10];
size_t len;
pthread_mutex_t mutex;
pthread_cond_t can_produce;
pthread_cond_t can_consume;
} buffer_t;
int index = 0;
int written = 0;
int n1;
char *s1;
FILE *fp ;
int readf(FILE * fp){
if((fp=fopen("messages.txt","r"))==0){
... | 0 |
#include <pthread.h>
char buffer_teste[40];
int *iniciaTransporte(){
int te, tr;
pthread_t te_trans, tr_trans;
te = pthread_create(&te_trans, 0, prod_Transporte, 0);
if (te) {
printf("ERRO: impossivel criar a thread");
exit(-1);
}
tr = pth... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int requests =3;
{
int thread_no;
char message[100];
} thdata;
thdata data[4];
pthread_t station_tid[2];
pthread_t machine_tid[4];
void runMachine(void *ptr);
void setup(int stations, int machines);
void release(int machine);
int alloca... | 0 |
#include <pthread.h>
int res = 12345 ;
int * px = 0 ;
int * py = 0 ;
pthread_mutex_t verroupx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t verroupy = PTHREAD_MUTEX_INITIALIZER;
void* mon_threadpx(void * arg){
int max = *(int*)arg ;
int i ;
for(i = 0 ; i < max ; i++ ){
pthread_mutex_lo... | 1 |
#include <pthread.h>
void * writer (void * id);
void * dove (void * id);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t fullOfLetters,
emptyOfLetters;
const int LETTERS = 30,
WRITERS = 50;
int lettersIn = 0;
int main (int argc, char * argv[])
{
pthread_t doveThread,
writerTh... | 0 |
#include <pthread.h>
void _scoks_queue_lock(struct _socks_queue_t* q)
{
pthread_mutex_lock(&q->_lock);
}
void _scoks_queue_unlock(struct _socks_queue_t* q)
{
pthread_mutex_unlock(&q->_lock);
}
struct _socks_queue_t* socks_queue_alloc()
{
struct _socks_queue_t* q = (struct _socks_queue... | 1 |
#include <pthread.h>
void *wolfThread(){
int i;
int color[3] = {0xFF1F05,0xAF2A00,0xDF3800};
int setcolor;
int lednum = 0;
int ledcolor = 0;
int sleeptime = 2000000;
int sleepmin = SLEEPMIN;
int sleepmax = SLEEPMAX;
printf("Start Wolf effect\\n");
for(i=0;i<(LEDANZ-1);i=i+2){
set... | 0 |
#include <pthread.h>
int total_all=0;
int total_word=0;
int total_char=0;
int total_line=0;
int find_longline=0;
int check=0;
pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
int main(int ac, char *av[])
{
pthread_t t;
int che;
int i;
void *count_all(void *);
void *count_char(void ... | 1 |
#include <pthread.h>
void fifo_init(struct fifo_wait *wait) {
memset(wait, 0, sizeof(struct fifo_wait));
pthread_mutex_init(&wait->mutex, 0);
pthread_cond_init(&wait->cond, 0);
wait->head = wait->tail = 0;
}
void fifo_destroy(struct fifo_wait *wait) {
pthread_mutex_destroy(&wait-... | 0 |
#include <pthread.h>
char *str_clear_crlf(char *s)
{
int i = strlen(s) - 1;
if(s)
{
for(int j = i;j >= 0;j--)
{
if(s[j] == '\\n' || s[j] == '\\r')
{
s[j] = 0;
}
else
{
break;
... | 1 |
#include <pthread.h>
int dequeue_is_waiting = 0;
pthread_mutex_t dequeue_is_waiting_mutex;
pthread_cond_t dequeue_is_waiting_cond;
int enqueue_is_waiting = 0;
pthread_mutex_t enqueue_is_waiting_mutex;
pthread_cond_t enqueue_is_waiting_cond;
const size_t smpl_size = sizeof (jack_default_audio_sa... | 0 |
#include <pthread.h>
void *takeoffFunc (void *ptr);
void *landingFunc (void *ptr);
int ARRAY_landing [10], ARRAY_lane [10];
pthread_mutex_t lock;
int main(int argc, char *argv[])
{
int question = 0;
int num = 0;
int plane_Cont = 0;
int x = 0;
int lane_Cont = 0;
int ux = 0;
int vx = 0;
int gx = ... | 1 |
#include <pthread.h>
int VT_mc34704_SU_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc34704_SU_cleanup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc34704_test_SU(void) {
int rv = TPASS, fd;
int event = EVENT_FLT5;
fd = open(MC34704_DEV... | 0 |
#include <pthread.h>
unsigned short itpf_gate(const unsigned short nnn, struct cp8_ctx *cp8) {
unsigned char x, y;
unsigned short next = 2;
switch (nnn & 0xff) {
case 0x07:
pthread_mutex_lock(&cp8->mtx);
cp8_vreg(cp8_asm_var(x, nnn), cp8) = cp8->dt;
... | 1 |
#include <pthread.h>
struct readerArgs
{
int fd;
size_t number;
};
ssize_t pgetLine(int fd, char *str, size_t maxLength, off_t offset);
void getCurrentTime(char *str, size_t maxLength);
void* readerFunc(readerArgs *args);
void* writerFunc(void *fd);
void clearResources(int fd);
pthread_mu... | 0 |
#include <pthread.h>
extern char reducer_pool[5*500];
extern pthread_mutex_t reducer_lock;
char summarizer_pool[5*500];
int letter_table[256]={0};
pthread_mutex_t table_lock=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t summarizer_lock=PTHREAD_MUTEX_INITIALIZER;
sem_t sem_read2,sem_write2;
extern ... | 1 |
#include <pthread.h>
pthread_mutex_t sharedMutex;
pthread_cond_t notEmptyCond;
int isEmpty = 1;
int isDone = 0;
int numOfThreads = 0;
int rc = 0;
struct _linked_list* lst;
int value;
struct _list_node* next;
struct _list_node* prev;
}list_node;
list_node* head;
list_node* tail... | 0 |
#include <pthread.h>
int row1, col1, row2, col2, currentRow = 0, currentCell = 0,flag, Matrix1[5005][5005], Matrix2[5005][5005], Result_Mat[5005][5005];
pthread_t * threads;
int numberOfThreads;
pthread_mutex_t mutex_Cell = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_threshold_cv = PTHREAD_... | 1 |
#include <pthread.h>
int seqNo;
char legend[20];
} item_t;
pthread_mutex_t mutex;
pthread_cond_t notFull;
pthread_cond_t notEmpty;
int cnt;
int first, last;
item_t* buf[15];
} buffer;
int tot = 0;
buffer buf = { .first = 0, .last = 15 -1, .cnt = 0 };
void store(int j, buffer *pb){
i... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t buyer[1005];
int sum = 0 ;
int buy = 0, nobuy = 0;
void* buyphone(){
pthread_mutex_lock(&mutex) ;
if( sum >= 800 )
{
printf("I can't buy\\n");
nobuy ++ ;
pthread_mutex_unlock(&mutex);
pthread_ex... | 1 |
#include <pthread.h>
char** theArray;
pthread_mutex_t mutex;
pthread_mutex_t fileMutex;
int count;
double times[MAX_THREADS];
void WriteFile(){
FILE* fp;
fp = fopen("results/mutex_results.txt", "a");
if (fp == 0)
{
fp = fopen("results/mutex_results.txt", "w+");
}
... | 0 |
#include <pthread.h>
int upper(char *path)
{
FILE* fp1, *fp2;
int c = 1;
fp1= fopen (path, "r");
fp2= fopen (path, "r+");
if ((fp1== 0) || (fp2== 0)) {
perror (path);
return errno;
}
while (c !=EOF) {
c=fgetc(fp1);
if (c!=EOF)
... | 1 |
#include <pthread.h>
void handler_SIGINT(int signum);
void rstrip_newline(char * aStr);
struct serverstat_t
{
unsigned mTotalAccessSec;
unsigned mTotalRequests;
};
struct serverstat_t gServerStats;
pthread_mutex_t gReportingMutex;
int main(int argc, char * argv[])
{
srand(time(0));
... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cv1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cv2 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t ready_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t ready_c... | 1 |
#include <pthread.h>
long cember = 0;
long nokta_sayisi;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *runner(void *arg) {
long runner_ici = 0;
unsigned int rand_state = rand();
long i;
for (i = 0; i < nokta_sayisi; i++) {
double z;
double x = rand_r(&rand_state) / ((double) 3276... | 0 |
#include <pthread.h>
int num = 0;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
void *add(void *arg)
{
int i = 0,tmp;
for(; i < 500; i++){
pthread_mutex_lock(&mylock);
tmp = num + 1;
num = tmp;
printf("+1, result is:%d\\n",num);
pthread_mutex_unlock(&mylock);
}
}... | 1 |
#include <pthread.h>
unsigned char onebyte[4096];
} BigMEMBlock;
unsigned long long numblocks = (51ULL * 1024) * 1024 * 1024 / sizeof(BigMEMBlock);
int numworkers = 1;
int runtime = 30;
int prepare = 5;
size_t MEMBLOCKSIZE = sizeof(BigMEMBlock);
BigMEMBlock* mfd;
pthread_t *tid;
pthread_mutex... | 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 = malloc(sizeof(struct foo))) != 0) {... | 1 |
#include <pthread.h>
void* funProd(void *arg);
void* funKons(void *arg);
struct bufCykl
{
int dane[16];
int we;
int wy;
int licznik;
};
int odczyt(struct bufCykl *buf);
void zapis(struct bufCykl *buf, int wartosc);
pthread_mutex_t semafor = PTHREAD_MUTEX_INITIALIZER;
int main()
{
s... | 0 |
#include <pthread.h>
void* thr_func(void* arg);
static int globvar = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char* argv[])
{
int nloop;
int thr_ret, i;
pthread_t thrID1, thrID2, thrID3;
if (argc != 2) {
fprintf(stderr, "Uso: %s <num ... | 1 |
#include <pthread.h>
void init_globals(struct globals_t* g)
{
memset(g, 0, sizeof(struct globals_t));
pthread_mutex_init(&g->mutex, 0);
ssh_threads_set_callbacks(ssh_threads_get_pthread());
if (ssh_init() == -1) {
fprintf(stderr, "ssh_init() failed\\n");
exit(1);
}
g->sshbind = ssh_bin... | 0 |
#include <pthread.h>
pthread_mutex_t roomLock;
pthread_cond_t occupancy;
unsigned int maximum, current, studentID, numOfThread, numOfStudents;
sem_t question, profAvail, done;
void
EnterOffice( int id ) {
pthread_mutex_lock( &roomLock );
while( current == maximum )
pthread_cond_wait( ... | 1 |
#include <pthread.h>
struct collatz {
int length;
int input;
} global_collatz;
struct test_range {
int min;
int max;
};
int CollatzLength(int n);
void* LongestCollatz(void* range);
const int maxValue = 1000000;
int thread_count;
pthread_mutex_t the_mutex;
int main(int argc, const char... | 0 |
#include <pthread.h>
struct ringbuf {
int ring[1000];
int tip, tail;
int ringfull, ringempty;
int readcount;
int reading, writing;
pthread_mutex_t *resourcelock;
pthread_mutex_t *readaccess;
pthread_cond_t *cond;
pthread_cond_t *allowread;
pthread_cond_t ... | 1 |
#include <pthread.h>
unsigned value = 0;
pthread_mutex_t m;
unsigned inc_flag = 0;
unsigned dec_flag = 0;
unsigned inc() {
unsigned inc_v = 0;
pthread_mutex_lock(&m);
if(value == 0u-1) {
pthread_mutex_unlock(&m);
return 0;
} else {
inc_v = value;
inc_flag = 1, valu... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_g1, mutex_g2;
double g1 = 1, g2 = 1;
void* geometric_mean_calc(void* arg) {
int id = (int) arg;
if (id % 2) {
pthread_mutex_lock(&mutex_g1);
g1 *= id;
pthread_mutex_unlock(&mutex_g1);
} else {
pthread_mutex_lock(&mutex_g2);
g2 *= id;
pth... | 1 |
#include <pthread.h>
int piao = 100;
pthread_mutex_t mut;
void * tprocess1(void * args) {
int a = 0;
while (1) {
pthread_mutex_lock( & mut);
if (piao > 0) {
Sleep(1);
piao--;
printf("window1----------------%d tickets left\\n", piao);
} else {
a = 1;
}
pthread_mutex_unloc... | 0 |
#include <pthread.h>
int global_i = 1;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait;
void *polez_rab(void *num)
{
long t_num;
t_num = (long) num;
pthread_mutex_lock(&mut);
global_i++;
pthread_mutex_unlock(&mut);
sleep (global_i);
pthread_mut... | 1 |
#include <pthread.h>
static struct log * stat_log;
static pthread_mutex_t stat_lock = PTHREAD_MUTEX_INITIALIZER;
int bfrstat_init(char * filename)
{
stat_log = malloc(sizeof(struct log));
char log_name[256];
snprintf(log_name, 256, "bfr_stats_%u", g_bfr.nodeId);
if (log_init(log_... | 0 |
#include <pthread.h>
int socketID[4];
char globalBuffer [2048];
char globalFileBuffer [4098], sendFile[4098];
pthread_mutex_t global_lock;
FILE *fp;
void fileWrite (char *fileName, char *text) {
FILE *fp;
fp = fopen(fileName, "w");
fputs(text, fp);
fclose(fp);
retu... | 1 |
#include <pthread.h>
struct s {
struct s *next;
int datum;
} *A, *B;
void init (struct s *p, int x) {
p -> datum = x;
p -> next = 0;
}
pthread_mutex_t A_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t B_mutex = PTHREAD_MUTEX_INITIALIZER;
void *t_fun(void *arg) {
int *ip;
stru... | 0 |
#include <pthread.h>
void* declare_trial_files(void* rank)
{
long my_rank = rank;
pthread_mutex_t mutex;
int check = pthread_mutex_init(&mutex, 0);
if (my_rank == 0)
{
pthread_mutex_lock(&mutex);
fV_vs_t_id = fopen("V_vs_T.txt", "w");
pthread_mutex_unlock(&mutex);
... | 1 |
#include <pthread.h>
FILE *logfile = 0, *errlogfile = 0;
pthread_mutex_t errlogmutexlock, stdlogmutexlock, sysloglock;
void record_std(char *record)
{
if(logfile == 0)
{
pthread_mutex_lock(&sysloglock);
syslog(LOG_INFO, record);
pthread_mutex_unlock(&syslogl... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.