text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int **matrice = 0;
int digprinc=0;
int digsec=0;
int rigcent=0;
int colcent=0;
int n=0;
int i =0;
int j=0;
int max=0;
int array[4];
void *funzione(void *param){
while(i<n){
pthread_mutex_lock(&mutex);
dig... | 1 |
#include <pthread.h>
extern char **envrion;
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);
... | 0 |
#include <pthread.h>
int semid;
char operazione;
int riga;
int colonna;
int **matA,**matB,**matC;
int *somma;
int dimensione;
}msg;
pthread_mutex_t mutex;
void * threadFiglio (void * args){
msg* data=(msg * )args;
int riga=data->riga;
int colonna = data->colonna;
char ope... | 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>
int fd = -1;
int open_port(char* serial_path, int speed) {
fd = open(serial_path, O_RDWR | O_NOCTTY | O_NDELAY);
if (fd == -1) {
status->pipe_error = PIPE_COULD_NOT_OPEN_ERROR;
return -1;
}
fcntl(fd, F_SETFL, FNDELAY);
struct termios options;
tcgetattr(f... | 1 |
#include <pthread.h>
char *buf[10];
pthread_mutex_t lock;
int stock;
pthread_cond_t condlock;
int count;
void * produce(void * arg){
while(1){
pthread_mutex_lock(&lock);
while(stock >= 10)
pthread_cond_wait(&condlock, &lock);
sprintf(buf[stock],"consumer %d\\n", count++);
stock++... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
void fh_init() {
int i;
pthread_mutex_lock(&hashlock);
for(i = 0; i < 29; ++i)
fh[i] = 0;
pthrea... | 1 |
#include <pthread.h>
int totalNumOfPassengers = 10;
int numOfPassengersOnBus = 0;
int maxPassenger = 5;
int isBusArrived = 0;
void* bus(void* ptr);
void* passenger(void* ptr);
pthread_cond_t condFull, condArrived, condEmpty, condAvailable;
pthread_mutex_t lock;
int main(int argc, char* arg... | 0 |
#include <pthread.h>
{
int meals[5];
pthread_mutex_t mutex;
} meal_data;
meal_data shared;
{
FILE *outputFile;
pthread_t philosophers[5];
void* status;
int error;
} dinner_table;
dinner_table thisTable;
void philosopher(int i);
void think();
void eat(int i);
void t... | 1 |
#include <pthread.h>
struct block_filter * create_block_filter(int block_size, int block_num) {
struct block_filter * filter = 0;
struct block * blocks = 0;
u_char *data = 0;
int i;
filter = malloc(sizeof(struct block_filter));
if (filter == 0)
goto OK;
blocks = malloc(block_n... | 0 |
#include <pthread.h>
struct passed_args{
long pid;
};
pthread_mutex_t count_mutex;
pthread_mutex_t mutex;
pthread_mutex_t print_mutex;
long int accessers = 0;
void *accesser(void *passed_arg);
int main(int argc, char **argv)
{
if (argc != 2) {
printf(
... | 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(stru... | 0 |
#include <pthread.h>
unsigned int global;
static pthread_mutex_t mutex;
void *increment_global(void *threadid)
{
printf("Valeur initiale : %d\\n", global);
pthread_mutex_lock(&mutex);
while (global < 1e8) {
global++;
}
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
int main ... | 1 |
#include <pthread.h>
struct job {
struct job* next;
int value;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
void process_job(struct job* job)
{
printf("now thread: %d finish the job: %d\\n", (int)pthread_self(), job->value);
}
void* ... | 0 |
#include <pthread.h>
void initSwitchBuffer(struct switch_buffer ** buffer, unsigned int size);
void freeSwitchBuffer(struct switch_buffer ** buffer);
int switchBufferQueue(struct switch_buffer * buffer, struct switch_if * receiverIf, const u_char * packetData, const int packetLength);
const str... | 1 |
#include <pthread.h>
struct args {
int n;
int s;
int* threadid;
};
double* A=0;
double* B=0;
double* C = 0;
void Get_dims(int* n_p);
void *Mat_Mat_mult(void *arguments);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int main(void) {
double* A = 0;
double* B = 0;
double c = ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full, empty;
buffer_type buffer[5];
int counter;
pthread_t thread_id;
pthread_attr_t attr;
void *producer_thread(void *param);
void *consumer_thread(void *param);
void initializi() {
pthread_mutex_init(&mutex, 0);
sem_init(&fu... | 1 |
#include <pthread.h>
struct list_node_s
{
int data;
struct list_node_s* next;
pthread_mutex_t mutex;
};
double timeval_diff(struct timeval *a, struct timeval *b)
{
return
(double)(a->tv_sec + (double)a->tv_usec/1000000) -
(double)(b->tv_sec + (double)b->tv_usec/1000000);
}
int threa... | 0 |
#include <pthread.h>
char getch(void);
struct RingBuffer
{
unsigned int tail;
unsigned int head;
unsigned char data[(16)];
};
char ringBufGetChar (struct RingBuffer *apBuffer)
{
int index;
index = apBuffer->head;
apBuffer->head = (apBuffer->head + 1) % (16);
retu... | 1 |
#include <pthread.h>
int bloqueadas = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void barreira(){
pthread_mutex_lock(&mutex);
if (bloqueadas == (5 -1)) {
pthread_cond_broadcast(&cond);
bloqueadas = 0;
} else {
bloqueadas++;
pthread_cond_wait(&cond, &mutex);
}
pthread_mutex_un... | 0 |
#include <pthread.h>
void helloSender(void *param)
{
struct shared_mem *mem = (struct shared_mem*) param;
int len;
char *msg = formHelloPacket(mem->local_id, &len);
for(;;){
DBG("helloSender: saying hello!");
sendToNeighbours(0, msg, len, mem);
sleep(HELLO_TIMER);
}
}
void ddrSende... | 1 |
#include <pthread.h>
static unsigned short timeout=10;
struct did_cache_entry {
char dirname[AFP_MAX_PATH];
unsigned int did;
struct timeval time;
struct did_cache_entry * next;
} ;
int free_entire_did_cache(struct afp_volume * volume)
{
struct did_cache_entry * d, * p, *p2;
pt... | 0 |
#include <pthread.h>
static pthread_mutex_t id_mutex = PTHREAD_MUTEX_INITIALIZER;
static uint32_t next_id = 1;
static int wish_init_heartbeat_packet_impl( struct wish_state* state, struct wish_heartbeat_packet* h ) {
memset( h, 0, sizeof(struct wish_heartbeat_packet) );
struct sysinfo sys... | 1 |
#include <pthread.h>
pthread_t tid[R_THREADS];
pthread_mutex_t mutex;
sem_t sem;
char filebuffer[FB_SIZE][13];
int stop = 0;
int ri = 0;
int wi = 0;
void closeFile(int fp, char *filename){
if(flock(fp, LOCK_UN) == -1)
printf("[Reader] Failed to unlock file %s. (%s)\\n", filename, strerror(... | 0 |
#include <pthread.h>
pthread_mutex_t *mutex;
int main()
{
char *ptr;
int i;
pid_t pid;
pthread_mutexattr_t attr;
mutex = mmap(0, sizeof(pthread_mutex_t), PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
pthread_mutexattr_init(&attr);
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_... | 1 |
#include <pthread.h>
void *customerMaker();
void *barberShop();
void *waitingRoom();
void checkQueue();
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t sleep_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t barberS... | 0 |
#include <pthread.h>
void *Producer();
void *Consumer();
int BufferIndex=0;
char *BUFFER;
pthread_cond_t Buffer_Not_Full=PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar=PTHREAD_MUTEX_INITIALIZER;
int main()
{
pthread_t ptid,ctid;
... | 1 |
#include <pthread.h>
struct playclock *nemoplay_clock_create(void)
{
struct playclock *clock;
clock = (struct playclock *)malloc(sizeof(struct playclock));
if (clock == 0)
return 0;
memset(clock, 0, sizeof(struct playclock));
if (pthread_mutex_init(&clock->lock, 0) != 0)
goto err1;
c... | 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);
pthread_mutex_in... | 1 |
#include <pthread.h>
int cntA;
int cntB;
int cntC;
pthread_mutex_t mutaA;
pthread_mutex_t mutaB;
pthread_mutex_t mutaC;
pthread_t threads[10];
int array[100*10];
void *init(void *arg) {
int idx = (*(int *) arg);
int offset = idx * 100;
int i;
for (i = 0; i < 100; i++) {
array[i+offset] = ... | 0 |
#include <pthread.h>
int pthread_library_is_available = 0;
int pthread_detection_done = 0;
int (*pthread_key_create_fnptr)(pthread_key_t *key,
void (*destructor)(void*)) = 0;
void *(*pthread_getspecific_fnptr)(pthread_key_t key) = 0;
int (*pthread_setspecific_fnptr)(pthread_key... | 1 |
#include <pthread.h>
int vector_size;
double start_time, end_time;
pthread_mutex_t mutex_size = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_vector = PTHREAD_MUTEX_INITIALIZER;
void set_start_time(){
double usec;
struct timeval current_time;
gettimeofday(¤t_time,0);
usec=curre... | 0 |
#include <pthread.h>
int buffer;
int number;
sem_t empty,full;
void* consumer(void*);
void* producer(void*);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char *argv[]) {
if(argv[1] != 0) {
buffer = atoi(argv[1]);
number = 0;
}
else {
... | 1 |
#include <pthread.h>
uint64_t nb;
FILE * file;
char str[60];
pthread_t thread0;
pthread_t thread1;
pthread_mutex_t lock;
void* thread_prime_factors(void * u);
void print_prime_factors(uint64_t n);
void* thread_prime_factors(void * u)
{
pthread_mutex_lock(&lock);
while ( fgets(str, 60... | 0 |
#include <pthread.h>
int main()
{
int philosopherIds[__NR_OF_PHILOSOPHERS];
pthread_t philosophersThreads[__NR_OF_PHILOSOPHERS];
initializeMutex();
preparePhilosopers(philosopherIds,philosophersThreads);
finalize(philosophersThreads);
return 0;
}
void initializeMutex()
{... | 1 |
#include <pthread.h>
pthread_mutex_t head_p_mutex = PTHREAD_MUTEX_INITIALIZER;
struct list_node_s{
int data;
struct list_node_s* next;
pthread_mutex_t mutex;
};
int Member(int value, struct list_node_s* head_p){
struct list_node_s* temp_p;
pthread_mutex_lock(&head_p_mutex);
temp_p = ... | 0 |
#include <pthread.h>
static volatile int pid = -1;
static int prog_length;
static pthread_mutex_t pid_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t zombie_lock = PTHREAD_MUTEX_INITIALIZER;
static int get_current_pid(void)
{
int __pid;
pthread_mutex_lock(&pid_lock);
__pid = p... | 1 |
#include <pthread.h>
struct node *head = 0;
struct node *create_node(int value) {
struct node *newnode = malloc(sizeof(struct node));
pthread_mutex_init(&newnode->lock, 0);
newnode->value = value;
newnode->next = 0;
return newnode;
}
void insert(struct list *L, int value){
... | 0 |
#include <pthread.h>
int on_train;
int start_trip;
pthread_mutex_t pass_mtx;
pthread_mutex_t wait_mtx;
struct list *nxt;
}waitL;
waitL *root_train=0;
waitL *end_train=0;
pthread_mutex_t mtx_train = PTHREAD_MUTEX_INITIALIZER;
waitL *root_passengers=0;
waitL *end_passengers=0;
pthread... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condition_c, condition_p;
int buffer = 0;
void* producer(void *ptr) {
for (int i = 1; i <= 10; i++) {
pthread_mutex_lock(&mutex);
while (buffer != 0) {
pthread_cond_wait(&condition_p, &mutex);
}
... | 0 |
#include <pthread.h>
int g = 0;
pthread_mutex_t l;
void *foo(void *arg) {
long x = (long)arg;
if (x == 1 || g > 10) {
pthread_mutex_lock(&l);
}
g = 10;
RC_ACCESS(1, RC_ALIAS | RC_MHP | RC_RACE);
RC_ACCESS(1, RC_ALIAS | RC_MHP | RC_RACE);
if (x == 1 && g > 10) {
... | 1 |
#include <pthread.h>
int count = 0;
int readcount = 0;
int writecount = 0;
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
pthread_mutex_t mutex3;
pthread_mutex_t w;
pthread_mutex_t r;
void *reader_thread(void *p) {
long id = (long) p;
int i = 10;
while (i --> 0) {
pthread_mutex_l... | 0 |
#include <pthread.h>
struct glob{
int a;
int b;
}obj;
pthread_mutex_t mutex;
void *writer(void *arg){
printf("writer-thread has created: %lu\\n",pthread_self());
pthread_mutex_lock(&mutex);
obj.a = 10;
pthread_exit(0);
sleep(1);
obj.b = 20;
pthread_mutex_unlock(&mutex);
return 0;
}... | 1 |
#include <pthread.h>
struct person_info {
int sex;
char name[32 +1];
int age;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *write_thread_routine(void * arg)
{
int i;
char buf[1024];
struct person_info *pInfo = (struct person_info *)arg;
printf("I'm sub thread,my thre... | 0 |
#include <pthread.h>
pthread_mutex_t lockAmp;
pthread_mutex_t lockDolar;
pthread_mutex_t lockBirlesim;
pthread_mutex_t lockMakine;
int amp = 0;
int dolar = 0;
int sayac = 1;
void makina();
void makinaAmp();
void makinaDolar();
void makinaBirlestir();
int main(int argc, ... | 1 |
#include <pthread.h>
void * whattodo( void * arg );
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main()
{
int i, rc;
int * t;
pthread_t tid[ 8 ];
for ( i = 0 ; i < 8 ; i++ )
{
t = (int *)malloc( sizeof( int ) );
*t = 3 + ( rand() % 11 );
printf( "MAIN: Ne... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
long long n;
double sum;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
int main(int argc, char* argv[])
{
long thread;
pthread_t* thread_handles;
thread_count = strtol(argv[1],0,10);
n = strtoll(argv[2],0,10);
th... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_mutex_t min_mutex, max_mutex;
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);
... | 0 |
#include <pthread.h>
struct msg{
struct msg *next;
int num;
};
struct msg *head;
pthread_cond_t g_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
void* threadFunc_Consumer(void* args){
struct msg *mp;
while(1){
pthread_mutex_lock(&g_mutex);
... | 1 |
#include <pthread.h>
enum
{
NOT_RESERVED = 0,
RESERVED_DATA = 1,
RESERVED_FREE = 2,
};
static int g_buffer_size;
static int g_start_idx;
static int g_data_size;
static int g_reserve_type;
static int g_reserve_size;
char *g_data_buffer = 0;
pthread_mutex_t g_buf_mutex;
int init_buffe... | 0 |
#include <pthread.h>
void *sum(void *p);
unsigned long int sumtotal = 0;
unsigned long int n;
int numthreads;
pthread_mutex_t mutex;
int main(int argc, char **argv) {
pthread_t tid[8];
int i, myid[8];
struct timeval start, end;
gettimeofday(&start, 0);
scanf("%lu %d", &n, &numthreads)... | 1 |
#include <pthread.h>
int ssock;
pthread_mutex_t smutex = PTHREAD_MUTEX_INITIALIZER;
void* comth(void* arg)
{
int ix;
int csock;
char buf[64];
int len;
ix = *((int*)arg);
free(arg);
while(1)
{
pthread_mutex_lock(&smutex);
csock = accept(ssock, 0, 0);
pthread_mutex... | 0 |
#include <pthread.h>
int semsetid = -1;
pthread_mutex_t mutex;
union semun
{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
void getChopsticks(int num)
{
int left = num;
int right = (num + 1) % 5;
struct sembuf sem[2] = {{left, -1, 0},
{right, -1,... | 1 |
#include <pthread.h>
{
char buff[100];
char fin;
int hilos;
int espera;
sem_t semaforo_es;
sem_t semaforo_mayus;
}
datos_compartidos;
int aleatorio (void);
void * es (void *);
void * mayus (void *);
int main (int argc, char * argv[])
{
int i, e;
pthread_t tids... | 0 |
#include <pthread.h>
int flag = 0;
struct Usuario{
char telefone[4];
char enderecoIP[4];
char porta[4];
int status;
struct Usuario *prox;
};
usuario *LISTA;
pthread_t thread_servidor;
pthread_mutex_t mutex;
void *Servidor(void *args);
void insereFim(usuario *LISTA, char tel[], cha... | 1 |
#include <pthread.h>
BTN_PRESS = 0,
BTN_RELEASE
} BTN_STATE_E;
static BTN_STATE_E current_btn_state = BTN_RELEASE;
static short worker_stop = 0;
static useconds_t worker_delay = 200000;
static pthread_mutex_t btn_state_lock;
void sigint_handler (int s) {
debug("Caught signal %d\\n", ... | 0 |
#include <pthread.h>
pthread_mutex_t consoleMutex;
pthread_mutex_t debugMutex;
struct threadArgs {
int threadId;
char searchString[15];
int startIndex;
int endIndex;
char searchArray[100000][15];
};
void *threadWork(void *args) {
struct threadArgs * newArgs;
newArgs = (struct thre... | 1 |
#include <pthread.h>
struct list_head {
struct list_head *next ;
struct list_head *prev ;
};
struct s {
int datum ;
struct list_head list ;
};
struct cache {
struct list_head slot[10] ;
pthread_mutex_t slots_mutex[10] ;
};
struct cache c ;
static inline void INIT_LIST_HEAD(s... | 0 |
#include <pthread.h>
int tid;
} data;
int x;
int y;
} int2;
double x;
double y;
} double2;
float **mat;
double x = -DBL_MAX, dt=0.001;
int nColumns=2048, nLines=2048, i = 0, size;
pthread_mutex_t mutex;
pthread_cond_t condM;
pthread_cond_t condE;
int2 coordinatesConver... | 1 |
#include <pthread.h>
int *spaces;
int capacity;
int occupied;
int nextin;
int nextout;
int car_in;
int car_out;
pthread_mutex_t lock;
pthread_cond_t num_space;
pthread_cond_t num_car;
pthread_barrier_t barrier;
} parking_lot_t;
static void *... | 0 |
#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_MUT... | 1 |
#include <pthread.h>
char bwc_buffer[BUFFER_LENGTH];
char bwss_buffer[BUFFER_LENGTH];
pthread_t bwss_thread;
pthread_t bwc_thread;
char *bwss_port = "2000";
char *bwc_port = "2001";
int bwc_socket;
int bwss_socket;
int cnt,ready,ready2;
pthread_mutex_t mutex;
pthread_cond_t cond,cond2;
void*... | 0 |
#include <pthread.h>
unsigned char startsWith(const char* str, const char* cmp)
{
while(1) {
char strC;
char cmpC = *cmp;
if(cmpC == '\\0') return 1;
strC = *str;
if(strC == '\\0' || strC != cmpC) return 0;
str++;cmp++;
}
}
char* skipWhitespace(char* s)
{
while(1) {
... | 1 |
#include <pthread.h>
FILE *fs;
FILE *ft;
long NumThreads;
int ThreadParam[64];
pthread_t ThreadHandle[64];
pthread_attr_t ThreadAttr;
pthread_mutex_t lock;
unsigned long long Primes[8192];
int PrimesIndex[8192];
unsigned long long array[8192];
int size;
void* (*MTFindPrimesFunc) (void *arg);
... | 0 |
#include <pthread.h>
enum Colour
{
blue = 0,
red = 1,
yellow = 2,
Invalid = 3
};
const char* ColourName[] = {"blue", "red", "yellow"};
const int STACK_SIZE = 32*1024;
const BOOL TRUE = 1;
const BOOL FALSE = 0;
int CreatureID = 0;
enum Colour doCompliment(enum Colour c1, enum Colo... | 1 |
#include <pthread.h>
pthread_mutex_t cm_debug_file_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t cm_notice_file_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t cm_warn_file_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t cm_error_file_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t c... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int pepsi = 0;
int counter = 0;
void * produce(){
while(pepsi < 50 && counter == 0){
pthread_mutex_lock(&mutex1);
counter++;
pthread_mutex_unlock(&mutex1);
printf("Producer has produced... | 1 |
#include <pthread.h>
void parse_url(char *url, struct request *req)
{
char *s;
int i, j, k;
int temp;
i = j = k = 0;
s = url;
printf("%s\\n", s);
if ((strncmp(url, "ftp://", 6)) == 0) {
fprintf(stderr, "Error: Currently Aget doesn't support FTP requests...\\n");
exit(1);
} else
if ... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cond_reset=PTHREAD_COND_INITIALIZER;
int x=0;
void * writer(void* arg){
int numWriter = *(int*) arg;
while(1){
pthread_mutex_lock(&m);
printf(" incr%d: before x=%d\\n",numWriter,x);
x+=1;
printf(" after x=%... | 1 |
#include <pthread.h>
int count = 1;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *threadStep (void *a) {
while (count < 1000000) {
pthread_mutex_lock (&m);
count++;
pthread_mutex_unlock (&m);
}
}
void *threadPrgs (void *a) {
int p, i;
while (c... | 0 |
#include <pthread.h>
static pthread_mutex_t randLock;
static unsigned int randSeed;
void randInit() {
randSeed = (unsigned int) time(0);
pthread_mutex_init(&randLock, 0);
}
int nextRand() {
pthread_mutex_lock(&randLock);
int val = rand_r(&randSeed);
pthread_mutex_unlock(&randLoc... | 1 |
#include <pthread.h>
unsigned long fh;
uint64_t readpos;
uint32_t refcount;
struct _fhentry *next;
} fhentry;
static unsigned long nextfh=1;
static fhentry *fhhead=0;
static uint8_t opbuff[0x1000000];
static uint64_t writepos=0;
static uint8_t waiting=0;
static pthread_mutex_t opbuffl... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_pi;
double pi;
struct thread_data_st
{
int st_my_rank;
int st_n;
double st_my_pi;
};
struct thread_data_st thread_data_st_array[8];
void *calc_pi_routine(void *routine_data)
{
int n, my_rank, i;
double x, h, sum;
struct thread_data_st *r_data;
r... | 1 |
#include <pthread.h>
void memory_data_register(void *not_used){
pthread_barrier_wait(&threads_creation);
while(1){
pthread_mutex_lock(&control_sign);
if(!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait,&control_sign) != 0);
}
... | 0 |
#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)
... | 1 |
#include <pthread.h>
struct spmc_moal_t {
pthread_mutex_t moal;
void **data;
uintptr_t len;
uintptr_t max;
};
struct spmc_moal_t *spmc_moal_init(uintptr_t max) {
struct spmc_moal_t *q = (struct spmc_moal_t*)malloc(sizeof(struct spmc_moal_t));
if (q == 0) {
return... | 0 |
#include <pthread.h>
struct jc_type_file_seq_cwlv {
struct jc_type_file_comm_hash *comm_hash;
};
static struct jc_type_file_seq_cwlv global_cwlv;
static int
jc_type_file_seq_cwlv_init(
struct jc_comm *jcc
)
{
return global_cwlv.comm_hash->init(global_cwlv.comm_hash, jcc);
}
static int
jc_t... | 1 |
#include <pthread.h>
struct WaitGroup {
int count;
pthread_cond_t cnd;
pthread_mutex_t mtx;
};
int Wait(struct WaitGroup * wp) {
if(0 == wp) {
return EINVAL;
}
pthread_mutex_lock(&wp -> mtx);
while(wp -> count > 0) {
pthread_cond_wait(&wp -> cnd, &wp ... | 0 |
#include <pthread.h>
double max;
double min;
double average;
double total;
double num;
double input_start[5];
double* input_end = input_start;
int quit;
pthread_mutex_t lock1;
void calculate(double f){
if (f > max){
max = f;
}
if (f < min){
min = f;
}
total = f + total;
num++;
... | 1 |
#include <pthread.h>
char family_type[20];
char name[20];
int enter_time;
int exit_time;
};
static sem_t mysem;
static pthread_mutex_t capuletlock;
static pthread_mutex_t montaguelock;
static int num_capulets=0;
static int num_montagues=0;
void *gang_member(void *args)
{
struct pe... | 0 |
#include <pthread.h>
struct data
{
int *fullarr;
int fullsize;
int partsize;
};
int min = (10000 + 1);
pthread_mutex_t mutex;
struct data dataitem;
void *findmin(int *arg)
{
int i, j, start, end, len, mymin;
int *array;
i = arg;
len = dataitem.partsize;
start = i*len;
end = start ... | 1 |
#include <pthread.h>
int s=0;
sem_t full,empty;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int q[5];
void *prod(void *count)
{
int* c = (int*)count;
long int i;
int j;
for(i=0;i<10;i++)
{
sem_wait(&full);
sem_getvalue(&full,&s);
printf("full= %d\\n", s);
pthread_mutex_l... | 0 |
#include <pthread.h>
struct skynetCore_t{
pthread_mutex_t protector;
pid_t pid;
};
int set_priority(int priority)
{
int policy;
struct sched_param param;
if (priority < 1 || priority > 63) return -1;
pthread_getschedparam(pthread_self(), &policy, ¶m);
param.sched_... | 1 |
#include <pthread.h>
int ** bigMatrix[200];
int value;
pthread_mutex_t lock;
} counter_t;
counter_t *prCount;
counter_t *coCount;
int producerTotal = 0;
int consumerTotal = 0;
int buffer[200];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;
int producerSum = 0;
int consumerSum = 0;
int l... | 0 |
#include <pthread.h>
pthread_mutex_t oskit_uvm_mutex;
pthread_key_t oskit_uvm_per_thread_key;
static void thread_create_hook(pthread_t tid);
static void thread_destroy_hook(pthread_t tid);
static void per_thread_destructor(void *arg);
static void thread_csw_hook(void);
extern void
oskit_uvm_th... | 1 |
#include <pthread.h>
void init(int n, double (**A)[n], double **b, double **x0, double **x1)
{
*A = malloc(n * n * sizeof(double));
*b = malloc(n * sizeof(double));
*x0 = malloc(n * sizeof(double));
*x1 = malloc(n * sizeof(double));
unsigned short xi[3] = {4, 153, 17};
int i,j;
for (i ... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo *
foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) == 0)... | 1 |
#include <pthread.h>
int *numbers;
size_t length;
} thread_arg_t;
static int Sum = 0;
static pthread_mutex_t Sum_Mutext = PTHREAD_MUTEX_INITIALIZER;
static void *thread_start(void *arg) {
thread_arg_t *thread_args = (thread_arg_t *) arg;
int *numbers = thread_args->numbers;
s... | 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... | 1 |
#include <pthread.h>
clock_t startm, stopm;
int PORT = 8181;
int putConsole(const char* msg);
void* doNewThread(void* Iterations);
pthread_mutex_t console;
int main(int argc, char **argv) {
if ( (startm = clock()) == -1) { printf("Error calling clock"); exit(1); };
pthread_t* thrArr... | 0 |
#include <pthread.h>
pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t num_in_mutex = PTHREAD_MUTEX_INITIALIZER;
double x;
double y;
} points;
points points_buf[32];
int read;
int write;
int done;
int num_elms;
}fifo_buf;
void init_fifo_buf(fifo_buf * buffer){
... | 1 |
#include <pthread.h>
void *producer (void *args);
void *consumer (void *args);
int a_mem[0xffff];
int b_mem[0xffff];
pthread_mutex_t *a_mutex;
pthread_mutex_t *b_mutex;
int a_is_processing;
int b_is_processing;
int a_is_empty;
int b_is_empty;
pthread_cond_t *a_is_ready, *a_isnt_proces... | 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... | 1 |
#include <pthread.h>
int * T;
sem_t * sem;
pthread_mutex_t * lock;
pthread_cond_t * cond;
void wtc_proc_init(int * initial_matrix, int n, int number_of_processes) {
sem_t * temp_sem;
int process_number;
pthread_condattr_t cond_attr;
pthread_mutexattr_t lock_attr;
T = share_memory(s... | 0 |
#include <pthread.h>
void* task(void* arg);
int var = 0;
int max = INT_MIN;
int min = 32767;
pthread_mutex_t lock;
int main(int argc, char* argv[])
{
pthread_mutex_init(&lock, 0);
pthread_t threads[6];
int threadArgs[6];
int i;
for (i = 0; i < 6; ++i) {
threadArgs[i] = i;
printf("Ma... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
uint8_t savedNonce[32];
volatile bool nonceFound;
void saveNonce(uint8_t *val) {
pthread_mutex_lock(&mutex);
if (nonceFound) return;
memcpy(savedNonce, val, 32);
nonceFound=1;
pthread_mutex_unlock(&mutex);... | 0 |
#include <pthread.h>
int buffer[100];
int nextp, nextc;
int count=0;
int procheck = 0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void printfunction(void * ptr)
{
int count = *(int *) ptr;
if (count==0)
{
printf("All items produced are consumed by the consumer \\n");
}
else
{
... | 1 |
#include <pthread.h>
int NUM_BINS;
pthread_mutex_t lock;
long long rand_per_thread;
struct bin{
int lower;
int upper;
long long value;
} ;
struct bin *my_bin;
void *histogram(void *threadid)
{
long tid;
tid = (long)threadid;
int i,j;
int x;
srand(time(0));
for(i=0;i<rand_per... | 0 |
#include <pthread.h>
struct timerfd_context {
int fd;
pthread_t worker;
timer_t timer;
int flags;
struct timerfd_context *next;
};
static struct timerfd_context *timerfd_contexts;
pthread_mutex_t timerfd_context_mtx = PTHREAD_MUTEX_INITIALIZER;
struct timerfd_context *
get_timerfd_con... | 1 |
#include <pthread.h>
int i = 0;
pthread_mutex_t i_mutex;
void* thread1_func(){
for(int j = 0; j < 100000; ++j){
while( pthread_mutex_lock(&i_mutex) );
i++;
pthread_mutex_unlock(&i_mutex);
}
return 0;
}
void* thread2_func(){
for(int j = 0; j < 1000000; ++j){
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.