text stringlengths 192 6.24k | label int64 0 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 );
char * getenv (const char * name);
static void thread_init (void )
{
p... | 1 |
#include <pthread.h>
{
uint64_t num;
int nb_factors;
uint64_t factors[50];
} decomp;
static int nb_decomp = 0;
static decomp *known_decomp[2000000];
static pthread_mutex_t decomp_mutex = PTHREAD_MUTEX_INITIALIZER;
int is_known(uint64_t n )
{
printf("hu\\n");
if(nb_decomp)
{
printf("w... | 0 |
#include <pthread.h>
sem_t customers;
sem_t chair;
sem_t sit;
sem_t end;
void mutex_semaphore_main() {
pthread_t barber_t;
int iret;
iret = pthread_create(&barber_t, 0, barber_semmutex, 0);
if( iret ) {
fprintf( stderr, "Error - pthread_create(barber_t) return code: %d... | 1 |
#include <pthread.h>
const int DATA_COUNT = 10;
int shared[DATA_COUNT] = {0};
pthread_mutex_t lock[DATA_COUNT];
void *work(void *arg) {
for (int i = 0; i < 100; i++) {
for (int j = 0; j < DATA_COUNT; j++) {
pthread_mutex_lock(&lock[j]);
++shared[j];
... | 0 |
#include <pthread.h>
int NR_THREADS = 10;
pthread_mutex_t count_mutex;
double circleCount=0;
int NR_PTS = 1000000;
void * threadFunction(){
double x =0, y=0, threadPi =0, inCircle =0;
int counter =0;
pthread_t thrID = pthread_self();
unsigned seed = getpid() * time(0) * (thrID + 1);
whil... | 1 |
#include <pthread.h>
char** buffer;
pthread_mutex_t myMutex;
int input_pointer;
int output_pointer;
int initFIFO() {
printf("init fifo...\\n");
buffer = malloc(sizeof (char*)*200);
for (int i = 0; i < 200; i++) {
buffer[i] = malloc(sizeof (char)*30);
}
if (pthrea... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t mutex;
void * ThreadAdd (void * a) {
int i, tmp;
for (i = 0; i < 1000000; i++) {
pthread_mutex_lock (&mutex);
tmp = count;
tmp = tmp+1;
count = tmp;
pthread_mutex_unlock (&mutex);
}
return 0;
}
... | 1 |
#include <pthread.h>
void *start_producer(void *);
int *shared_buffer;
int buffer_size, producer_index, consumer_index, number_of_items;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t prod_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cons_cond = PTHREAD_COND_INITIALI... | 0 |
#include <pthread.h>
static struct cannon cn;
static struct cannon cn2;
void setupCannon(int players) {
int col;
if (players == 1) {
col = ((0 + COLS-1)/2);
} else {
col = ((0 + COLS-1)/4);
strncpy(cn2.message, CANNON, CANNON_LEN);
cn2.length = CANNON_LEN;
cn2.col = col;
cn2... | 1 |
#include <pthread.h>
void * other(void * unused){
while(1)
kitsune_update("testkick");
}
void * testwait(void * unused){
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
while(1)
{
kitsune_update("testwait");
pt... | 0 |
#include <pthread.h>
int task = 10;
pthread_mutex_t task_mutex;
pthread_cond_t task_cond;
void *say_hello2( void *args )
{
pthread_t pid = pthread_self();
printf("pthread %d run sayhello2 with %d \\n", pid, *( ( int *) args ) );
while(1)
{
pthread_mutex_lock( &task_mutex );
if... | 1 |
#include <pthread.h>
struct node
{
pthread_mutex_t mutex;
int data;
struct node *next;
};
struct node *_head;
int Member(int _value)
{
int is_in = 0;
pthread_mutex_lock(&(_head->mutex));
struct node *cursor = _head;
while(cursor != 0 && (*c... | 0 |
#include <pthread.h>
static pthread_mutex_t mtio_lock = PTHREAD_MUTEX_INITIALIZER;
void ubik_mtprintf(char *fmt, ...)
{
va_list ap;
__builtin_va_start((ap));
pthread_mutex_lock(&mtio_lock);
vprintf(fmt, ap);
pthread_mutex_unlock(&mtio_lock);
}
| 1 |
#include <pthread.h>
int n_threads=1;
int myid=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void do_something()
{
int id,i,j;
pthread_mutex_lock(&mutex);
id=myid;
myid++;
printf("This is ult %d\\n", id);
if(n_threads<6){
n_threads++;
pthread_mu... | 0 |
#include <pthread.h>
static const char* input_paths[] =
{
"out/1",
"out/2",
"out/3",
"out/4",
"out/5"
};
static const char* output_path = "out/out";
size_t bufsize = 0;
char buffer[20971520];
void asio_read (pthread_mutex_t*);
void* asio_write (void*);
void asio_read( pt... | 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>
static double POS_Steer_Scale_Left;
static double POS_Steer_Scale_Right;
static double POS_Steer_Current_Setting;
static double POS_Steer_Current_Abstract_Setting;
static pthread_mutex_t POS_Steer_Write_Lock = PTHREAD_MUTEX_INITIALIZER;
void Init_POS_Steer(vo... | 1 |
#include <pthread.h>
pthread_mutex_t g_mutex;
pthread_cond_t g_cond;
{
char buf[5];
int count;
} buffer_t;
buffer_t g_share = {"", 0};
char g_ch = 'A';
void* producer( void *arg )
{
printf("Producer starting.\\n");
while(g_ch != 'Z')
{
pthread_mutex_lock(&g_mutex);
... | 0 |
#include <pthread.h>
struct thread_barrier *barrier(int max){
if (max < 2)
max = 2;
struct thread_barrier *barrier = ALLOC(*barrier, 1);
barrier->max = max;
barrier->arrived = 0;
pthread_mutex_init(&barrier->mutex);
barrier->blockers = ALLOC(*barrier->blockers, max ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond_portal;
pthread_cond_t cond_readers;
char news_buf[1024];
bool read[5];
} news_t;
int thread_num;
news_t *shared_news;
} thread_info;
void* portal(void *arg) {
news_t *shared_news = (news_t*)ar... | 0 |
#include <pthread.h>
struct keyValue_struct* endpointConfiguration=0;
char* initialize(struct keyValue_struct** endpointConfig);
void* handler(void* args);
char* getUrl(char* key);
pthread_t tid[1];
pthread_mutex_t lock;
int main(){
int err;
initialize(&endpointConfiguration);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t fillCount;
sem_t emptyCount;
int item;
int sharedBuffer[100];
int index1 = 0;
int index2 = 0;
int productionCount = 0;
int consumptionCount = 0;
int X=0;
int produceItem(){
return X++;
}
void putItemIntoBuffer(int arg_item){
sharedBuff... | 0 |
#include <pthread.h>
static FILE *logfilefp;
static pthread_mutex_t mutex;
void logfile_write_data(char *buf, long length);
void get_time(char *sTime, int length)
{
time_t ct;
struct tm *currtime;
time(&ct);
currtime = (struct tm *)localtime(&ct);
memset(sTime,0x00,length);
sprintf(sTime... | 1 |
#include <pthread.h>
pthread_mutex_t puente_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t izq_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t der_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t izq_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t der_cond = PTHREAD_COND_INITIALIZER;
... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
int num;
struct _ProdInfo *next;
} ProdInfo;
ProdInfo *head = 0;
int beginnum = 1000;
void *productor( void *arg ) {
while ( 1 ) {
ProdInfo *ptr = (ProdInfo *) malloc( sizeof( ProdInfo ) );
ptr->num = ... | 1 |
#include <pthread.h>
void * thread_function(void *);
int Counter=0;
pthread_mutex_t mutex_id;
int main(void)
{
pthread_t tid1, tid2;
void *thread_result;
if(pthread_mutex_init(&mutex_id, 0) != 0){
perror("pthread_mutex_init");
exit(errno);
}
if(pthread_create(&tid1, 0, thread_f... | 0 |
#include <pthread.h>
struct job {
struct job* next;
int dato;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
void initialize_job_queue (){
job_queue = 0;
sem_init (&job_queue_count, 0, 0);
}
void* raiz_cuadrada (void* arg... | 1 |
#include <pthread.h>
void *compute_pi (void *);
double intervalWidth, intervalMidPoint, area = 0.0;
int numberOfIntervals, interval, iCount,iteration, num_threads;
double distance=0.5,four=4.0;
pthread_mutex_t area_mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t pi_mutex=PTHREAD_MUTEX_IN... | 0 |
#include <pthread.h>
int fd;
pthread_mutex_t m;
bool running;
} server_t;
int peer_fd;
pthread_t thread;
server_t* server;
} connection_t;
void server_init(const char* port, server_t* server) {
struct addrinfo hints;
struct addrinfo *ptr;
memset(&hints, 0, sizeof(struct addrinfo))... | 1 |
#include <pthread.h>
pthread_mutex_t gm;
unsigned long long chunk_size;
void* t(void *args) {
int sec = 3;
char *ptr = (char*)malloc(chunk_size);
pthread_mutex_lock(&gm);
printf("allocated\\n");
pthread_mutex_unlock(&gm);
free(ptr);
pthread_exit(0);
}
int main() {... | 0 |
#include <pthread.h>
int nbThreads;
pthread_t idThdAfficheurs[20];
int tour = 0;
pthread_mutex_t affMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t tourMutex = PTHREAD_MUTEX_INITIALIZER;
void thdErreur(int codeErr, char *msgErr, void *codeArret) {
fprintf(stderr, "%s: %d soit %s ... | 1 |
#include <pthread.h>
int baguette_dispo[5];
pthread_mutex_t mutex;
pthread_cond_t cond[5];
int indice_philo;
int nbr_portion;
}philo_t;
void prendre_baguettes(int i){
pthread_mutex_lock(&mutex);
while(!baguette_dispo[i] || !baguette_dispo[(i+1)%5]){
if(!baguette_dispo[i]){
pthread_cond... | 0 |
#include <pthread.h>
int n;
unsigned *ugarfoLivre;
pthread_cond_t *garfoLivre;
pthread_mutex_t *mutex;
pthread_mutex_t mutexStatus;
char *status;
void atualizarStatus(char novoStatus, int id)
{
pthread_mutex_lock(&mutexStatus);
*(status + id) = novoStatus;
int i;
for(i = 0; i < n... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
long count1;
long count2;
void* work(void* v) {
for (int i = 0; i < 500000; i++) {
count1++;
}
for (int i = 0; i < 500000; i++) {
pthread_mutex_lock(&lock);
count2++;
pthread_... | 0 |
#include <pthread.h>
pthread_mutex_t debug_file_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t notice_file_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t warn_file_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t error_file_mutex = PTHREAD_MUTEX_INITIALIZER;
void request_mutex(pthread_m... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t tidP[20], tidC[20];
sem_t full, empty;
int counter;
int buffer[10];
void initialize()
{
pthread_mutex_init(&mutex,0);
sem_init(&full, 1, 0);
sem_init(&empty, 1, 10);
counter=0;
}
void write(int item)
{
buffer[counter++]=item;
}
in... | 0 |
#include <pthread.h>
int iters;
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int count = 0;
char bufdata[CHUNK*SLOTS];
void * produce(void *arg) {
int dev = open(DEV, O_RDONLY);
char buf[CHUNK];
for (int i = 0; i < iters; i++) {
read(dev, buf, CHUNK);
pthre... | 1 |
#include <pthread.h>
struct msg
{
struct msg *next;
int num;
};
struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer( void *p )
{
struct msg *mp;
for(;; )
{
pthread_mutex_lock( &lock );
while( head =... | 0 |
#include <pthread.h>
int G_CHUNK_SIZE;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
large_uint G_current_start;
large_uint G_subset_count;
int G_terminated_flag;
large_uint G_steps;
void increment_step() {
pthread_mutex_lock(&mutex);
G_steps++;
pthread_mutex_unlock(&mutex);
}
struct s... | 1 |
#include <pthread.h>
long long int size;
char* D1;
char* D2;
int* bitr;
pthread_mutex_t* D1_lock;
pthread_mutex_t* D2_lock;
int STATE;
} database;
database global_db;
int is_finished = 0;
long long int throughput = 0;
long long int active0=0;
long long int active1=0;
int peroid=0;
in... | 0 |
#include <pthread.h>
pthread_t t1,t2;
pthread_mutex_t m1,m2;
pthread_cond_t c;
void* r1(void* d){
while(1){
pthread_mutex_lock(&m1);
printf("wait..............\\n");
pthread_cond_wait(&c,&m2);
pthread_mutex_unlock(&m1);
}
}
void* r2(void* d){
while(1){
pthread_mutex_lock(&m1);
pri... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_count=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_mutex= PTHREAD_COND_INITIALIZER;
int count = 0;
void * thread1(void *ptr){
while(1){
pthread_mutex_lock(&mutex_count);
if((count%2) != 0){
pthread_cond_wait(&cond_mutex,&mutex_count);
}
... | 0 |
#include <pthread.h>
void* send_frame(void* args) {
int i = (int)args;
int wait;
struct timeval now;
struct timespec limit;
pthread_mutex_lock(&network);
gettimeofday(&now, 0);
limit.tv_nsec = now.tv_usec*1000 + TIMEOUT_MS*1000000;
limit.tv_sec = now.tv_sec + limit.tv_nsec/1000000000;
li... | 1 |
#include <pthread.h>
struct monitor {
int count;
int sleep;
int quit;
pthread_t * pids;
pthread_cond_t cond;
pthread_mutex_t mutex;
};
static struct monitor *m = 0;
void create_thread(pthread_t *thread, void *(*start_routine) (void *), void *arg) {
if (pthread_create... | 0 |
#include <pthread.h>
int dato = 4;
int n_lectores = 0;
pthread_mutex_t mutex;
pthread_mutex_t mutex_lectores;
void* Lector(void* args);
void* Escritor(void* args);
int main(){
pthread_mutex_init(&mutex, 0);
pthread_mutex_init(&mutex_lectores, 0);
pthread_t escritor[10];
pthread_t l... | 1 |
#include <pthread.h>
int waitCars[2];
int NumOfCars;
int counter;
pthread_mutex_t waitCars_mtx;
pthread_mutex_t enter_bridge_mtx[2];
void enter_bridge ( int dir ) {
NumOfCars++;
waitCars[dir]--;
counter++;
if ( waitCars[dir] > 0 && counter < 50 && NumOfCars < 100 ) {
pthread_mutex_... | 0 |
#include <pthread.h>
{
unsigned char valor;
unsigned char tomado;
pthread_mutex_t mutex;
pthread_cond_t esperoPar;
} numero_t;
numero_t arreglo[20/2];
pthread_t hilos[20];
int numeroAleatorio(int rango){
return ((rand()) % rango);
}
void arregloAleatorio(){
int i;
for(i = 0; i ... | 1 |
#include <pthread.h>
struct pub {
unsigned int mugs;
unsigned int clients;
};
struct pub my_pub;
pthread_mutex_t mug_mutex;
pthread_mutex_t bar_mutex;
pthread_cond_t mugs_cond;
void *visit_pub_cond(unsigned int *arg) {
unsigned int th_num = *arg;
int k;
printf("Moje ID %d; Wc... | 0 |
#include <pthread.h>
void print_sched(int policy){
switch(policy){
case SCHED_FIFO:
printf("SCHED_FIFO\\n");
break;
case SCHED_RR:
printf("SCHED_RR\\n");
break;
case SCHED_OTHER:
printf("SCHED_OTHER\\n");
break;
default:
printf("unknown\\n");
}
}
int int_sched(char... | 1 |
#include <pthread.h>
void *odd_func();
void *even_func();
pthread_mutex_t num_mutex;
int buf;
int flag=0;
int main()
{
pthread_t odd_th,even_th;
void *thread_result;
pthread_mutex_init(&num_mutex, 0);
pthread_create(&odd_th, 0, odd_func, 0);
pthread_create(&even_th, 0, even_fun... | 0 |
#include <pthread.h>
char *matrica;
int m,n;
int pocetak, kraj, stupac;
} thr_struct;
thr_struct *nova;
pthread_mutex_t lock;
pthread_barrier_t barijera;
void* thr_f( void* arg )
{
int pocetak = ( (thr_struct*) arg )->pocetak;
int kraj = ( (thr_struct*) arg )->kraj;
int stupac = ( (thr_s... | 1 |
#include <pthread.h>
char* prog_name;
int thread_count;
int max_thread_count;
char* key;
int key_length;
pthread_mutex_t lock;
long get_file_size(FILE* f){
long current_position = ftell(f);
fseek(f, 0, 2);
int result = ftell(f);
fseek(f, current_position, 0);
return result;
}
void read_key(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t gateaux_prets = PTHREAD_COND_INITIALIZER;
int gateaux = 0;
int stop = 0;
void* enfant(void *arg) {
int id = *((int*) arg);
int mange = 0;
while(1) {
pthread_mutex_lock(&mutex);
while(gateaux... | 1 |
#include <pthread.h>
pthread_t tid[6];
int global_count = 0;
int counter;
pthread_mutex_t lock;
void calculate(){
double pi;
pi = 4* (double)global_count/(double)3500;
printf("\\nglobal count = %d , rand times = %d\\n",global_count,3500);
printf("\\n\\033[1;41mpi is %2.6f\\033[m\\n"... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void * writer(void *p)
{
printf("\\n %s: \\n",__func__);
if(pthread_mutex_lock(&mutex)==0)
{
printf(" Writer: lock acquired\\n");
if(pthread_mutex_lock(&mutex)==0)
printf("\\n Recursive lock attempt succeded \\n");
printf(" updating commit... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int data = 0;
void *thread1(void *arg)
{
pthread_mutex_lock(&mutex);
data++;
printf ("t1: data %d\\n", data);
pthread_mutex_unlock(&mutex);
return 0;
}
void *thread2(void *arg)
{
pthread_mutex_lock(&mutex);
data+=2;
printf ("t2: ... | 0 |
#include <pthread.h>
static float * polygon_x;
static float * polygon_y;
static pthread_mutex_t * polygon_lock;
static int * contact_p1;
static int * contact_p2;
static float * contact_n_x;
static float * contact_n_y;
static float * contact_penetration;
static int * contact_used_flag;
static int ... | 1 |
#include <pthread.h>
int
explor(char *dirname, bool top) {
char *lom = "/";
DIR *d;
struct dirent *de;
char *name;
struct stat stats;
if ((d = opendir(dirname)) == 0) {
warn("%s", dirname);
exit(-1);
}
errno = 0;
while ((de = readdir(d)) != 0) {
if (de->d_name[0] == '.')
... | 0 |
#include <pthread.h>
pthread_mutex_t ANS_mutex;
int ANS[4][4];
int X[4][4] = { {1, 1, 1, 1},
{2, 2, 2, 2},
{3, 3, 3, 3},
{4, 4, 4, 4}};
int Y[4][4] = { {1, 1, 1, 1},
{2, 2, 2, 2},
{3, 3, 3, 3},
... | 1 |
#include <pthread.h>
const char * thread_outgoing_reader_tslogid = "outgoing_reader";
void * thread_outgoing_reader (void * arg)
{
tslog(0, thread_outgoing_reader_tslogid, "Started.");
struct thread_outgoing_synchroblock * synchroblock = arg;
int code;
do
{
tslog(0, thread_outgoing_read... | 0 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_cond_t go;
int numWorkers;
int numArrived = 0;
void Barrier() {
pthread_mutex_lock(&barrier);
numArrived++;
if (numArrived == numWorkers) {
numArrived = 0;
pthread_cond_broadcast(&go);
} else
pthread_cond_wait(&go, &bar... | 1 |
#include <pthread.h>
int
rw_init(struct rw_lock_t *rw)
{
struct rw_lock_t temp={0,0,PTHREAD_MUTEX_INITIALIZER,PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER,PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER};
*rw=temp;
if (rw->readers == 0 && rw->writers == 0)
return 0;
else
... | 0 |
#include <pthread.h>extern void __VERIFIER_error();
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[400];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(vo... | 1 |
#include <pthread.h>
struct targs{
int *arr;
ssize_t size;
int *dest;
pthread_mutex_t *write_lock;
pthread_t *id;
bool final;
};
int gcd(int x, int y){
while (x != y){
if (x < y) {
y -= x;
}
else {
x = x - y;
}
}
return x;
}
int lcm(int x, int y){
return (x/gcd(x,y))*y;... | 0 |
#include <pthread.h>
int buffer;
int number;
void* consumer(void*);
void* producer(void*);
pthread_mutex_t the_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t signalConsumer = PTHREAD_COND_INITIALIZER;
pthread_cond_t signalProducer = PTHREAD_COND_INITIALIZER;
int main(int argc,... | 1 |
#include <pthread.h>
static pthread_t thread_handle[YAB_NUM_THREADS];
static pthread_mutex_t thread_mutex[YAB_NUM_THREADS];
static pthread_cond_t thread_cond[YAB_NUM_THREADS];
int YabThreadStart(unsigned int id, void (*func)(void *), void *arg)
{
if (thread_handle[id])
{
fprintf... | 0 |
#include <pthread.h>
inline void* fetch_mmap(char* file_path)
{
int fd = open(file_path, O_RDWR | O_CREAT);
ftruncate(fd, 512);
void* mem =
mmap(0, 512, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (mem == MAP_FAILED)
printf("Error Mapping !");
printf("Mapped Memory Adrress : %ld \... | 1 |
#include <pthread.h>
static const char servoDir[] = "/var/servoDaemon";
int const frequency_hz = 50;
int const servo_range = 1200;
int const servo_mid = 1500;
pthread_t servoThread;
pthread_mutex_t lock;
volatile sig_atomic_t done = 0;
struct listener_struct {
pthread_t tid;
int... | 0 |
#include <pthread.h>
pthread_mutex_t t_lock;
pthread_cond_t t_cond;
int *data_array;
int sum_array[4];
struct data_info
{
int *d_point;
int idx;
};
void *t_func(void *data)
{
struct data_info d_info;
int i = 0;
int sum = 0;
d_info = *((struct data_info*)data);
pth... | 1 |
#include <pthread.h>
void *malloc(unsigned size);
int nondet_int();
int x, y, z;
int balance;
pthread_mutex_t lock;
} ACCOUNT, *PACCOUNT;
PACCOUNT create(int b)
{
PACCOUNT acc = (PACCOUNT) malloc(sizeof(ACCOUNT));
acc->balance = b;
pthread_mutex_init(&acc->lock, 0);
return acc... | 0 |
#include <pthread.h>
int forks[] = {2, 2, 2, 2, 2};
pthread_mutex_t dp_mutex;
pthread_cond_t both_free[5];
int right[] = {1, 2, 3, 4, 0};
int left[] = {4, 0, 1, 2, 3};
int iters;
void getforks(int i)
{
pthread_mutex_lock(&dp_mutex);
if (forks[i] < 2) pthread_cond_wait(&both_free... | 1 |
#include <pthread.h>
int buffer[8];
int bufin = 0;
int bufout = 0;
pthread_mutex_t buffer_lock = PTHREAD_MUTEX_INITIALIZER;
unsigned long sum = 0;
sem_t hay_datos;
sem_t hay_sitio;
void obten_dato(int *itemp)
{
pthread_mutex_lock(&buffer_lock);
*itemp = buffer[bufout];
bufout = (bufo... | 0 |
#include <pthread.h>
int packetNum;
int numOfPacks;
char * packets[100];
pthread_mutex_t packetNumMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t packetsMutex = PTHREAD_MUTEX_INITIALIZER;
{
char * ip;
int port;
}SERVER;
void * getPackets(void * serv)
{
SERVER * myserv = serv;... | 1 |
#include <pthread.h>
int makethread(void *(*)(void *), void *);
struct to_info{
void (*to_fun)(void *);
void *to_arg;
struct timespec to_wait;
};
void *timeout_helper(void *arg)
{
struct to_info *tip;
tip = (struct to_info *)arg;
nanosleep(&tip->to_wait, 0);
(*tip->to_fun)(tip->to_arg... | 0 |
#include <pthread.h>
int (*grid)[9];
int max_threads;
char *filename;
int *thread_number;
int errors;
pthread_mutex_t mutex_error;
int load_grid(char *filename) {
grid = (int (*)[9])malloc(sizeof(*grid)*9);
FILE *input_file = fopen(filename, "r");
if (input_file != 0) {
for(int i = 0; ... | 1 |
#include <pthread.h>
int f_count;
int f_id;
pthread_mutex_t f_lock;
}foo;
foo * foo_alloc(int id);
void foo_hold(foo *fp);
void foo_free(foo *fp);
void * start_routine(void *);
foo *
foo_alloc(int id)
{
foo *fp;
if ((fp = (foo *)malloc(sizeof(foo))) != 0) {
if (pthread_mutex_init(&fp->... | 0 |
#include <pthread.h>
static pthread_mutex_t s_mutex;
static FILE *s_fileHandler;
void LOGGER_PL_init(int isPrintToLogFile)
{
s_fileHandler = 0;
if (isPrintToLogFile)
s_fileHandler = fopen("log.log", "w");
pthread_mutex_init(&s_mutex, 0);
}
static void printToConsole(char *logMs... | 1 |
#include <pthread.h>
static pthread_mutex_t gGetmntentMutex = PTHREAD_MUTEX_INITIALIZER;
struct mntent *getmntent(FILE *fp) {
static struct mntent mnt;
static char *buf = 0;
struct mntent *ret;
pthread_mutex_lock(&gGetmntentMutex);
if (buf == 0) {
buf = malloc(4096);
if (buf =... | 0 |
#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 unlocking locks...\\n"... | 1 |
#include <pthread.h>
pthread_mutex_t mutexLock;
sem_t oddSem;
sem_t evenSem;
void *print_even_nums(void *param) {
int even_num_to_print;
for(even_num_to_print = 2; even_num_to_print <= 100;) {
sem_wait(&oddSem);
pthread_mutex_lock(&mutexLock);
printf("%4d", even_num_to_print);
pthre... | 0 |
#include <pthread.h>
unsigned short X_data_trace[512 * 512];
unsigned short X_data_retrace[512 * 512];
unsigned short Y_data_trace[512 * 512];
void readHugeData(void)
{
int len;
DEBUG0("IN readHugeData");
len = recv(connect_socket_fd, (char *)X_data_trace, 512 * 512 * 2, MSG_WAITALL);
len = r... | 1 |
#include <pthread.h>
int number;
pthread_mutex_t mu= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t sig_consumer= PTHREAD_COND_INITIALIZER;
pthread_cond_t sig_producer= PTHREAD_COND_INITIALIZER;
void *consumer(void *dummy)
{
int printed= 0;
" now\\"\\n", pthread_s... | 0 |
#include <pthread.h>
struct shared
{
int sum;
pthread_mutex_t mut;
int global_index;
};
struct matrix
{
int nbLines;
int nbColumns;
int** elements;
struct shared *psh;
};
static void *sum_array (void *p);
int main(int argc, char *argv[])
{
srand(time... | 1 |
#include <pthread.h>
{
pthread_t thread;
char* name;
int id;
int isDancing;
int isEating;
} customer_t;
customer_t customers[12];
int dancing_status;
int eating_status;
int isCurfew;
pthread_mutex_t dance_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t eat_mutex = PTHREAD_MUTEX_IN... | 0 |
#include <pthread.h>
pthread_mutex_t cond_var_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_var_odd_done = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_var_even_done = PTHREAD_COND_INITIALIZER;
int evenDone = 0;
int oddDone = 0;
void* thread_Even(void* args)
{
printf("thread_Even +... | 1 |
#include <pthread.h>
struct board {
unsigned int width;
unsigned int queens;
unsigned int left, down, right;
};
struct task {
board board;
struct task *next;
};
static pthread_mutex_t tasks_mutex = PTHREAD_MUTEX_INITIALIZER;
static task *tasks;
static board *
get_task()
{
task *t;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void recover(void)
{
printf("\\n Performing Recovery by Thread : %u \\n",syscall(SYS_gettid));
printf("\\n Recovery completed by Thread : %u \\n",syscall(SYS_gettid));
pthread_mutex_lock(&mutex);
}
void * write_thread (void *p)
{
printf("\\... | 1 |
#include <pthread.h>
void *writeIps(void *pa)
{
int check,fwrite_check,i;
int flag;
FILE *fp;
long double tempVal = 0.0;
float value = 0.0;
check = 0;
while(check==0)
{
semaphore_p(sem_fft3);
check = fft3Status[4];
semaphore_v(sem_fft3);
pthread_mutex_lock(&ipsSto... | 0 |
#include <pthread.h>
extern FILE *fileout_basicmath_sqrt;
extern pthread_mutex_t mutex_print;
int main_basicmath_sqrt(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 = -31.0;
doubl... | 1 |
#include <pthread.h>
void* clnt_connection(void *arg);
void send_msg(char* msg, int len);
void matching_seq();
void error_handling(char *msg);
void signal_handler(int signo);
int clnt_no = 0;
int clnt_socks[10][2];
int matched = 0;
int defender_selected = 0;
int role[10];
struct sigaction siga... | 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 mybarrier;
double row[45];
} DATAITEM;
DATAITEM column[45 +1];
int NO_PROC;
void barrier_init(barrier_t * mybarrier)
... | 1 |
#include <pthread.h>
int counter;
int count;
pthread_mutex_t train_mtx;
pthread_mutex_t enter_passenger_mtx;
pthread_mutex_t *exit_passenger_mtx;
pthread_mutex_t counter_mtx;
pthread_mutex_t end_mtx;
void StartTtrip () {
pthread_mutex_lock ( &train_mtx ) ;
printf("Starting...!!!\\n");
}... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void *protected_fun(void *ptr)
{
char *message;
pthread_mutex_lock( &mutex1 );
message = (char *)ptr;
int i;
for(i = 0; i < 5; i++)
{
printf("%s = %d\\n", message, i);
sleep(1);
}... | 1 |
#include <pthread.h>
double const delta = 1.0 / 1000000000;
int sliceSize ;
double sum;
pthread_mutex_t sumMutex;
void * partialSum(void *const arg ) {
int const start = 1 + ((long)arg) * sliceSize;
int const end = (((long)arg) + 1) * sliceSize;
double localSum = 0.0;
for (int i... | 0 |
#include <pthread.h>
int g_buffer[10];
unsigned short in = 0;
unsigned short out = 0;
unsigned short produce_id = 0;
unsigned short consume_id = 0;
sem_t g_sem_full;
sem_t g_sem_empty;
pthread_mutex_t g_mutex;
pthread_t g_thread[1 +5];
void *consume(void *arg)
{
int i;
while(1)
... | 1 |
#include <pthread.h>
pthread_t id;
int loop_time;
struct tm *time;
}item;
item buffer[8];
sem_t empty, full;
pthread_mutex_t mutex;
int in = 0, out = 0;
void Producer(void *arg);
void Consumer(void *arg);
int main(int argc, char *argv[])
{
pthread_t producer[3];
pthread_t consumer[5];
... | 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) {... | 1 |
#include <pthread.h>
int recordSize = 1024;
int threadsNr;
char *fileName;
int fd;
int numOfRecords;
int creatingFinished = 0;
char *word;
int rc;
int someonefound = 0;
int detachedNr = 0;
pthread_key_t key;
pthread_t *threads;
int *wasJoin;
pthread_mutex_t mutexForRecords = PTHREAD_MUTEX_INITIA... | 0 |
#include <pthread.h>
static void thread_create(pthread_t *tid,void *(*fun)(void *));
static void thread_wait(pthread_t tid);
static void maketimeout(struct timespec *tsp,long min);
void * fun1(void *arg);
void * fun2(void *arg);
pthread_mutex_t lock;
pthread_cond_t cond = PTHREAD_COND_INITIALIZ... | 1 |
#include <pthread.h>
struct job {
struct job* next;
int dato;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
void* raiz_cuadrada (void* arg){
while (1){
struct job* next_job;
pthread_mutex_lock (&job_queue_mutex);
if (job_queue == 0){
next_jo... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.