text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct packet
{
int clnt_sock;
char ip_addr[100];
};
void * handle_clnt(void * arg);
void send_msg(char * msg, int len);
void error_handling(char * msg);
int clnt_cnt=0;
int clnt_socks[256];
int name_size = 0;
pthread_mutex_t mutx;
int main(int argc, char *arg... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
main()
{
pthread_t thread1, th... | 0 |
#include <pthread.h>
static pthread_mutex_t *lockarray;
static void lock_callback(int mode, int type, char *file, int line)
{
(void)file;
(void)line;
if (mode & CRYPTO_LOCK) {
pthread_mutex_lock(&(lockarray[type]));
} else {
pthread_mutex_unlock(&(lockarray[... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
unsigned int seed;
long red=0,blue=0;
void* runner(void* arg)
{
double x,y;
x=(double)rand_r(&seed) / (double)32767 ;
y=(double)rand_r(&seed)/(double)32767 ;
if(sqrt((x*x)+(y*y))<=1)
{
pthread_mutex_lock(&mu... | 0 |
#include <pthread.h>
static void monitor_callback(int pin, void* arg);
struct Piphoned_HwActions_TriggerMonitor* piphoned_hwactions_triggermonitor_new(unsigned long grace_time, int pin, void (*p_callback)(int, void*), void* p_userdata)
{
struct Piphoned_HwActions_TriggerMonitor* p_monitor = (str... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full, empty;
buffer_item buffer[25];
int counter;
int numberToBeProduced;
int numberProduced = 0;
int runningThreads = 0;
pthread_t tid,tid0, tid1;
pthread_attr_t attr;
void *producer(void *param);
void *consumer0(void *param);
vo... | 0 |
#include <pthread.h>
void *row_compute();
void gauss_pthread();
int min(int a, int b){
if (a >= b){
return b;
}else{
return a;
}
}
char *ID;
int N;
int procs;
int row_count;
pthread_mutex_t row_lock;
volatile float A[5000][5000], B[5000], X[5000];
void gauss... | 1 |
#include <pthread.h>
int n;
int n_max;
unsigned char* primes;
pthread_mutex_t index_cond_lock;
void run() {
while(1) {
pthread_mutex_lock(&index_cond_lock);
if(n > sqrt(n_max)) {
pthread_mutex_unlock(&index_cond_lock);
return;
}
int ... | 0 |
#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;
while (1) {
err = sigwait(&mask, &signo);
if (err != 0) {
err_exit(err, "sigwait failed");
... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void thread_init() {
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_m... | 0 |
#include <pthread.h>
int main(int argc, char* argv[])
{
srand(time(0));
readConfigFile(argc, argv[0], argv[1]);
configSocket();
inicio_simulacao = time(0);
acabou = 0;
thcounter = 0;
pthread_mutex_init(&trinco_thcounter, 0);
pthread_mutex_init(&trinco_salaA, 0);
sem_init(&sem_salaA,... | 1 |
#include <pthread.h>
static struct net_ring_common * net_work_module_ring;
static pthread_mutex_t net_work_module_mutex;
static pthread_cond_t net_work_module_cond;
static int net_work_module_inside_parser(struct net_common_ring_node *node)
{
uint32_t ipaddr;
int n, ret = 0, len = 0;
char ... | 0 |
#include <pthread.h>
static const int NUM_TASKS = 30;
static const int NUM_THREADS = 10;
static int tasks[NUM_TASKS];
static pthread_mutex_t lock;
static int next_task = 0;
static sem_t *semaphore;
void *worker(void *_unused)
{
while (1) {
int my_task;
pthread_mutex_lock(&lock);
my_tas... | 1 |
#include <pthread.h>
int input[10]={1,2,3,4,5,6,7,8,9,10}, FIFO01[10], FIFO02[10], FIFO13[10], FIFO23[10];
int h01=0, h02=0, h13=0, h23=0,
t01=0, t02=0, t13=0, t23=0,
c01=0, c02=0, c13=0, c23=0;
pthread_mutex_t m01=PTHREAD_MUTEX_INITIALIZER,
m02=PTHREAD_MUTEX_INITIALIZER,... | 0 |
#include <pthread.h>
pthread_mutex_t chopsticks[5];
void * philosopher(void * arg)
{
int i = *((int *) arg);
if (i % 2)
{
pthread_mutex_lock (&chopsticks[i]);
sleep(1);
pthread_mutex_lock (&chopsticks[(i+1)%5]);
printf ("philosopher%d is eating.\\n", i);
sleep(3);
pthread_m... | 1 |
#include <pthread.h>
pthread_mutex_t Lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t PiesToEat = PTHREAD_COND_INITIALIZER;
int Done[3];
int PiecesOfPie;
void * baker()
{
int i, AllDone;
while (!AllDone)
{
AllDone = 1;
for (i = 0; i < 3; i++)
AllDone = (Done[i] && AllDone);
if(Al... | 0 |
#include <pthread.h>
static pthread_mutex_t current_column_mutex = PTHREAD_MUTEX_INITIALIZER;
static int current_column;
static int columns_per_thread;
static double step_r, step_i, min_r, max_r, min_i, max_i;
void *generator_render_part(void *);
int generator_get_next_column();
void... | 1 |
#include <pthread.h>
struct bfs_queue* bfs_queue_new(){
struct bfs_queue* bq = (struct bfs_queue*) malloc(sizeof(*bq));
bq->head = 0;
bq->tail = 0;
pthread_mutex_init(&bq->mutex, 0);
return bq;
}
int bfs_queue_destroy(struct bfs_queue **pbq){
if (0 == pbq){
... | 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) {
long my_id = (long) t;
for (int i = 0; i < 10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
... | 1 |
#include <pthread.h>
static int counter;
pthread_mutex_t mutex;
void incr_counter(void *p) {
do {
pthread_mutex_lock(&mutex);
counter++;
printf("%d\\n", counter);
sleep(1);
pthread_mutex_unlock(&mutex);
sleep(2);
} while ( 1 );
}
void reset_counter(void *p) {
int buf;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
int nThreads = 4;
int **grid;
int rows, columns;
int allocate_grid() {
grid = (int**)malloc(sizeof(int*)*rows);
int i;
for (i = 0; i < rows; i++)
grid[i] = (int*)malloc(sizeof(int)*columns);
return gri... | 1 |
#include <pthread.h>
int status = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *cond_signal()
{
printf("\\nIn cond_signal function \\nThread id = %ld\\n", pthread_self());
pthread_mutex_lock(&mutex);
status = 20;
printf("Status before sending signal: %d\\n", status);
pthread_cond_... | 0 |
#include <pthread.h>
long lButterflyBaudrate = 19200;
int iButterflyFile;
unsigned char ucButterflyDeviceName[256] = "/dev/ttyS0";
unsigned char ucButterflyDeviceOpened = 0;
unsigned char aButterflyRxBuffer[1024];
unsigned char aButterflyTxBuffer[1024];
struct sButterflyType sButterflyThread = {-1... | 1 |
#include <pthread.h>
static pthread_once_t g_init = PTHREAD_ONCE_INIT;
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
char const*const LCD_FILE
= "/sys/class/backlight/omap_bl/brightness";
char const*const BUTTON_FILE
= "/sys/class/leds/button-backlight/bright... | 0 |
#include <pthread.h>
buffer_item_t data[5];
pthread_mutex_t mutex;
sem_t* full;
sem_t* empty;
int in;
int out;
} buffer_t;
buffer_t buffer;
int buffer_init()
{
memset(buffer.data, '\\0', sizeof(buffer_item_t)*5);
buffer.in = 0;
buffer.out = 0;
i... | 1 |
#include <pthread.h>
int gate_array[2];
int runway_array[1];
int id;
pthread_t tid;
} airplanes;
pthread_mutex_t runway_lock;
pthread_mutex_t gate_lock;
static void runway_init(int arr[1]) {
int i;
for (i = 0; i < 1; i++) {
arr[i] = 0;
}
}
static void gate_init(int a... | 0 |
#include <pthread.h>
int fragment[10];
char buf[10][1000];
int empty[10];
} Buffer;
int sock;
struct sockaddr_in echoServAddr;
struct sockaddr_in echoClntAddr;
unsigned int cliAddrLen;
char echoBuffer[1004];
unsigned short echoServPort;
int recvMsgSize;
Buffer b;
pthread_mutex_... | 1 |
#include <pthread.h>
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[8];
pthread_mutex_t mutexsum;
void* dotprod(void* arg);
int main (int argc, char* argv[]) {
long i;
double *a, *b;
void* status;
pthread_attr_t attr;
a = (double*) mallo... | 0 |
#include <pthread.h>
int flag;
pthread_cond_t cond;
pthread_mutex_t mutex;
void initialize_flag()
{
pthread_mutex_init(&mutex, 0);
pthread_cond_init(&cond, 0);
flag = 0;
}
void set_thread_flag (int v)
{
pthread_mutex_lock(&mutex);
flag = v;
pthread_cond_signal(&cond);
pthread_mutex_... | 1 |
#include <pthread.h>
struct player_info {
char ptype;
int duration;
};
struct thread_arguments {
int duration;
int id;
};
void * reader(void *argument);
void * writer(void *argument);
void * clock2(void *argument);
void delay(int units);
pthread_mutex_t mutexsem;
int critical ... | 0 |
#include <pthread.h>
int send_port, rec_port;
char remote_address[30] = "127.0.0.1";
void* senderT(void*);
void* receiverT(void*);
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char** argv)
{
if (argc != 4)
{
printf("Usage: peer <Dest address> <Dest Port> <Rec... | 1 |
#include <pthread.h>
int variable_global=0;
pthread_mutex_t verrou = PTHREAD_MUTEX_INITIALIZER;
struct data {
int *Tab1;
int *Tab2;
int i;
};
void * Mul(void * par){
pthread_t moi = pthread_self();
int resultat;
struct data *mon_D1 = (struct data*)par;
pthread_mutex_loc... | 0 |
#include <pthread.h>
int waiting_chair_count;
pthread_mutex_t barber_chair_mutex;
pthread_mutex_t hair_cut_mutex;
void * barber()
{
while(1){
pthread_mutex_lock(&hair_cut_mutex);
fprintf(stdout,"barber started cut_hair\\n");
int rd_bar = 1+rand()%2;
sleep(rd_bar);
pthread_mutex_unlock(&b... | 1 |
#include <pthread.h>
pthread_mutex_t sumLock;
pthread_mutex_t bot;
int numWorkers;
int numArrived = 0;
int tasks = 0;
int sums = 0;
int maxInd[3] = {0, 0, 0};
int minInd[3] = {32767, 0, 0};
int size;
int bagOfTasks(){
pthread_mutex_lock(&bot);
if(tasks < size){
tasks++;
pthread_mutex_u... | 0 |
#include <pthread.h>
int a, b;
pthread_mutex_t mtxa = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mtxb = PTHREAD_MUTEX_INITIALIZER;
void* f(void * p)
{
char* sir = (char*)p;
for ( int i = 0; sir[i]; i++)
{
if (sir[i] == '5')
{
pthread_mutex_lock(&mtxa);
... | 1 |
#include <pthread.h>
void *Producer();
void *Consumer();
int BufferIndex=0;
char *BUFFER[10];
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;... | 0 |
#include <pthread.h>
struct {
int nused;
int next_write;
int next_read;
int data[10];
} buf = {0, 0, 0, {0}};
pthread_cond_t prKey = PTHREAD_COND_INITIALIZER;
pthread_cond_t coKey = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* produce(void* arg) {
... | 1 |
#include <pthread.h>
int ring[64];
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
sem_t blank_sem;
sem_t data_sem;
void* product(void *arg)
{
int data = 0;
static int step = 0;
while(1)
{
pthread_mutex_lock(&lock... | 0 |
#include <pthread.h>
long double pi = 0.0;
pthread_mutex_t Locked;
long double intervals;
int numThreads;
double numiter;
void *calculPI(void *id)
{
unsigned int seed=time(0);
double z,x,y,localSum=0;
int i,count=0;
srand(time(0));
for(i = 0 ; i < numiter; i ++) {
x = ( double... | 1 |
#include <pthread.h>
int capacity, prod_threads, cons_threads, producer_loops, consumer_loops, avg1, avg2;
int *buffer;
int buffer_index;
pthread_mutex_t buffer_mutex;
sem_t full;
sem_t empty;
int ex(int a)
{
int var = (-1)*((rand() % 10) + 1)/a;
int x = 100* (exp(var));
x = x/a... | 0 |
#include <pthread.h>
pthread_mutex_t mu;
pthread_cond_t registerSignal;
key_t shmkey;
int shmid;
sem_t *sem;
int nXray = 3;
int toTreat = 0, nTreated = 0, size = 0, dep_no = 0;
int **treatTimes;
void fileOP(const char* inputFile) {
int num, num2, i, j;
FILE* file = fopen(inputFile, "r");
w... | 1 |
#include <pthread.h>
pthread_mutex_t stack_mutex;
struct timeval tm1, tm2;
void start()
{
gettimeofday(&tm1, 0);
}
void stop()
{
gettimeofday(&tm2, 0);
unsigned long long t = ((tm2.tv_sec - tm1.tv_sec) * 1000000)
+ (tm2.tv_usec - tm1.tv_usec);
printf("\\n... | 0 |
#include <pthread.h>
void bag_of_tasks(int*, int*);
int find_word(const char*);
char *strrev(char *);
void write_output_buffer(const char*);
void increment_sum(void);
int *words, numWords, sum = 0, current_task = 0, outBuffer_offset =0;
char *inBuffer, *outBuffer;
FILE *outFile;
pthread_mutex_t... | 1 |
#include <pthread.h>
pthread_mutex_t forks[5];
pthread_t phils[5];
void *philosopher (void *id);
int food_on_table ();
void get_fork (int, int, char *);
void down_forks (int, int);
pthread_mutex_t foodlock;
int sleep_seconds = 0;
int
main (int argn,
char **argv)
{
int i;
if (argn ... | 0 |
#include <pthread.h>
int const MAX=5;
int buffer[MAX];
int fill = 0;
int use =0;
int loops = 10;
sem_t *items;
sem_t *slots;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
void put(int value){
sem_wait(slots);
pthread_mutex_lock(&mut);
printf("fill buffer %d with %d by thread %ld\\n",f... | 1 |
#include <pthread.h>
int main(void)
{
pid_t pid;
int mid;
int bCreate = 0;
key_t key = 0x12341235;
pthread_mutex_t *mut;
pthread_mutexattr_t attr;
mid = shmget(key, 0, 0);
printf("sizeof mutex: %d\\n" ,sizeof(pthread_mutex_t));
if( mid == -1 )
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
void usage(char *argv0, char *msg) {
if (msg != 0 && strlen(msg) > 0) {
printf("%s\\n\\n", msg);
}
printf("obtain and release mutex_locks in wrong order (lock 1, lock 2, unlock 1, unlock 2)\\n\\n");
printf("Usage\\... | 1 |
#include <pthread.h>
long long num_steps = 1000000000;
double step;
double pi;
int NO_PROC = 4;
int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *hiloFunc(void *args){
double x, sum=0.0;
pthread_mutex_lock(&mutex);
long range= counter*250000000;
counter++;
pthre... | 0 |
#include <pthread.h>
static void readfunc();
static void writefunc();
char buffer[256];
int buffer_has_item = 0;
int retflag = 0;
pthread_mutex_t mutex;
int pthread_mutex_test(){
pthread_t reader;
pthread_mutex_init(&mutex, 0);
pthread_create(&reader, 0, (void *)&readfunc, 0);
... | 1 |
#include <pthread.h>
struct block_hd *next;
struct block_hd *prev;
int size;
} block_header;
block_header* start;
int reverse;
int size;
} myarg_t;
block_header* current;
int status;
} myret_t;
block_header* list_head = 0;
block_header* list_tail = 0;
void *thread_space;
int search_done ... | 0 |
#include <pthread.h>
static const unsigned int kNumPhilosophers = 5;
static const unsigned int kNumForks = kNumPhilosophers;
static const unsigned int kNumMeals = 3;
static pthread_mutex_t forks[kNumForks];
static int getSleepTime()
{
return rand() % 200000;
}
static int getEatTime()
{
retur... | 1 |
#include <pthread.h>
struct task_node_t
{
struct task_node_t *next;
task_fun_t task;
void *args;
};
struct task_queue_t
{
struct task_node_t *work_task_head;
struct task_node_t *work_task_tail;
struct task_node_t *free_task;
int num;
};
static int tn_clear(struct t... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0);
... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
extern int __VERIFIER_nondet_int();
int idx=0;
int ctr1=1, ctr2=0;
int readerprogress1=0, readerprogress2=0;
pthread_mutex_t mutex;
void __VERIFIER_atomic_use1(int myidx) {
__VERIFIER_assume(myidx <= 0 && ctr1>0);
ctr1++;
}
void __V... | 0 |
#include <pthread.h>
int Buffer_Index_Value = 0;
char *Buffer_Queue;
pthread_mutex_t mutex_variable = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t Buffer_Queue_Not_Full = PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Queue_Not_Empty = PTHREAD_COND_INITIALIZER;
void *Consumer()
{
while(1... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full,empty;
pthread_t producer[5],consumer[5];
int counter,buffer[10];
void *produce(void*);
void *consume(void*);
int main()
{
pthread_mutex_init(&mutex,0);
sem_init(&full,1,0);
sem_init(&empty,1,10);
counter=0;
int i=0;
for(i=0;i<=2;i++)
... | 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)
{
thread_key_create(&key, free);
}
char *getenv(const char *name)
{
int i, le... | 1 |
#include <pthread.h>
void mux_2_regdst(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);
}
pt... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void* p_func(void* p)
{
pthread_mutex_lock(&mutex);
int ret;
int i=(int)p;
printf("I am child %d,I am here\\n",i);
ret=pthread_cond_wait(&cond,&mutex);
if(0!=ret)
{
printf("pthread_cond_wait ret=%d\\n",ret);
}
printf("I ... | 1 |
#include <pthread.h>
int threads_amount;
char *file_name;
int records_to_read;
char *to_find;
int records_size = 1024;
int fd;
int END_FILE = 0;
int records_transfered;
int *finished;
pthread_key_t records;
pthread_t *threads;
pthread_mutex_t out_mutex = PTHREAD_MUTEX_INITIALIZER;
int main(in... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread0(void *arg)
{
printf("thread0 wait for lock\\n");
pthread_mutex_lock(&mutex);
printf("thread0 get lock\\n");
printf("thread0 wait for cond\\n");
pthread_cond_wait... | 1 |
#include <pthread.h>
uint32_t get_user_id(char* username)
{
if(username)
{
for(uint32_t i = 1; i < user_count; i++)
{
if(strcmp((users+i)->name, username) == 0) return i;
}
}
return 0;
}
char* contains_group(char* name)
{
char* groupname = 0;
if(name)
{
for(uint32_t i = 0; i < s... | 0 |
#include <pthread.h>
pthread_mutex_t kljuc = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t d = PTHREAD_COND_INITIALIZER;
pthread_cond_t l = PTHREAD_COND_INITIALIZER;
pthread_cond_t plovi = PTHREAD_COND_INITIALIZER;
int obala;
int index;
}podaci;
int obala_camac = 1;
int broj_kanibala_na_camcu = ... | 1 |
#include <pthread.h>
int *array;
int length, count= 0;
pthread_t *ids;
pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;
int length_per_thread;
void * count3p(void *myI){
int i, myStart, myEnd, myIdx= (int)myI;
myStart= length_per_thread * myIdx; myEnd= myStart + length_per_thread;
printf(... | 0 |
#include <pthread.h>
enum memmodel
{
MEMMODEL_RELAXED = 0,
MEMMODEL_CONSUME = 1,
MEMMODEL_ACQUIRE = 2,
MEMMODEL_RELEASE = 3,
MEMMODEL_ACQ_REL = 4,
MEMMODEL_SEQ_CST = 5
};
inline static void mysync(int id, int volatile * b){
if(id == 0) {
*b = 1;
} else {
w... | 1 |
#include <pthread.h>
struct threadpool* threadpool_init(int thread_num, int queue_max_num)
{
struct threadpool *pool = 0;
do
{
pool = malloc(sizeof(struct threadpool));
if (0 == pool)
{
printf("failed to malloc threadpool!\\n");
break;
... | 0 |
#include <pthread.h>
pthread_t *thread_id;
int *thread_data;
pthread_mutex_t nopen_lock = PTHREAD_MUTEX_INITIALIZER;
volatile int nopen = 0;
int *isopen, *cd;
int ncons = MAX_NUM_CONNECTIONS;
void terminate_client (int ci)
{
isopen[ci] = 0;
pthread_mutex_lock (&nopen_lock);
nopen--... | 1 |
#include <pthread.h>
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=head_p;
while(temp_p != 0 && temp_p->data < value)... | 0 |
#include <pthread.h>
char achData[1024];
char achSendData[1024];
int iCount,iSocketfd,iConfd,iLen,iCharCount,c;
FILE *fp;
pthread_t thread[5];
struct sockaddr_in serv_addr;
pthread_mutex_t lock;
void *sendd();
int main()
{
iSocketfd=socket(AF_INET,SOCK_STREAM,0);
serv_addr.sin_family=AF_INET;... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
long long count = 0;
int availA, availB = 0;
void *
increment_count(void *arg)
{
int iter;
char *letter = arg;
availA = 1;
if (strcmp(letter, "A") == 0)
{
... | 0 |
#include <pthread.h>
struct file {
int entier;
FIFO *next;
int readed;
};
FIFO *initial_fifo(int num) {
FIFO *fifo = (FIFO *)malloc(sizeof(FIFO));
fifo->entier = num;
fifo->readed = 0;
fifo->next = 0;
return fifo;
}
void add_file(FIFO **head, int num) {
FI... | 1 |
#include <pthread.h>
int thread_count;
double integral;
double a, b;
int n;
double h;
pthread_mutex_t mutex;
double f(double x);
void Trap(double a, double b, int n, double h);
void *Pth_interpol(void* rank);
int main(void) {
printf("Enter a, b, n and thread_count\\n");
scanf("%lf", ... | 0 |
#include <pthread.h>
void *new_malloc(size_t size);
void new_exit(int status);
void handle_error(const char *file, int lineno, const char *msg)
{
int first_iteration;
fprintf(stderr, "** %s:%d %s\\n", file, lineno, msg);
ERR_print_errors_fp(stderr);
}
static pthread_mutex_t *mutex_buf ... | 1 |
#include <pthread.h>
int counter;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
void *doit(void *);
int main()
{
pthread_t th1,th2;
int status;
status=pthread_create(&th1,0,doit,0);
if ( status )
{
printf("Error in Creating Thread\\n");
exit(status);
}
status=pth... | 0 |
#include <pthread.h>
int fd = 0;
void* (*__malloc)(size_t) = 0;
void (*__free)(void*) = 0;
long start_sec = 0, start_mcsec = 0;
pthread_mutex_t write_sync = PTHREAD_MUTEX_INITIALIZER;
inline void get_time(long* sec, long* mcsec) {
long sec_, mcsec_;
struct timespec spec;
clock_getti... | 1 |
#include <pthread.h>
void *Incrementer(void *Dummy) {
extern int CommonInt;
extern pthread_mutex_t Mutex;
sleep(rand() % 4);
pthread_mutex_lock(&Mutex);
if (CommonInt == 0) {
sleep(rand() % 2);
CommonInt += 1;
printf("The common integer is now %d\\n",... | 0 |
#include <pthread.h>
double cx_min;
double cx_max;
double cy_min;
double cy_max;
int ix_max;
int iy_max;
double pixel_width;
double pixel_height;
int image_size;
int image_buffer_size;
unsigned char **image_buffer;
int nthreads;
int current_iy;
pthread_mutex_t stacklock = PTHREAD_MUTEX_... | 1 |
#include <pthread.h>
{
pthread_mutex_t *lock;
int id;
int size;
int iterations;
char *s;
} Thread_struct;
void *infloop(void *x)
{
int i, j, k;
Thread_struct *t;
t = (Thread_struct *) x;
for (i = 0; i < t->iterations; i++)
{
pthread_mutex_lock(t->lock);
for (j = 0; j < t->si... | 0 |
#include <pthread.h>
main(int argc, char *argv[])
{
int i, *pint, shmkey;
char *addr;
int walkno, start, shmid, matsize;
pthread_mutex_t mutex;
srand(time(0));
pthread_mutex_init(&mutex, 0);
walkno = atoi(argv[1]);
start = atoi(argv[2]);
matsize = atoi(argv[3]);
shmkey = atoi(argv... | 1 |
#include <pthread.h>
int fd;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *do_work(void *data)
{
int count = 0, i;
char buf[1024];
char *s = (char *)data;
while (count < 100)
{
pthread_mutex_lock(&mutex);
snprintf(buf, sizeof(buf), "%s pid = %d... | 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 lock... | 1 |
#include <pthread.h>
struct ks_req ks_nomem_request =
{
.refcnt = 1,
.completed = TRUE,
.err = -ENOMEM,
};
void ks_req_timer(struct ks_timer *timer, enum ks_timer_action action, void *start_data)
{
struct ks_req *req = timer->data;
switch(action) {
case KS_TIMER_STOPPED:
ks_req_put(req)... | 0 |
#include <pthread.h>
pthread_mutex_t mutex ;
pthread_cond_t cond_pro, cond_con ;
void* handle(void* arg)
{
int* pt = (int*)arg ;
int soldn = 0 ;
int tmp ;
while(1)
{
pthread_mutex_lock(&mutex);
while(*pt == 0)
{
printf("no ticket!\\n");
pthread_cond_signal(&cond_pro);
... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_t *threads;
static int num_threads;
static void service_tcp_requests(int server_fd) {
while (1) {
pthread_mutex_lock(&mutex);
int client_fd = accept(server_fd, 0, 0);
if (-1... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
static int iTThreads = 2;
static int iRThreads = 1;
static int data1Value = 0;
static int data2Value = 0;
pthread_mutex_t *data1Lock;
pthread_mutex_t *data2Lock;
void lock(pthread_mutex_t *);
void unlock(pthread_mutex_t *);
void *funcA(void *p... | 1 |
#include <pthread.h>
static int Resource_Counter = 0;
static pthread_mutex_t Resource_Counter_Mutex =
PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t Got_Resources_Condition =
PTHREAD_COND_INITIALIZER;
static void *writer_start(void *arg) {
static const size_t TIMES_TO_PRODUCE = 1... | 0 |
#include <pthread.h>
int client_array[10];
int clNum=0;
int server_sockfd = 0, client_sockfd = 0;
pthread_mutex_t mutx;
void sig_handler(int signo);
void* clientConnection(void* s);
void sendMsg(char* msg);
int main(void)
{
signal(SIGINT, (void *)sig_handler);
int i = 0;
int server_len=0, cl... | 1 |
#include <pthread.h>
int numWorkers = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void *threadMain (void *_n);
static int maxWorkers = 5;
int main (int argc, char* argv[])
{
int count = 0;
if (argc > 1) {
int c = atoi(argv[1]);
if (c > 1) {
maxWorkers = c;... | 0 |
#include <pthread.h>
struct list_node_s {
int data;
struct list_node_s *next;
};
struct list_node_s *head_pp = 0;
bool unique_array[65536] = {0};
int *operation_array;
float *time_array;
int elements;
int count = 0;
float overhead;
long thread_count;
pthread_mutex_t mutex;
int member(... | 1 |
#include <pthread.h>
int nproc;
double a[1000];
long int ok,ni=(sizeof(a)/sizeof(double))-1;
long int size=(sizeof(a)/sizeof(double));
double sum=0,status, sd=0, ans, avg;
pthread_mutex_t lock;
void *work();
void *sdav();
int main()
{
printf("Enter Number of Threads : ");
scanf("%d", &nproc);
... | 0 |
#include <pthread.h>
int id;
} philosopher;
int isFree;
pthread_mutex_t lock;
pthread_cond_t forkcond;
} chopstick;
chopstick f[5];
philosopher phil[5];
void init(void){
int i;
for(i=0; i<5; i++){
f[i].isFree = 1;
f[i].lock = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
f[i].fo... | 1 |
#include <pthread.h>
int main(void)
{
int i;
int *x;
int rt;
int shm_id;
char *addnum="myadd";
char *ptr;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_SHARED);
rt=fork();
if(rt==0)
{
shm... | 0 |
#include <pthread.h>
int num;
int mark;
}Item;
Item* S;
int ini;
int len;
}Block;
pthread_cond_t new_piv = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int a=0;
int condicion = 0;
void* scan(void* block);
void* wakeup_all(void);
int global_rearrangement(It... | 1 |
#include <pthread.h>
{
double **mat;
double *y;
long who;
long N;
int P;
int *counters;
pthread_mutex_t *mutex;
} ssystem_striped_fast;
void *thread_gauss_striped_fast_ciclic(void *p)
{
ssystem_striped_fast data=*(ssystem_striped_fast *)p;
long s;
long nr;
long last=0;
long proccoun... | 0 |
#include <pthread.h>
pthread_t workers[3];
pthread_t oura;
pthread_mutex_t lock;
pthread_mutex_t initial_hash;
struct jobs{
int worker_tid;
int jid;
}queue[5];
int hash_locked = 0;
int head = 0;
int last = 0;
int pin[3][3];
void * queue_manager(void * unused)
{
int run = 1;
int worker_... | 1 |
#include <pthread.h>
static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
static struct dlog_record *_pool[8192];
static size_t _num;
struct dlog_record *recpool_acquire()
{
struct dlog_record *rec = 0;
pthread_mutex_lock(&_mutex);
if (_num > 0)
rec = _pool[--_num];
pthread_mutex_u... | 0 |
#include <pthread.h>
static pthread_mutex_t m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
char *ts="[??:??:??]";
struct tm * now;
time_t nw;
pthread_mutex_lock(&m_trace);
nw = time(0);
now = localt... | 1 |
#include <pthread.h>
static struct atexit_handler {
void (*f)(void *);
void *p;
void *d;
struct atexit_handler *next;
} *head;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int __cxa_atexit( void (*f)(void *), void *p, void *d) {
return 0;
pthread_mutex_lock(&lock);
stru... | 0 |
#include <pthread.h>
struct bqueue *bqueue_new()
{
struct bqueue *q = malloc(sizeof(*q));
if (!q)
return 0;
TAILQ_INIT(&q->head);
pthread_mutex_init(&q->mutex, 0);
pthread_cond_init(&q->cond, 0);
q->state = BQUEUE_STATE_ACTIVE;
return q;
}
void bqueue_nq(struct bqueue *q, struct bqueue_e... | 1 |
#include <pthread.h>
uint32_t arr[(4096 * 10)];
pthread_mutex_t mutexes[((4096 * 10)/(4096*1))];
int pause_thread(int pause_count){
int total=0;
for(int i=0;i<pause_count;++i){
total++;
}
return total;
}
int get_lock_index(int mem_index){
return ((mem_index*sizeof(uin... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.