text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int is_exiting = 0;
buffer_item buffer[5];
int buffer_space = 5;
pthread_mutex_t buffer_lock;
int buffer_has_space();
int buffer_has_item();
int insert_item(buffer_item item);
int remove_item(buffer_item *item);
void *producer(void *param);
void *consumer(void *p... | 1 |
#include <pthread.h>
void *runner(void *param);
int count = 0;
pthread_mutex_t lock;
int main(int argc, char **argv)
{
pthread_t tid1, tid2;
int value;
if (pthread_mutex_init(&lock, 0) != 0)
{
printf("\\n mutex init failed\\n");
exit(1);
}
if(pthre... | 0 |
#include <pthread.h>
void wait_for_completion(struct completion *x)
{
pthread_mutex_lock(&x->lock);
while(!x->done) {
pthread_cond_wait(&x->cond, &x->lock);
}
x->done--;
pthread_mutex_unlock(&x->lock);
}
unsigned long wait_for_completion_timeout(struct completion *x, un... | 1 |
#include <pthread.h>
void set_motor_par()
{
clear_to_color(screen, COL_BG);
layout_base("Set motor parameters");
button_set(rectx1, recty1, "previus");
textout_centre_ex(screen, font, "SET THE PARAMETERS OF MOTOR", sezx/2, d, COL_BUT, BG);
button_set(motparx1,... | 0 |
#include <pthread.h>
void receive(void *arg);
void cleanup(int i);
void add_login(char *name, char* host, int ppid);
void del_login(char *name, char* host, int ppid);
void get_logins(int sock);
void parse (char *command, char *argv[], int *argc);
struct heybook hey;
pthread_mutex_t mutex;
int ma... | 1 |
#include <pthread.h>
pthread_t threads[4];
pthread_mutex_t mutex;
unsigned int * V;
int divisor = 2;
double limit;
double dwalltime(){
double sec;
struct timeval tv;
gettimeofday(&tv,0);
sec = tv.tv_sec + tv.tv_usec/1000000.0;
return sec;
}
void * criba(void * tid){
int mydiv... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex_ressources = PTHREAD_MUTEX_INITIALIZER;
static unsigned int nb_ressources = 4;
static pthread_cond_t cond_ressources_libere = PTHREAD_COND_INITIALIZER;
void f_thread(unsigned int *ressources_necessaires)
{
pthread_t current_thread = pthread_... | 1 |
#include <pthread.h>
void * ucr (void * arg);
void * uad (void * arg);
void muestreoPeriodico (int ids);
void escribirEnArchivo (int noAEscribir,int unidad, int tipo);
void fueraDeRango (int ads);
void apagarSistema (int ids);
int encendido = 1;
int * valores;
int * valoresFueraDeRango;
int ... | 0 |
#include <pthread.h>
pthread_mutex_t barber_access;
pthread_mutex_t seat_access;
int customer_access = 0;
int num_free_seats = 5;
bool shop_open = 1;
void wait_for_customer() {
while(customer_access <= 0) {
;
}
customer_access -= 1;
}
void customer_available() {
custom... | 1 |
#include <pthread.h>
{
pthread_mutex_t lock;
pthread_cond_t wait;
int value;
int waiters;
} sema;
sema *InitSem(int count)
{
sema *s;
s = (sema *)malloc(sizeof(sema));
if(s == 0) {
return(0);
}
s->value = count;
s->waiters = 0;
... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
void *Thread_function(void* ignore);
void Usage(char* prog_name);
double elapsed = 0.0;
pthread_mutex_t mutex;
pthread_barrier_t barrier_p;
int main(int argc, char* argv[]) {
int thread_count;
long thread;
pthread_t* thread_handle... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int value = 0;
void *
signal_after_sometime(void *arg)
{
if (usleep((int)arg * 1000))
{
fprintf(stderr, "error calling usleep\\n");
exit(1);
}
pthread_mute... | 0 |
#include <pthread.h>
int info;
char* buffer;
} DATA;
DATA data;
struct Node_t *prev;
} NODE;
NODE *head;
NODE *tail;
int size;
int limit;
int count;
int active;
} Queue;
Queue *ConstructQueue(int limit);
void DestructQueue(Queue *queue);
int Enqueue(Queue... | 1 |
#include <pthread.h>
static pthread_mutex_t coordinator_mutex;
static pthread_cond_t coordinator_cond;
static int continuous_mode;
static int quickly_mode;
static int got_a_location;
void init_coordination(int continuous, int quickly)
{
continuous_mode = continuous;
quick... | 0 |
#include <pthread.h>
int global_variable_count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void* IncrementVariable(void *id)
{
int i;
int threadID = (int)id;
printf("Starting IncrementVariable(): thread %d\\n", threadID);
for (i=0; i < 5; i++) {
... | 1 |
#include <pthread.h>
void generar_persona ();
void cerrar_banio (int ids);
void generar_mujer ();
void generar_hombre ();
void * mujer (void * arg);
void * hombre (void * arg);
void mujer_quiere_entrar ();
void hombre_quiere_entrar ();
void mujer_sale ();
void hombre_sale ();
void * sacarPersona ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void* child1( void* param )
{
pthread_cleanup_push( (void (*)(void*))pthread_mutex_unlock, (void*)&mutex );
while( 1 )
{
printf( "thread 1 get running\\n" );
printf( "thread 1 pthread_mutex_lock returns %d\\n", pthread... | 1 |
#include <pthread.h>
pthread_mutex_t mutexA = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexB;
pthread_mutex_t mutexC;
pthread_mutex_t mutexD;
pthread_mutex_t mutexE;
void *f(void *unused)
{
pthread_mutex_lock(&mutexA);
pthread_mutex_lock(&mutexB);
pthread_mutex_unlock(&mutexB);
pthread_mut... | 0 |
#include <pthread.h>
void initGrid(int grid[ROW][ROW]){
int i,j;
for (i=0; i< ROW; i++){
for (j=0; j< ROW; j++){
grid[i][j]=0;
}
}
}
void initNetwork(pthread_mutex_t network[ROW][ROW]){
int i,j,rc;
for (i=0; i<ROW; i++){
for (j=0; j<ROW; j+... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int x;
void producer(void)
{
while(1){
pthread_mutex_lock(&mutex);
int i;
for(i=0; i<3-x; i++){
x++;
printf("Producing : x=%d \\n", x);
sleep(1);
}
if(x >= 3){
pthread_cond_signal(&cond);
printf("Producing ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int power_modulo_fast(int a, int b, int m)
{
int i;
int result = 1;
long int x = a%m;
for (i=1; i<=b; i<<=1)
{
x %= m;
if ((b&i) != 0)
{
result *= x;
result %= m;
}
x *= x;
}
return result%m;
}
int Fermat(int n, int ... | 1 |
#include <pthread.h>
void func1();
void func2();
void func3();
pthread_cond_t cond,cond2;
pthread_mutex_t mutex;
int main()
{
pthread_t thread[2];
pthread_mutex_init(&mutex,0);
pthread_cond_init(&cond,0);
pthread_cond_init(&cond2,0);
int i=0;
int *status;
void (*funcptr[3])();
funcptr[0]=func... | 0 |
#include <pthread.h>
struct s_c_c
{
unsigned int msg_type;
unsigned int msg_len;
unsigned char msg[1];
};
struct stalker_info
{
pthread_t stalker;
void *mq;
pthread_mutex_t mut;
pthread_cond_t cond;
unsigned int status;
unsigned int (*thread_worker)(... | 1 |
#include <pthread.h>
extern int pthread_setconcurrency(int);
extern int pthread_getconcurrency();
struct {
pthread_mutex_t data_lock[5];
int int_val[5];
double double_val[5];
} data;
void *add_to_value();
int main()
{
puts("arrays - POSIX version");
pthread_t thr[5];
puts... | 0 |
#include <pthread.h>
double sum;
pthread_mutex_t sumMutex;
int id;
int sliceSize;
double delta;
} CalculationParameters;
void * partialSum(void *const arg ) {
int const start = 1 + ((CalculationParameters *const)arg)->id * ((CalculationParameters *const)arg)->sliceSize;
int cons... | 1 |
#include <pthread.h>
int thread_status = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *rand_input(void *arg)
{
if(!arg)
{
printf("\\nERR:INVALID input argument to thread\\n");
pthread_exit(0);
}
printf("\\nrand_input pthread self ID : %lu\\n", pthread_self());
whil... | 0 |
#include <pthread.h>
int pbs_terminate_err(
int c,
int manner,
char *extend,
int *local_errno)
{
struct batch_reply *reply;
int rc = 0;
int sock;
struct tcp_chan *chan = 0;
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
if ((chan = DI... | 1 |
#include <pthread.h>
struct telnet_info_node
{
int controlId;
char *ip_addr;
int port;
int id;
TELNET_INFO_NODE prev;
TELNET_INFO_NODE next;
};
static TELNET_INFO_NODE g_telnet_info_node_head = 0;
static pthread_mutex_t g_telnet_info_mutex = PTHREAD_MUTEX_INITIALIZER;
static TELNET_INFO_N... | 0 |
#include <pthread.h>
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mut2 = PTHREAD_MUTEX_INITIALIZER;
int done = 0;
int todo = 0;
double wtime(void);
void* thread1_fn(void* foo);
... | 1 |
#include <pthread.h>
pthread_t tid;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *arg;
}thdinfo_t;
void *led_cntl(void *arg);
void *gprs_cntl(void *arg);
void *camera_cntl(void *arg);
void *firehydrant_cntl(void *arg);
void *alarm_cntl(void *arg);
int warn_flag;
int main()
{
void *(*pt... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int compare(const int * a, const int * b){
if (*a > *b){
return(1);
}
else if( *b > *a){
return(-1);
}
else{
return(0);
}
}
int is_prime(int p){
int i;
if(p < 2){
return(0);
}
i = 2;
while(i*i <= p){
... | 1 |
#include <pthread.h>
void* produce(void *arg) {
for (;;) {
pthread_mutex_lock(&put.mutex);
if (put.nput >= nitems) {
pthread_mutex_unlock(&put.mutex);
return 0;
}
buff[put.nput] = put.val;
put.nput++;
put.nval++;
pthread_mutex_unlock(&put.mutex);
pthread_mutex_lock(&nready.... | 0 |
#include <pthread.h>
void operand1_mutex();
void operand2_mutex();
pthread_mutex_t filemutex;
int main(int argc, char *argv[]) {
pthread_t t1;
pthread_t t2;
pthread_mutex_init(&filemutex, 0);
printf("Operand mixer\\n");
printf("\\nStarting threads WITHOUT mutex\\n");
pthread_create( &t... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread1(void *);
void *thread2(void *);
int i = 1;
int main(void)
{
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a, 0, thread1, (void *)0);
pthread_creat... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int stage = 0;
void *check_in_thread(void *load_area) {
pthread_mutex_lock(&mutex);
stage = 1;
pthread_cond_signal(&cond);
while (stage != 2) {
pthread_cond_... | 1 |
#include <pthread.h>
void *producer(),*consumer();
int *array;
int limit=-1;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char **argv) {
int howmany;
pthread_t johntid,marytid;
long long *howlong;
howmany=atoi(argv[1]);
array=calloc(howmany,sizeof(int));
pt... | 0 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
} *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... | 1 |
#include <pthread.h>
pthread_mutex_t cmutex;
int array_a[10], array_b[10], array_c[10];
int smallest_value, largest_value, average_value;
void print_array(int array_x[10], char *name)
{
if (!1){
printf("%s: ", name);
int i;
for(i = 0; i < 10; i++){
printf("%d ", array_x[i]);
}
prin... | 0 |
#include <pthread.h>
int *item;
} matrixIndex;
int tid;
double scalar;
} thread_data_t;
int NUM_THREADS;
pthread_mutex_t valLock = PTHREAD_MUTEX_INITIALIZER;
int* nextVal = 0;
int valueReady = 0;
pthread_cond_t checkSignal = PTHREAD_COND_INITIALIZER;
pthread_mutex_t signalLock = PT... | 1 |
#include <pthread.h>
int n, thread_count, flag;
double sum, w;
pthread_mutex_t mutex;
void* thread_sum(void *rank) {
int *ranki = (int *) rank;
int start = *ranki*n/thread_count;
int end = (*ranki+1)*n/thread_count;
double local_sum = 0.0, x;
int i;
w=(double)1.0/(double)n;
for (i=start;... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void*
start_thread()
{
int *n, fd, c;
ssize_t size;
n = (int *)malloc(sizeof(int));
*n = 0;
for (c = 0; c != 100; c++) {
pthread_mutex_lock(&mutex);
fd = open("Example.txt", O_RDWR, 0600);
if (fd == -1) {
... | 1 |
#include <pthread.h>
int queue[100];
int length;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;
void *producer_thread(void *);
void *consumer_thread(void *);
void print_queue();
... | 0 |
#include <pthread.h>
long unsigned int seconds1 ;
long unsigned int seconds2;
char message1[50];
{
pthread_cond_t cond;
int seconds;
char message[50];
struct tag *next;
}my_struct;
struct mutex
{
pthread_mutex_t mutex;
pthread_cond_t cond1;
pthread_cond_t cond2;
my_struct *head ;
}mute... | 1 |
#include <pthread.h>
int buf[10];
pthread_mutex_t lock;
void* producer(void* param)
{
int i;
pthread_mutex_lock(&lock);
for (i = 0; i < 10; ++i) {
buf[i] = i;
}
pthread_mutex_unlock(&lock);
pthread_exit(0);
}
void* consumer(void* param)
{
int i;
... | 0 |
#include <pthread.h>
int numOfBottles=25;
int guestInfo[20][3];
int moodOfHost = 0;
int i;
pthread_mutex_t refr;
pthread_t guestsArray[20];
pthread_t host;
void *guestFunc(void *arg){
srand(time(0));
int posNumber = *((int *) arg);
while(1){
pthread_mutex_lock(&refr);
... | 1 |
#include <pthread.h>
int memory[(2*32+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top;
int index_malloc(){
int curr_alloc_idx = -1;
pthread_mutex_lock(&m);
if(next_alloc_idx+2-1 > (2*32+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx = ... | 0 |
#include <pthread.h>
int data;
struct _node * left;
struct _node * right;
} node;
void * tmain(void *);
void do_work(void);
void init_mutexes(void);
void init_workers(int param[]);
void wind_up(void);
void process_node(node * n, int sorted[], int * i);
void tree_insert(node ** t... | 1 |
#include <pthread.h>
static int glob = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static void *thread_routine(void *arg)
{
int loc, j;
for (j = 0; j < 10000000; j++) {
pthread_mutex_lock(&mtx);
loc = glob;
loc++;
glob = loc;
... | 0 |
#include <pthread.h>
void vpn_loop(struct options opt)
{
struct Ctunnel **ctunnel;
struct Network *net_srv = 0;
char dev[5] = "";
int i = 0, x = 0, srv_sockfd = 0, ret = 0, tunfd = 0;
int pool = 1;
pthread_t tid[MAX_THREADS];
extern int threads[MAX_THREADS];
... | 1 |
#include <pthread.h>
char buffer[2000000];
int countarray[128];
pthread_mutex_t mutex;
int buffstart, buffend;
} argue, *argues;
int ascicount(void *ar);
int main(int argc, char *argv[]){
int *openfile, readcount, threadbyte, n;
argue *datapass;
pthread_t handlethreads[8];
pthread_attr... | 0 |
#include <pthread.h>
int queue[1000000];
int queueStart = 0;
int queueEnd = 0;
int n = 50;
int thSync = 1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static void *producer(void *arg);
static void *consumer(void *arg);
int main(int argc, c... | 1 |
#include <pthread.h>
int global_i = 1;
int global_j = 10;
pthread_mutex_t mutex;
pthread_mutex_t fict;
pthread_cond_t blocked;
void *ThreadsUseIt(void* num) {
int i;
long t;
t = (long) num;
pthread_mutex_lock(&mutex);
i = global_i;
global_i++;
pthread_mutex_unlock(&mutex);
printf("I`m ... | 0 |
#include <pthread.h>
int still_tasks_left = 1;
int pw_found = 0;
char * current_task = 0;
char * current_username = 0;
char * current_solution = 0;
char * current_pw = 0;
char * pw_with_a = 0;
size_t workload_per_thread = 0;
size_t thread_c;
int num_unknowns;
int prefix_length;
char * pw = ... | 1 |
#include <pthread.h>
struct MsgQueue* MsgQueueCreate(int id, int len, int width)
{
int i;
struct MsgQueue* mq;
mq = (struct MsgQueue*) malloc(sizeof(struct MsgQueue));
mq->m_id = id;
mq->m_len = len;
mq->m_width = width;
mq->m_write_index = 0;
mq->m_read_index = ... | 0 |
#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;
for ( ; ; ) {
err = sigwait(&mask, &signo);
if (err != 0)
err_exit(err, "sigwait failed");
swit... | 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++;
... | 0 |
#include <pthread.h>
double accounts[4];
pthread_mutex_t account_locks[4];
void* worker(void* fname) {
FILE* f = fopen((char*) fname, "r");
if (!f) {
fprintf(stderr, "Error could not open file '%s'!\\n", (char*) fname);
}
while (1) {
int to, from;
... | 1 |
#include <pthread.h>
void generar_persona ();
void cerrar_banio (int ids);
void generar_mujer ();
void generar_hombre ();
void * mujer (void * arg);
void * hombre (void * arg);
void mujer_quiere_entrar ();
void hombre_quiere_entrar ();
void mujer_sale ();
void hombre_sale ();
void * sacarPerso... | 0 |
#include <pthread.h>
static pthread_mutex_t s_data_lock = PTHREAD_MUTEX_INITIALIZER;
static int s_data_version = 0;
static char s_data[100];
void *data_producer(void *arg) {
(void) arg;
fprintf(stderr, "Data producer running\\n");
srand(time(0));
while (1) {
pthread_mutex_lock(&s_da... | 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 *idp)
{
int j,i;
double result=0.0;
int *my_id = (int*)idp;
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
... | 0 |
#include <pthread.h>
static uint8_t okey[64], ikey[64];
static void vlc_rand_init (void)
{
uint8_t key[64];
int fd = vlc_open ("/dev/urandom", O_RDONLY);
if (fd == -1)
return;
for (size_t i = 0; i < sizeof (key);)
{
ssize_t val = read (fd, key + i, sizeof... | 1 |
#include <pthread.h>
extern double a, h;
extern int local_n;
double total;
pthread_mutex_t mutex;
long flag = 0;
sem_t sem;
extern int thread_count;
double f(double x){
double return_val;
return_val = x*x;
return return_val;
}
double trap(double local_a, double local_b, double h, int loc... | 0 |
#include <pthread.h>
int balance = 1000;
int credits = 0;
int debits = 0;
pthread_mutex_t b_lock,c_lock,d_lock;
void * transactions(void * args){
int i,v;
for(i=0;i<100;i++){
v = (int) random() % 100;
if( random()% 2){
pthread_mutex_lock(&b_lock);
balance ... | 1 |
#include <pthread.h>
int global = 0x31337;
void * work(void *arg)
{
pthread_mutex_t * m = (pthread_mutex_t *)arg;
int timer_th;
for (timer_th = 0; timer_th < 9; ++timer_th)
{
printf("CHILD THREAD: Trying take main resourse...\\n");
int r_mutex = pthread_mutex_tryl... | 0 |
#include <pthread.h>
struct chair {
struct chair *next;
};
struct queue {
struct chair *current;
struct chair *next;
int chairs;
int customerCount;
};
struct queue theQueue;
pthread_mutex_t barberLock;
pthread_mutex_t customerLock;
void signalCatch(int sig) {
p... | 1 |
#include <pthread.h>
int pocetVolicov = 0, kruzkuje = 0;
int koniec = 0;
pthread_mutex_t mutexPremenne = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexUrna = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condKruzkovat = PTHREAD_COND_INITIALIZER;
void kruzkuj(void) {
pthread_mutex_lock(&mu... | 0 |
#include <pthread.h>
struct cave
{
int pearlsRemain;
int pearlsMovedOver;
};
void *pirateA();
void *pirateB();
void *pirateC();
void *pirateD();
pthread_mutex_t mutex;
struct cave piratesNew;
int
main()
{
piratesNew.pearlsRemain = 1000;
piratesNew.pearlsMovedOver = 0;
... | 1 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("preparing locks ... \\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent unloc... | 0 |
#include <pthread.h>
pthread_mutex_t rssth_http_mutex = PTHREAD_MUTEX_INITIALIZER;
int http_open (const struct selector *sel) {
char * URL = sel->link;
struct t_url url = tokenize_url (URL);
int fd = socket(PF_INET, SOCK_STREAM, 6);
struct sockaddr_in in_adrs;
in_adrs.sin_family = AF_INET;
... | 1 |
#include <pthread.h>
struct x86_glut_frame_buffer_t
{
int *buffer;
int width;
int height;
int flush_request;
};
static struct x86_glut_frame_buffer_t *x86_glut_frame_buffer;
void x86_glut_frame_buffer_init(void)
{
x86_glut_frame_buffer = xcalloc(1, sizeof(struct x86_glut_frame_... | 0 |
#include <pthread.h>
int contador=0;
pthread_cond_t condicao_contador;
pthread_t threads[3];
pthread_mutex_t mutex_contador;
void *incrementa(void *valor)
{
int i,j;
for(i=0;i<50;i++)
{
pthread_mutex_lock(&mutex_contador);
contador++;
... | 1 |
#include <pthread.h>
int mediafirefs_release(const char *path, struct fuse_file_info *file_info)
{
printf("FUNCTION: release. path: %s\\n", path);
(void)path;
struct mediafirefs_context_private *ctx;
struct mediafirefs_openfile *openfile;
struct mfconn_upload... | 0 |
#include <pthread.h>
{
int fd;
off_t pos;
size_t nbytes;
}COMPUTE_INFO,*PCOMPUTE_INFO;
value_type compute(int fd,off_t pos,off_t nbytes);
void thread_compute(void *param);
int g_nthreads = 0;
pthread_mutex_t nthreads_mutex;
value_type g_final_res = 0;
int main(int argc,char **argv)
{
int f... | 1 |
#include <pthread.h>
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
static int write_int(char const *path, int value)
{
int fd;
static int already_warned = -1;
fd = open(path, O_RDWR);
if (fd >= 0) {
char buffer[20];
int bytes = sprintf(buffer, "%d\\... | 0 |
#include <pthread.h>
volatile sig_atomic_t gotsigterm = 0;
volatile sig_atomic_t gotsigusr1 = 0;
volatile sig_atomic_t gotsigalrm = 0;
static pthread_mutex_t sigalrm_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_t sigalrm_owner;
static unsigned int sigalrm_installed = 0;
static void si... | 1 |
#include <pthread.h>
long value[50000];
int index;
pthread_mutex_t lock;
} syncarray;
void init(syncarray *c)
{
pthread_mutex_init(&c->lock, 0);
int i;
for (i=0; i<50000; i++)
c->value[i] = 0;
c->index = 0;
}
int put(syncarray *c, long val)
{
pthread_mutex_lock(&c->lock);
... | 0 |
#include <pthread.h>
volatile double pi = 0.0;
pthread_mutex_t pi_lock;
volatile double intervals;
void *
process(void *arg)
{
register double width, localsum;
register int i;
register int iproc;
iproc = (int)(long) arg;
width = 1.0 / intervals;
localsum = 0;
f... | 1 |
#include <pthread.h>
pthread_t PIDARR[5];
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
bool running=1;
int var1=0, var2=0;
void* kjooor(void *arg){
while(running){
pthread_mutex_lock(&mutex);
var1=var1+1;
var2=var1;
pthread_mutex_unlock(&mutex);
}
return 0;
}
void* kjor2(vo... | 0 |
#include <pthread.h>
static pthread_mutex_t tmutex = PTHREAD_MUTEX_INITIALIZER;
static char dataroot[1024];
extern char *TCID;
static void tst_dataroot_init(void)
{
const char *ltproot = getenv("LTPROOT");
char curdir[1024];
const char *startdir;
int ret;
if (ltproot) {
ret = snprintf(d... | 1 |
#include <pthread.h>
void __VERIFIER_error() { abort(); };
int __VERIFIER_nondet_int() {int n; return n;}
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;
}
... | 0 |
#include <pthread.h>
const int MAX = 65536;
pthread_mutex_t mutex;
struct list_node_s** head;
int n;
int m;
float memb;
float ins;
float del;
int n_obs;
int tc;
int *data;
struct list_node_s {
int data;
struct list_node_s* next;
};
int Member (int value, struct list_node_s* head_p);
int... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int count=0;
struct rw_file{
FILE *srcfile;
FILE *desfile;
};
void thread_rw(struct rw_file *rw_file);
int main(int argc,char *argv[]){
pthread_t thrd[5];
int ret;
struct rw_file rw_file;
if((rw_file.srcfil... | 0 |
#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, len;
... | 1 |
#include <pthread.h>
void init_transmition(){
pthread_cond_init(&new_data,0);
pthread_mutex_init(&mutex,0);
pthread_cond_init(&arrived_configuration,0);
pthread_mutex_init(&mutex_configuration,0);
stop = 0;
pthread_create(&transmition_thread, 0, transmition, 0);
}
void init_fifos(int* ... | 0 |
#include <pthread.h>
extern int search_file_list(long f_inode,struct file_lock **add_loc);
extern void delete_file_list(struct file_lock *ptr_file_node);
extern int tr_yaffs_close_abort (int handle, unsigned int txnid);
struct file_lock *resume(long f_inode,char *file_path,int f_flags,int txnid)
{... | 1 |
#include <pthread.h>
int counter = 0;
int semaphore_place = 0;
pthread_mutex_t mtx_geton_passenger, mtx_getdown_passenger;
pthread_cond_t cond_passenger, cond_bus, cond_stay;
void *passengerAction(void *ptr){
int *id = (int *)ptr;
while (1) {
pthread_mutex_lock(&mtx_geton_pass... | 0 |
#include <pthread.h>
static void * thread_compteur (void * inutile);
static void * thread_signaux (void * inutile);
static int compteur = 0;
static pthread_mutex_t mutex_compteur = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_compteur = PTHREAD_COND_INITIALIZER;
static pthread_t ... | 1 |
#include <pthread.h>
int threads_activos;
pthread_mutex_t l = PTHREAD_MUTEX_INITIALIZER;
int fib_secuencial(int n)
{
if(n < 2)
return n;
return (fib_secuencial(n-1) + fib_secuencial(n-2));
}
void *fib(void *p)
{
unsigned int n = *(int*)p;
if (n < 2)
return 0;
else if(thre... | 0 |
#include <pthread.h>
{
char** m_que;
int m_flag;
int m_capacity;
int m_size;
int m_front,m_tail;
pthread_mutex_t m_lock;
pthread_cond_t m_pro,m_con;
}QUE,*pQUE;
void* thd_func(void* arg);
void put(pQUE pq,char* src);
void get(pQUE pq,char* dest);
int main(int argc,char* argv[])
... | 1 |
#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;
q->tail... | 0 |
#include <pthread.h>
void init_tswm(struct tsWordTree* tree){
if(tree != 0) {
tree->head = (struct tsTreeNode*)malloc(sizeof(struct tsTreeNode));
memset(tree->head, 0, sizeof(struct tsTreeNode));
pthread_mutex_init(&tree->head->nodeUse, 0);
tree->wordCount = 0;
}
}
void addWord_... | 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_top(void)
{
t... | 0 |
#include <pthread.h>
{
int add;
int take;
int buffer[10];
}product;
product proBuff = {0,0,{0}};
unsigned int proId = 1;
pthread_mutex_t mutex;
sem_t full;
sem_t empty;
void *Gen(void *id)
{
while(1)
{
sem_wait(&empty);
pthread_mutex_lock(&mutex);
if(!(((... | 1 |
#include <pthread.h>
static int top=0;
unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=0;
void *t1(void *arg) {
for(int i=0; i<(5); i++) {
pthread_mutex_lock(&m);
assert(top!=(5));
arr[top]=i;
top++;
printf("pushed element %d\\n", i);
pthread_mutex_unlock(&m);... | 0 |
#include <pthread.h>
static int ensure_capacity(struct charbuffer *b, int size) {
if (size > b->size) {
char *newbuffer = (char *) malloc(size);
if (!newbuffer)
return CHARBUFFER_ERROR;
if (b->buffer) {
memcpy(newbuffer, b->buffer, b->size)... | 1 |
#include <pthread.h>
int MAX = 20001;
int p_sleep;
int c_sleep;
int producer_count;
int consumer_count;
int item_p;
int item_c;
bool isproducersleeping = 0;
bool isconsumersleeping = 0;
pthread_mutex_t lock;
pthread_cond_t cond_consume;
pthread_cond_t cond_produce;
struct Queue
{
int fr... | 0 |
#include <pthread.h>
pthread_mutex_t mt = PTHREAD_MUTEX_INITIALIZER;
void lock_func(void* arg)
{
pid_t pid;
pt_t tid;
pid = getpid();
tid = pthread_self();
printf("want to lock mutex, msg=%s, tid=%u\\n", (char*)arg, (uint_t)tid);
pthread_mutex_lock( &mt );
printf("I[tid=%u] am using,... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *thread2 (void *arg);
void *thread3 (void *arg);
void *thread (void *arg)
{
long j = (long) arg;
int i, ret;
pthread_t th[2];
printf ("t%ld: running!\\n", j);
for (i = 0; i < 2; i++)
{
ret = pthread_... | 0 |
#include <pthread.h>
{
int* carpark;
int capacity;
int occupied;
int nextin;
int nextout;
int cars_in;
int cars_out;
pthread_mutex_t lock;
pthread_cond_t space;
pthread_cond_t car;
pthread_barrier_t bar;
} cp_t;
static void* car_in_handler(void* cp_in);
static void* car_out_handle... | 1 |
#include <pthread.h>
struct s_block {
size_t size;
struct s_block *next;
int f;
};
void *segmentptr;
int segmentsize;
pthread_mutex_t mutex;
void printBlock ( t_block b) {
if ( b->f == 1)
printf( "Block addr: %lx, size: %zu\\t is free\\n", ( unsigned long) b, b->size);
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.