text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t wd_news_mutex = PTHREAD_MUTEX_INITIALIZER;
void wd_send_news(void) {
FILE *fp;
char buffer[8192];
fp = fopen(wd_settings.news, "r");
if(!fp) {
wd_log(LOG_WARNING, "Could not open %s: %s", wd_settings.news);
goto end;
}
while((wd_getnewsline(... | 1 |
#include <pthread.h>
int pro_num=0;
int left_num=20;
pthread_mutex_t mutex_pro, mutex_left;
pthread_cond_t cond_pro, cond_left;
void *thd1_handle(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex_pro);
if(pro_num>0)
{
pthread_mutex_lock(&mutex_left);
pro_num--;
... | 0 |
#include <pthread.h>
char character_name[30];
char symbol;
int thread_num;
int position_xy[2];
int condition;
pthread_t thread_id;
}thread_data;
struct mutex_shared{
int BOARD[5][5];
int WINNER;
int FLAG[2];
int CONDITION;
char DUDE_WITH_FLAG;
} ... | 1 |
#include <pthread.h>
int thread_count;
int barrier_thread_counts[100];
pthread_mutex_t barrier_mutex;
void Usage(char* prog_name);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread, i;
pthread_t* thread_handles;
double start, finish;
if (argc != 2)
... | 0 |
#include <pthread.h>
pthread_cond_t exit_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t exit_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t watcher_thr;
pthread_t cli_thr;
pthread_t daemon_thr;
int daemon_stopped;
char file_backend_prefix[1024];
int log_priority = LOG_ERR;
int use_syslog... | 1 |
#include <pthread.h>
extern pthread_mutex_t raspyMutex;
extern pthread_mutex_t timeMutex;
extern pthread_cond_t cond;
extern char gTimeStr[];
extern int gNextSwitchTime;
extern void fifoInit(void);
extern int putMessage(int, int);
extern enum globMode gMode;
struct switchTimes {
int swi... | 0 |
#include <pthread.h>
int clientCount = 0;
int byteCount = 0;
pthread_mutex_t lock;
struct serverParm{
int connectionfd;
int clientNO;
};
static int callback(void *data, int argc, char **argv, char **azColName) {
int *fileDesc;
fileDesc = (int *) data;
int i;
for (i = 0; i < argc; i++)... | 1 |
#include <pthread.h>
int readers;
int writer;
pthread_cond_t readers_proceed;
pthread_cond_t writer_proceed;
int pending_writers;
pthread_mutex_t read_write_lock;
} mylib_rwlock_t;
mylib_rwlock_t read_write_lock;
void *find_min_rw(void *list_ptr);
void mylib_rwlock_init (mylib_rwlock_t *l);
vo... | 0 |
#include <pthread.h>
int thread_count;
int barrier_thread_count = 0;
pthread_mutex_t barrier_mutex;
pthread_cond_t ok_to_proceed;
void Usage(char* prog_name);
void *Thread_work(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
double start, finis... | 1 |
#include <pthread.h>
pthread_mutex_t chops[5];
void *eat(void * arg);
int main()
{
int i;
pthread_t persons[5];
srand(time(0));
for (i = 0; i < 5; i++)
{
pthread_mutex_init(&chops[i], 0);
}
for (i = 0; i < 5; i++)
{
pthread_create(&persons[i], 0, ... | 0 |
#include <pthread.h>
{
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
sem_t sem1;
sem_t sem2;
unsigned total;
unsigned arrived;
sem_t xxx;
} gomp_barrier_t;
void
gomp_barrier_init (gomp_barrier_t *bar, unsigned count)
{
pthread_mutex_init (&bar->mutex1, 0);
pthread_mutex_init ... | 1 |
#include <pthread.h>
void * simple(void *);
pthread_t tid[2];
int bignum = 0;
pthread_mutex_t mut;
main( int argc, char *argv[] )
{
int i, ret;
pthread_mutex_init(&mut, 0);
for (i=0; i<2; i++) {
pthread_create(&tid[i], 0, simple, 0);
}
for ( i = 0; i < 2; i++)
pthread_... | 0 |
#include <pthread.h>
const static int n = 3;
static int m = 1;
static int l = 0;
static int first[n][n];
static int second[n][n];
static int result[n][n];
static pthread_mutex_t mutex;
void *crt(void *p) {
int k = 1;
while (1) {
if (k == m && (k - 1) == l) {
pth... | 1 |
#include <pthread.h>
extern int HELLO_INTERVAL;
extern int identifier;
extern int HELLO_INTERVAL;
extern int NUMBER_OF_ROUTERS;
extern int NUMBER_OF_EDGES;
extern int NUMBER_OF_NEIGHBORS;
extern int* NEIGHBOR_IDS;
extern int sock;
extern struct sockaddr_in my_addr;
extern struct hostent *host;
ext... | 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>
unsigned int times;
unsigned int width_bytes;
unsigned int id;
pthread_cond_t *signal;
pthread_cond_t *peersignal;
} info;
pthread_cond_t signals[((unsigned int)8)];
pthread_mutex_t lock;
FILE *output = 0;
int next_id = 0;
void *thread(void *param0)
{
... | 0 |
#include <pthread.h>
void *temperature_thread_entry()
{
int8_t temperature;
struct peer_net_params admin_addr;
admin_addr.ipstr[0] = '\\0';
while (1) {
temperature = get_temperature();
get_admin_params(&admin_addr);
if (admin_addr.ipstr[0] != '\\0') {
send_temperature(&admin_add... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
long counter = 0L;
pthread_barrier_t barrier;
void *thread_counting(void *ptr)
{
int fd;
int i;
long ending;
char buffer[16384];
char *filename = (char*) ptr;
pthread_mutex_lock(&lock);
ending = 0L;
fd = open(filename, O_RDONLY);
if (fd < 0... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
void* threadRead(void*);
void* threadWrite(void*);
int shmid;
char *buf[4092];
int main(int argc,char** argv)
{
printf("Enter main\\n");
printf("Create sh... | 1 |
#include <pthread.h>
pthread_mutex_t fork_mutex[5];
pthread_mutex_t grab_mutex;
pthread_mutex_t drop_mutex;
pthread_cond_t eat_cond;
int num_eating;
int main()
{
int i;
pthread_t diner_thread[5];
int dn[5];
void *diner();
num_eating = 0;
for (i = 0; i < 5; i+... | 0 |
#include <pthread.h>
static pthread_mutex_t my_mutex;
void *pthread_example(void *void_tid)
{
int status;
printf("[demo-pthread-mutex][thread1] Initialize thread1\\n");
printf("[demo-pthread-mutex][thread1] pthread_mutex_trylock() will instantly fail bc main has the lock\\n");
status = pthread... | 1 |
#include <pthread.h>
pthread_mutex_t gm;
struct node{
int id;
struct node *next;
unsigned long nextNodeInfo[3];
};
struct list
{
int head_id;
struct node *next;
unsigned long nextNodeInfo[3];
} list_t;
void *t(void *args){
nvcheckpoint();
pthread_exit(0);
}
i... | 0 |
#include <pthread.h>
int state[5];
int forks[5];
pthread_t p_thread[5];
pthread_mutex_t mutex[2] = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond[5] = PTHREAD_COND_INITIALIZER;
void *philosopher(void *num);
void get_forks(int phi, int l_fork, int r_fork);
void put_forks(int phi, int l_for... | 1 |
#include <pthread.h>
int total = 0;
pthread_mutex_t *lock;
void *tfn(void *arg)
{
int num = *((int *)arg);
long d2num = 2*num;
pthread_mutex_lock(lock);
total+=num;
pthread_mutex_unlock(lock);
printf("num=%d total=%d\\n",num,total);
return (void*)(d2num);
}
int main(int argc,char *argv[... | 0 |
#include <pthread.h>
bool raspberryPilotInit();
int main() {
struct timeval tv_c;
struct timeval tv_l;
unsigned long timeDiff=0;
if (!raspberryPilotInit()) {
return 0;
}
gettimeofday(&tv_l,0);
while (!getLeaveFlyControlerFlag()) {
gettimeofday(&tv_c,0);
timeDiff=GET_USEC_TIMED... | 1 |
#include <pthread.h>
pthread_mutex_t mutex ;
pthread_cond_t cond ;
int flag=0;
void thread1(void *arg) ;
void thread2(void *arg) ;
int main(void)
{
int count = 6;
pthread_t thid1, thid2 ;
pthread_mutex_init (&mutex, PTHREAD_MUTEX_TIMED_NP) ;
pthread_cond_init (&cond, 0) ;
... | 0 |
#include <pthread.h>
struct node {
int n_number;
struct node *n_next;
};
struct node *head = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static void cleanup_handler1(void *arg)
{
printf("Cleanup thread----[1].\\n");
... | 1 |
#include <pthread.h>
int sens= -1;
static pthread_mutex_t m= PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cOE= PTHREAD_COND_INITIALIZER;
static pthread_cond_t cEO= PTHREAD_COND_INITIALIZER;
static int nb= 0;
void initThreadSynchro() {
};
pthread_t AllumageTrain(void *arg) {
pthread_... | 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;
void main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0);
pth... | 1 |
#include <pthread.h>
pthread_t philosopher[5];
pthread_mutex_t chopstick[5];
void *fun(void*);
int main(){
int i;
for(i=0; i<5; i++)
pthread_mutex_init(&chopstick[i],0);
for(i=0; i<5; i++)
pthread_create(&philosopher[i],0, fun, (void*)&i);
for(i=0; i<5; i++)
pthread_join... | 0 |
#include <pthread.h>
int buffer[10];
int first = 0;
int num = 0;
pthread_mutex_t mon = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t itemCond = PTHREAD_COND_INITIALIZER;
pthread_cond_t slotCond = PTHREAD_COND_INITIALIZER;
static void fail( char const *msg );
void *producer(void *param) {
f... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_var = PTHREAD_MUTEX_INITIALIZER;
int var;
int wait_barrier (int n){
pthread_mutex_lock(&mutex_var);
var++;
pthread_mutex_unlock(&mutex_va... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
void *function(void *null) {
pthread_mutex_lock( &mutex1 );
counter++;
pthread_mutex_unlock( &mutex1 );
pthread_exit(0);
}
int main(void) {
pthread_t thread_id[10];
int i, j;
f... | 1 |
#include <pthread.h>
int wait=0;
pthread_mutex_t mutex;
pthread_cond_t cv;
int buf,wa=-1,wb=-1,c;
void * printa()
{
int j;
pthread_mutex_lock(&mutex);
int a,b;
printf("a recieved: %d \\n",buf);
if(wa==0)
{
a=buf;
pthread_cond_signal(&cv);
wb=0;
}
if(wb==0)
{
pthread_cond_wait(&c... | 0 |
#include <pthread.h>
void *horizontal_check(void *arg);
void *vertical_check(void *arg);
void *box_check(void *arg);
int find(int val, int *array);
int clear(int *array);
pthread_mutex_t valid_mutex;
int sudoku[9][9];
} sudoku;
int valid = 1;
int main(void){
FILE *file;
sudoku puzzle... | 1 |
#include <pthread.h>
pthread_cond_t adultBoardOahu;
pthread_cond_t kidsBoardOahu;
pthread_cond_t onBoat;
pthread_cond_t onMolo;
int boatLoc;
int kidsOnBoard;
int adultsOnBoard;
int adultGoes;
void init() {
pthread_mutex_init(&lock, 0);
pthread_cond_init(&allReady, 0);
pthread_cond_... | 0 |
#include <pthread.h>
int philosopher[5];
int Fork[5];
pthread_mutex_t mutex;
void init();
int GetRandom(int min,int max);
void *func_thread(void *p);
int take(int fn, int pn);
void put(int fn, int pn);
void think(int num);
void eat(int num);
int main(int argc, char const *argv[])
{
init();... | 1 |
#include <pthread.h>
pthread_t f_thread;
pthread_mutex_t f_mutex;
const char* string_debugs[] = {
"Allocation for struct PIECE",
"Allocation for struct GAME",
"Allocation for struct POSITION",
"Allocation for struct NODE",
"Allocation for struct LIST",
"Allocation for struct PLAYER",
"Alloca... | 0 |
#include <pthread.h>extern void __VERIFIER_assume(int);
extern void __VERIFIER_error() ;
int block;
int busy;
int inode;
pthread_mutex_t m_inode;
pthread_mutex_t m_busy;
void *allocator(){
pthread_mutex_lock(&m_inode);
if(inode == 0){
pthread_mutex_lock(&m_busy);
busy = 1;
pthre... | 1 |
#include <pthread.h>
long ninc_per_thread;
long a;
long b;
long r;
long * p;
pthread_mutex_t * m;
} arg_t;
void * f(void * arg_) {
arg_t * arg = (arg_t *)arg_;
long a = arg->a, b = arg->b;
long ninc_per_thread = arg->ninc_per_thread;
if (b - a == 1) {
int i;
for (i =... | 0 |
#include <pthread.h>
int ranking;
int leader_id;
pthread_mutex_t lock;
} Best_ranking;
int tid;
int ranking;
int count;
} arg_t;
int nt;
pthread_mutex_t lock;
} Counter;
sem_t barrier1, barrier2;
Counter c;
Best_ranking best_ranking;
int Random_Generator(int *rankings, int *N){
int re... | 1 |
#include <pthread.h>
{
int id;
char name[20];
int flag;
int money;
}Person;
Person per[20];
double money = 0.0;
int num = 0;
pthread_mutex_t lock;
void *producer(void* value)
{
double n = *(double*)value;
pthread_mutex_lock(&lock);
money = n;
pthread_mutex_unlock(&l... | 0 |
#include <pthread.h>
int final_max = INT_MIN;
int final_min = 32767;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int min;
int max;
} result_t;
int *arr;
struct timeval tval_before, tval_after, tval_result;
struct thread_args {
int arraySize;
int subSize;
int co... | 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)
{
pthread_key_create(&key, free);
}
char *
getenv(const char *name)
{
int i, le... | 0 |
#include <pthread.h>
int add=0;
int gReaders = 0;
int gWaitingReaders = 0;
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t rCond = PTHREAD_COND_INITIALIZER;
pthread_cond_t wCond = PTHREAD_COND_INITIALIZER;
void *readerFunc (void *args);
void *writerFunc (void *args);
int m... | 1 |
#include <pthread.h>
int buffer[100];
int in = -1;
int out = -1;
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t BUFFER_HAS_SPACE = PTHREAD_COND_INITIALIZER;
pthread_cond_t BUFFER_HAS_DATA = PTHREAD_COND_INITIALIZER;
void *Producer(void* arg)
{
int i;... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *add(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i < 100; i++) {
pthread_mutex_lock(&count_mutex);
count++;
pthread_cond_signal(&count_threshold_cv);
printf("add(... | 1 |
#include <pthread.h>
struct prodcons {
int buffer[16];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct prodcons * b)
{
pthread_mutex_init(&b->lock, 0);
pthread_cond_init(&b->notempty, 0);
pthread_cond_ini... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long double pi = 0;
void *piCalculator(void *param);
void *piPrinter(void *param);
int maxIterations;
int maxExecTime;
clock_t start, end;
int iteration = 0;
int main(int argc, char* argv[])
{
pthread_t worker_thread, pri... | 1 |
#include <pthread.h>
int pbs_orderjob_err(
int c,
char *job1,
char *job2,
char *extend,
int *local_errno)
{
struct batch_reply *reply;
int rc;
int sock;
struct tcp_chan *chan = 0;
if ((job1 == (char *)0) || (*job1 == '\\0') ||
(job2 == (char *)0) || (*job2 == '\\0'... | 0 |
#include <pthread.h>
unsigned int v_in, v_out;
static pthread_cond_t cond_lance, cond_resultat;
static pthread_mutex_t mutex;
void *thread_entree_sortie(void *p)
{
pthread_mutex_lock(&mutex);
printf("Entrez une valeur : ");
scanf("%d", &v_in);
pthread_cond_signal(&cond_lance);
pthre... | 1 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void * sumDirectory(void *arg){
struct stat statbuf;
DIR *dp;
struct dirent *direntry;
pthread_t* childs = malloc(256 * sizeof(pthread_t));
int index_childs = -1;
int te... | 0 |
#include <pthread.h>
int balance;
int withdrawn;
pthread_mutex_t lock;
} ACCOUNT, *PACCOUNT;
PACCOUNT acc;
PACCOUNT create(int b) {
PACCOUNT acc = (PACCOUNT) malloc(sizeof(ACCOUNT));
acc->balance = b;
acc->withdrawn = 0;
pthread_mutex_init(&acc->lock, 0);
return acc;
}
int rea... | 1 |
#include <pthread.h>
void* f_jdg (void *v);
void enter_judge();
void confirm_judge();
void leave_judge();
void* f_jdg (void *v){
enter_judge();
confirm_judge();
leave_judge();
return 0;
}
void enter_judge(){
atomic_exchange(&judge_inside, 1);
printf("Judge entered.\\n... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condizione = PTHREAD_COND_INITIALIZER;
int n;
int i =0;
int flag=0;
void *scrittore(void *param){
char *buf = malloc(sizeof(int));
int fd = open("file.txt",O_WRONLY);
for(i=1;i<=n;i++){
pthread_mutex_lock(&... | 1 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main()
{
int res;
pthread_t a_thread;
void *thread_result;
res = pthread_mutex_init(&work_mutex, 0);
if(res != 0)
{
perror("Initialization failed");
... | 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, le... | 1 |
#include <pthread.h>
static pthread_mutex_t pc_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct iface_stats *sample_buf;
static struct iface_stats *produce_ptr;
static struct iface_stats *consume_ptr;
void raw_sample_buf_init()
{
sample_buf = malloc((3 * sizeof(struct iface_stats)));
ass... | 0 |
#include <pthread.h>
int DownLoadHttp(struct arg *s_info)
{
char get[256];
char buf[1024]="";
char headhost[256];
char range[32];
int connected =0;
int i,j,starttext,boolprint=0;
int sock,nextthread=0,boolbyte=0;
unsigned long timeuse;
int readen,bytesge... | 1 |
#include <pthread.h>
int **matrix;
pthread_t tid[3];
struct stack_record {
int value;
pthread_t id;
};
struct stack_record *stack;
int stack_iterator;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t var_cond = PTHREAD_COND_INITIALIZER;
sem_t *sem_with_name;
int n;
void *prod... | 0 |
#include <pthread.h>
char* key;
char* value;
size_t value_len;
struct hash_item** pprev;
struct hash_item* next;
} hash_item;
hash_item* hash[1024];
pthread_mutex_t hash_mutex[1024];
hash_item* hash_get(const char* key, int create) {
unsigned b = string_hash(key) % 1024... | 1 |
#include <pthread.h>
enum PhilState { THINKING, HUNGRY, EATING };
pthread_t thread;
int id;
int prio;
int state;
struct philosopher_t *philLeft, *philRight;
} Philosopher;
pthread_cond_t forkLock = PTHREAD_COND_INITIALIZER;
pthread_mutex_t fmutex = PTHREAD_MUTEX_INITIALIZER;
Philo... | 0 |
#include <pthread.h>
struct file
{
char* f_name;
char* f_host;
int f_fd;
int f_flags;
pthread_t f_tid;
} file[20];
int nconn;
int nfiles;
int nlefttoconn;
int nlefttoread;
void* do_get_read(void*);
void home_page(const char*,const char*);
void write_get_cmd(struct file*);
int min(i... | 1 |
#include <pthread.h>
int
gai_suspend (const struct gaicb *const list[], int ent,
const struct timespec *timeout)
{
struct waitlist waitlist[ent];
struct requestlist *requestlist[ent];
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int cnt;
int dummy;
int none = 1;
int result... | 0 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo{
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo* foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_... | 1 |
#include <pthread.h>
double func(double x,double y, double z);
double integrate(double a, double b, double c, double d, double e, double f, int N, int M, int K);
void* proc(void *);
void* pthstat(void *);
double a, b, c, d, e, f, N, M, K;
unsigned pthnum;
double result = 0.0;
char *stat_list;
p... | 0 |
#include <pthread.h>
unsigned long long main_counter, counter[3];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void* thread_worker(void*);
int main(int argc,char* argv[])
{
int i, rtn, ch;
pthread_t pthread_id[3] = {0};
for ... | 1 |
#include <pthread.h>
double ** Matrix;
double ** Result_thrd;
int row,col,N;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int get_rand(int n)
{
return ( ((double) rand()) / 32767 ) * n;
}
void InitializeMatrix()
{
int i,j;
Matrix = (double **) malloc(N * sizeof(double*));
for(i=0;... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
}TLckData;
void *lck_init(void) {
TLckData *lck = malloc(sizeof(TLckData));
if ( lck != 0 ) {
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread... | 1 |
#include <pthread.h>
static pthread_mutex_t lock;
static pthread_rwlock_t rwlock;
static int counter = 0;
static int rwvar = 0;
static void init(int cnt) {
pthread_mutex_init(&lock, 0);
pthread_rwlock_init(&rwlock, 0);
counter = cnt;
}
static void finalize(void) {
pthread_mutex_destro... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t var1;
pthread_cond_t var2;
int writeable;
int sharedData;
} buffer;
int tot = 0;
buffer buf = { .writeable = 1, .sharedData = 0 };
int store(int item, buffer *pb){
pb->sharedData = item;
}
int retrieve(buffer *pb){
int item = ... | 1 |
#include <pthread.h>
void mb_dev_list_init(struct mb_device_list_s *dlist) {
memset(dlist, 0, sizeof(struct mb_device_list_s));
pthread_mutex_init(&dlist->mutex, 0);
}
int mb_dev_add_signal(struct mb_device_list_s *dlist, struct signal_s *signal) {
int mb_id = signal->s_register.dr_device.... | 0 |
#include <pthread.h>
int balance = 1000;
pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER;
void *deposit(void *arg)
{
int amt = 50, i;
for(i=0; i<50; i++)
{
pthread_mutex_lock(&mutx);
balance = balance + amt;
pthread_mutex_unlock(&mutx);
}
return 0;
}
... | 1 |
#include <pthread.h>
static struct Logger* logger = 0;
static const int LOG_BUF_SIZE = 64;
static const int DEFAULT_THRESH = 1000000;
static struct LogQueue* newLogQueue()
{
struct LogQueue* queue = (struct LogQueue*)malloc(sizeof(struct LogQueue));
assert(queue != 0);
queue->head = 0;
queu... | 0 |
#include <pthread.h>
char c;
struct node* next;
}node;
node* head=0;
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c=PTHREAD_COND_INITIALIZER;
void* printlist(void* q)
{
for (;;){
pthread_mutex_lock(&m);
pthread_cond_wait(&c,&m);
node* p;
while (head!=0){
write(1,&hea... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *printHello();
void *printWorld();
int count = 0;
main()
{
pthread_t thread1, thread2;
pthread_create( &thread1... | 0 |
#include <pthread.h>
void * t_func (void *);
pthread_mutex_t mux = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
enum tstate {
T_ALIVE,
T_TERMINATED,
T_JOIN
};
struct tinfo {
pthread_t tid;
enum tstate state;
int sleeptime;
}*threads;
int nthreads = 0;
i... | 1 |
#include <pthread.h>
ssize_t r_read(int fd, void *buf, size_t len)
{
size_t bytestoread;
ssize_t bytesread;
ssize_t totalbytes;
char *ptr = 0;
for (ptr = buf, bytestoread = len, totalbytes = 0; bytestoread > 0; ptr += bytesread, bytestoread -= bytesread)
{
bytesread = read(fd, ptr, byt... | 0 |
#include <pthread.h>
static unsigned int freqScanStartFreq;
static unsigned int freqScanEndFreq;
static short freqScanAmpBuf[518];
static short freqScanPhaseBuf[518];
void setFreqRange(unsigned int startFreq, unsigned int endFreq)
{
freqScanStartFreq = startFreq;
freqScanEndFreq = endF... | 1 |
#include <pthread.h>
struct glut_frame_buffer_t
{
int *buffer;
int width;
int height;
int flush_request;
};
static struct glut_frame_buffer_t *glut_frame_buffer;
void glut_frame_buffer_init(void)
{
glut_frame_buffer = xcalloc(1, sizeof(struct glut_frame_buffer_t));
glut_frame_... | 0 |
#include <pthread.h>
void* naNewLock()
{
pthread_mutex_t* lock = naAlloc(sizeof(pthread_mutex_t));
pthread_mutex_init(lock, 0);
return lock;
}
void naFreeLock(void* lock)
{
pthread_mutex_destroy(lock);
naFree(lock);
}
void naLock(void* lock)
{
pthread_mutex_lock((pthrea... | 1 |
#include <pthread.h>
struct arpQueueNode* addQueueNode(uint32_t ip, const char* interface){
struct sr_instance* sr = get_sr();
struct sr_router* subsystem = (struct sr_router*)sr_get_subsystem(sr);
struct arpQueueNode *cur = subsystem->arpQueue;
while(cur){
if( !strcmp(interface, cur->inte... | 0 |
#include <pthread.h>
pthread_cond_t Var_Cond;
pthread_mutex_t Verrou;
pthread_t Thread_Id;
int Threads_Finis;
} Zone_Part_t;
Zone_Part_t Zone_Part;
sem_t sem;
int main(int argc, char *argv[]){
pthread_t Tid_main, Threads[1000];
int i, Acquittes, Nbre_Threads;
void Un_Thr... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int cnt;
} Counter;
int n, k, numThreads, finished = 0;
int *numer, *denom;
float result = 1.0;
Counter countNumerFactors, countDenomFactors, countNumerBarrier, countDenomBarrier;
sem_t *barrier1, *barrier2;
void* thNumerator(void* arg);
void* thDen... | 0 |
#include <pthread.h>
pthread_t threads[5];
pthread_mutex_t mutexsum;
{
int veclen;
double sum;
double *ap;
double *bp;
} DOTDATA_t;
DOTDATA_t dotstr;
{
pthread_t thread_id;
long offset;
double sum;
int rc;
} thread_data_t;
thread_data_t thread_data[5];
void... | 1 |
#include <pthread.h>
pthread_cond_t CondVar = PTHREAD_COND_INITIALIZER;
pthread_mutex_t MutexCondVar = PTHREAD_MUTEX_INITIALIZER;
void* Thread1(void *data)
{
int rc;
while(1)
{
printf("1"); fflush(stdout);
rc = pthread_cond_broadcast(&CondVar);
if(rc){
perror("pthread_cond_... | 0 |
#include <pthread.h>
pthread_t tid;
uint32_t thNumber;
}pthread_info_t;
uint32_t gCounter = 0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INI... | 1 |
#include <pthread.h>
int isEnd = FALSE;
int product_count = 0;
int produce_times = 0;
pthread_mutex_t produce_mutex;
pthread_cond_t consume_cond;
pthread_cond_t produce_cond;
void* consume(void *pvoid) {
int pid = (int)pvoid;
while (TRUE) {
sleep((uint)(random() % 2));
RLOG("%d ... | 0 |
#include <pthread.h>
static int g_running = 1;
static int g_complete = 0;
static pthread_mutex_t g_mutex;
static pthread_cond_t g_cond;
static void sigint_handler(int signal)
{
(void) signal;
fprintf(stderr, "sigint\\n");
pthread_mutex_lock(&g_mutex);
g_running = 0;
pthread_cond_signal(&g_... | 1 |
#include <pthread.h>
int kuz;
int sharmuta;
pthread_mutex_t zain = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t tutzke = PTHREAD_MUTEX_INITIALIZER;
void* suma(void*arg)
{
for(int i=0;i<10000;++i)
{
pthread_mutex_lock(&zain);
kuz= kuz +1;
pthr... | 0 |
#include <pthread.h>
float array1[1024][1024];
float array2[1024][1024];
pthread_t t[16];
int num_of_iter = 0;
int not_converged = 1;
int count =0;
pthread_mutex_t count_lock;
pthread_cond_t ok_to_proceed;
} mylib_linear_barrier_t;
mylib_linear_barrier_t barrier1;
mylib_lin... | 1 |
#include <pthread.h>
pthread_mutex_t mutexid;
pthread_mutex_t mutexres;
int idcount = 0;
pthread_mutex_t joinmutex[2];
int join[2];
int result[2];
int target;
int sequence[(2 * 30)];
void *thread (void *arg)
{
int id, i, from, count, l_target;
pthread_mutex_lock (&mutexid);
l_target = ... | 0 |
#include <pthread.h>
pthread_mutex_t pingmtx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t pongmtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t pingcv = PTHREAD_COND_INITIALIZER;
pthread_cond_t pongcv = PTHREAD_COND_INITIALIZER;
int minprio;
int maxprio;
int nrmlprio;
int specprio;
int main( int,... | 1 |
#include <pthread.h>
static pthread_mutex_t logLock;
int ptapp_logging_init(void)
{
int rv = 0;
FILE *fp;
rv = pthread_mutex_init(&logLock, 0);
_PTAPP_ASSERT_NET_ERROR( (rv == 0), "PTAPP : Error creating logging mutex \\n");
fp = fopen(PTAPP_COMMUNICATION_LOG_FILE_NEW, "... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct thread_info {
double **A_matrix_pointer;
double **B_matrix_pointer;
double **C_matrix_pointer;
int b, d;
int * counter;
int src, dst;
};
void *subsum(void *arg) {
double s = 0;
struct ... | 1 |
#include <pthread.h>
int cur =0;
char content[4] = {'1', '2', '3', '4'};
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t ready = PTHREAD_COND_INITIALIZER;
void *thread_func(void *arg){
int x = (int)arg;
int i;
for(i=0; i<10;i++){
pthread_mutex_lock(&lock);
... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=... | 1 |
#include <pthread.h>
struct data {
char **arr;
int mem_allocated;
double t_alloc, t_free, t_realloc, t_refree, t_total;
};
inline double curr_time(void)
{
struct timeval tv;
gettimeofday(&tv, 0);
return tv.tv_sec * 1e-6 + (double) tv.tv_usec;
}
void * malloc_local(void *args)
{... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, offset, len ;
double mysum, *x, *y;
offset = (int)arg;
len = dots... | 1 |
#include <pthread.h>
extern sigset_t signal_set;
unsigned int bwritten = 0;
pthread_mutex_t bwritten_mutex = PTHREAD_MUTEX_INITIALIZER;
void * http_get(void *arg) {
struct thread_data *td;
int sd;
char *rbuf, *s;
long long dr, dw, i;
long long foffset;
pthread_t tid;
tid = pthre... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.