text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int SHARED_GLOBAL_VAR = -1;
int count = 0;
int readers = 0;
pthread_mutex_t mux = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_reader = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_writer = PTHREAD_COND_INITIALIZER;
void *writer(void* param);
void *reader(void* param);
void ran... | 1 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
static void * func_add( void *arg){
volatile mytype *p = (mytype *) arg;
for( int i = 0; i < 100000000 ; i++){
pthread_mutex_lock(&mut);
(*p)++;
pthread_mutex_unlock(&mut);
}
return 0;
}
... | 0 |
#include <pthread.h>
clock_t timeInsert;
clock_t timeMember;
clock_t timeDelete;
float timeInsertTotal,timeMemberTotal,timeDeleteTotal = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct list_node_s{
int data;
struct list_node_s* next;
};
int Member(int value, struct list_n... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
void __VERIFIER_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
char *v;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *thread1(void * arg)
{
v = malloc(sizeof(char));
return 0;
}
void *thread2(... | 0 |
#include <pthread.h>
struct task * generate_task(void (*func)(void *, struct task *), void *arg) {
struct task *t = dsm_malloc(sizeof(struct task));
t->func = func;
t->arg = arg;
t->next = 0;
t->deps = 0;
t->parent = 0;
return t;
}
struct task * enqueue_task(struct task *t) {... | 1 |
#include <pthread.h>
bool done = 0;
int size = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_cond;
int number;
struct LList *next;
} LList;
void *T1(void *t);
void *T2(void *t);
int randGen();
int getFactorial(int toFact);
int getEntry(LList *head_loc);
void AddEntry(LList *he... | 0 |
#include <pthread.h>
int var = 0;
int var2 = 100000;
pthread_mutex_t mutex_1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_2 = PTHREAD_MUTEX_INITIALIZER;
void* sumar();
void* restar();
int main(){
pthread_t suma;
pthread_t resta;
pthread_create(&suma,0,sumar,0);
pthread_create(&re... | 1 |
#include <pthread.h>
void init_serial_comm(){
pthread_mutex_init(&m_analizza_pacchetto, 0);
int i;
tty_open(PIC_DEVICE);
for(i=0;i<N_PIC_MES_BUFF;i++){*(pic_message_buffer+i)=malloc(MAX_PIC_MES_LENGHT*sizeof(unsigned char));}
current_pic_packet_slot=0;
}
void signal_handler_IO (int ... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t count_mutex3 = PTHREAD_MUTEX_INITIALIZER;
pthread_t tID[3];
int resultMatrix [3][3];
int array [3][3];
void *solveMatrix (void *arg){
long tid, i, j;
tid = (long) arg;
if(tid == 0){
printf("Thre... | 1 |
#include <pthread.h>
FILE*file;
int num;
}ph;
int count=0;
char array[1000];
int process=0;
pthread_mutex_t mutex;
int mut;
ph one;
ph two;
void *read_thread(void *ptr);
int main(void) {
pthread_mutex_init(&mutex, 0);
FILE*file1;
FILE*file2;
file1=fopen("data1.txt", "r");
file2=fopen("... | 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>
int end;
int i,j;
char buffer[5];
pthread_mutex_t mutex;
pthread_cond_t empty,full;
int thread_num;
int par_count;
} thdata;
void Producer(FILE *fp)
{
char s1;
s1 = fgetc(fp);
while(1)
{
pthread_mutex_lock(&mutex);
buffer[i] = s1;... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int curThread = 0;
int timecount = 0;
void *createThread(void *input) {
pthread_mutex_lock(&mutex);
curThread++;
int actual = curThread;
printf("Hello from thread No. %d!\\n", curThread);
pthread_mutex_unl... | 1 |
#include <pthread.h>
int N;
int *vetorPrefixosSeq;
int *vetorPrefixosPar;
int threads = 0;
pthread_mutex_t mutex, mutex_bar;
pthread_cond_t cond_bar;
void barreira(int NTHREADS) {
pthread_mutex_lock(&mutex_bar);
threads++;
if (threads < NTHREADS) {
pthread_cond_wait(&cond_bar, &mutex_bar);
... | 0 |
#include <pthread.h>
int main(int argc, char *argv[]) {
int parentfd;
int childfd;
int port = DEFAULT_PORT;
unsigned int clientlen;
struct sockaddr_in serveraddr;
struct sockaddr_in clientaddr;
struct hostent *hostp;
char *h_name;
int optval = 1;
pthread_t thread_id;
cli... | 1 |
#include <pthread.h>
pthread_mutex_t mx, my;
int x=2, y=2;
void *thread1() {
int a;
pthread_mutex_lock(&mx);
a = x;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
pthread_mutex_unlock(&my);
a = a + 1;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y... | 0 |
#include <pthread.h>
static int count = 0;
static int i;
static pthread_mutex_t countlock = PTHREAD_MUTEX_INITIALIZER;
void *threadcompilereturn(void *arg){
char *filename;
int error;
i = 1;
filename = (char *)(arg);
if(compile(PATH, filename) == 1){
perror("Compiled");
if(error =... | 1 |
#include <pthread.h>
struct mlx5_db_page {
struct mlx5_db_page *prev, *next;
struct mlx5_buf buf;
int num_db;
int use_cnt;
unsigned long free[0];
};
static struct mlx5_db_page *__add_page(struct mlx5_context *context)
{
struct mlx5_db_page *page;
int ps = to_mdev(context->ibv_ctx.device)... | 0 |
#include <pthread.h>
void msgu_event_map_init(struct msgs_event_map *map, struct msgu_handlers *h, void *a) {
pthread_mutex_init(&map->map_mutex, 0);
msgu_map_init(&map->data, msgu_uint32_hash, msgu_uint32_cmp, sizeof(uint32_t), sizeof(union msgu_any_event));
msgu_map_alloc(&map->data... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err, signo;
for(;;) {
err = sigwait(&mask, &signo);
if(err != 0) {
printf("sigwait error\\n");
}
switch(... | 0 |
#include <pthread.h>
struct flash_info {
struct block_manager *blk_mgr;
uint32_t init_called;
struct bm_operation_option operation_option;
struct bm_operate_prepare_info* prepare_info;
uint32_t block_size;
uint32_t page_size;
int64_t capacity;
pthread_mutex_t mutex_... | 1 |
#include <pthread.h>
pthread_t tid[1 +1 +1 +1];
pthread_mutex_t mutex1, mutex1_2, mutex2_3, mutex3;
pthread_cond_t atelier1_2, atelier2_3;
int NbInput = 50;
int NbOutput = 0;
int NbInput1 = 20;
int NbOutput1 = 0;
int NbInput2 = 20;
int NbOutput2 = 0;
int NbInput3 = 20;
int NbOutput3 = 0;... | 0 |
#include <pthread.h>
char buff[5];
int num;
}PRODUCT;
PRODUCT products = {"",0};
char ch = 'A';
pthread_mutex_t mutex;
pthread_cond_t cond;
void *producer_func(void *arg)
{
pthread_t producer_thid;
producer_thid = pthread_self();
printf("Producer %lu: Starting\\n", producer_thid);
whil... | 1 |
#include <pthread.h>
int fd;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *write_data(void *data)
{
char buf[128] = {};
int count = 1;
int ret = 0;
pthread_mutex_lock(&mutex);
while (1)
{
snprintf(buf, sizeof(buf), "%s : count = %d\\n", (char *)data, ... | 0 |
#include <pthread.h>
int quitflag = 0;
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;
for (;;) {
err = sigwait (&mask, &signo);
if (err != 0) {
err_exit (err, "sigwait failed... | 1 |
#include <pthread.h>
pthread_mutex_t buffer;
pthread_cond_t condc, condp;
int limit = 0;
int entry = 0;
struct item {
int value;
int ctimer;
} citem[32];
static unsigned long mt[624];
static int mti=624 +1;
_Bool supportsRDRND() {
const unsigned int flag_RDRAND = (1 << 30);
unsigned int leve... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double wtime()
{
struct timeval t;
gettimeofday(&t, 0);
return (double)t.tv_sec + (double)t.tv_usec * 1E-6;
}
void *counter_thread(void *counter)
{
int i;
for (i = 0; i < 5000000; i++) {
pthread_mutex_lock(&... | 1 |
#include <pthread.h>
bool compare(char * comm, char * comm2)
{
if( strlen( comm ) == strlen( comm2 ) && strncmp( comm, comm2, strlen( comm )) == 0 )
return 1;
return 0;
}
void errorMsg(const char* str)
{
fprintf( stderr, str);
}
char disk[MAX_BLOCK][BLOCK_SIZE];
int disk_read( int... | 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;
int f_id;
struct foo * f_next;
};
struct foo *foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(st... | 1 |
#include <pthread.h>
const int M = 20, CNT = 20000;
pthread_mutex_t level[20 + 1];
void *func_a() {
int i, count = CNT;
while (count--) {
printf("a start %d\\n", count);
for (i = 0; i < M; i++) {
printf("a want %d\\n", i);
pthread_mutex_lock(&level[i]);
}
puts("a");
for (i = ... | 0 |
#include <pthread.h>
int active_sessions_counter;
} llp_info_t;
static llp_info_t info;
static pthread_mutex_t info_mutex;
int llp_info_initialize() {
if (pthread_mutex_init(&info_mutex, 0) > 0) {
liblog_error(LAYER_LINK, "error allocating mutex: %s.",
strerror(errno));
re... | 1 |
#include <pthread.h>
struct check_info {
int span;
int delay;
};
char phone_num[100000][64] = {
0,
};
static int check_phone_count=0;
static FILE *fp=0;
pthread_mutex_t mutex;
void check_phone(const char* num, int span, int delay, char* ret_buf, int buf_len)
{
FILE *stream;
char cm... | 0 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node {
int n_number;
struct node *n_next;
} *head = 0;
static void cleanup_handler(void *arg)
{
printf("Cleanup handler of second thread./n");
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double *
jacobi (double *x, double *X, double *A, double *b, int h, int w,
int rank, int size)
{
int li, i, j, convergence, iter;
double d, ldelta, delta;
for (li = 0; li < h; li++)
x[li] = 1.0;
iter = 0... | 0 |
#include <pthread.h>
void posts_db_init(struct post_fds *fds, char *meta_path, char *post_path) {
fds->meta_fd = open(meta_path, O_RDWR|O_APPEND|O_CREAT, 0600);
fds->post_fd = open(post_path, O_RDWR|O_APPEND|O_CREAT, 0600);
pthread_mutex_init(&fds->mutex, 0);
}
void posts_db_... | 1 |
#include <pthread.h>
int *arr;
int tid;
int size;
int nthreads;
double *time;
} params;
int pairmax(int *arr, int startIndex, int endIndex);
void *threadParallelSum( void *ptr );
double maximum(double a, double b);
long upper_power_of_two(long v);
static int globa... | 0 |
#include <pthread.h>
int GnChopstick[5] = {0} ;
pthread_mutex_t mutex[5];
pthread_t GpThread[5];
void *Aristotle ();
void *Plato();
void *Marx();
void *Laozi();
void *Zhuangzi();
int thread_create();
void thread_wait();
int main()
{
int i;
for(i = 0;i < 5;i++)
{
pthread_mu... | 1 |
#include <pthread.h>
int buffer[32] = {0};
int acked = -1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * consumer(void * round) {
int version;
version = *((int *)round);
if (version == 10000) return 0;
while (1) {
usleep(10);
pthread_mutex_l... | 0 |
#include <pthread.h>
struct node{
int data;
struct node *next;
} *head;
pthread_t searcher[3];
pthread_t deleter[3];
pthread_t inserter[3];
pthread_mutex_t insert_mutex;
pthread_mutex_t delete_mutex;
sem_t delete_insert_lock;
sem_t delete_search_lock;
void *search(void *arg);
void *delet... | 1 |
#include <pthread.h>
double cur_time() {
struct timespec ts[1];
clock_gettime(CLOCK_REALTIME, ts);
return ts->tv_sec + ts->tv_nsec * 1.0E-9;
}
void think(double s) {
double t0 = cur_time();
while (cur_time() - t0 < s) { }
}
double enter_lock_time;
double return_from_lock_tim... | 0 |
#include <pthread.h>
int buf[8];
int count;
int in,out;
int waiting;
pthread_mutex_t bbmutex;
pthread_cond_t bbcond;
void *producer(void *arg);
void *consumer(void *arg);
int get();
void put(int val);
void bbint(){
pthread_mutex_init(&bbmutex,0);
pthread_cond_init(&bbcond,0);
in = ... | 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>
pthread_mutex_t a = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t b = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t c = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t d = PTHREAD_MUTEX_INITIALIZER;
void *
thr_fn1(void *arg)
{
while (1) {
pthread_mutex_lock(&a);
printf("a");
pthr... | 1 |
#include <pthread.h>
int
csnet_cond_init(struct csnet_cond* cond) {
if (pthread_mutex_init(&cond->mutex, 0) < 0) {
return -1;
}
if (pthread_cond_init(&cond->cond, 0) < 0) {
pthread_mutex_destroy(&cond->mutex);
return -1;
}
return 0;
}
void
csnet_cond_destroy(struct csnet_cond* cond)... | 0 |
#include <pthread.h>
static int has_init_thread_pool = 0;
static int thread_num = 10;
static void *thread_pool;
static struct task *task_head;
pthread_mutex_t task_mutex;
pthread_mutex_t read_task_mutex;
void *thread_handle(void *arg);
int
init_thread_pool(int max)
{
thread_num = max;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_fpga= PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_dpll= PTHREAD_MUTEX_INITIALIZER;
{
unsigned char cs;
unsigned short addr;
unsigned short len;
unsigned char buff[64];
}spi_rdwr;
int fd,errnu_f = 0,errnu_d = 0;
spi_rd... | 0 |
#include <pthread.h>
void* philosopher (void* t_id_t);
pthread_mutex_t forks[4];
int main (int argc, char *argv[])
{
pthread_t seat[4];
int t_id[4] = {0,1,2,3};
int err = 0;
int i=0;
for (i = 0; i < 4; i++)
{
if (pthread_mutex_init (&forks[i], 0) != 0){
printf("\\n mutex init fa... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int avail = 0;
static void *
threadFunc(void *arg)
{
int cnt = atoi((char *) arg);
int j;
for (j = 0; j < cnt; j++) {
sleep(1);
... | 0 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static int environ_extended = 0;
void update_existing_env(const char *str, int env_indx);
void add_new_env(const char *str);
static void thread_init(void) {
pthread_mut... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER;
void *producer(void *arg)
{
long int i;
long int loops = (long int)arg;
for (i=0; i<loops; i++) {
p... | 0 |
#include <pthread.h>
int buffer;
int count = 0;
pthread_cond_t cond;
pthread_mutex_t mutex;
void put(int value) {
assert(count == 0);
count = 1;
buffer = value;
}
int get() {
assert(count == 1);
count = 0;
return buffer;
}
void *producer(void *arg) {
int i;
int ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_t chCliente[5];
pthread_t caixas[5];
int filas_vazia = 5;
int cliente_fila = 0;
int conf = 0;
sem_t filas[5];
sem_t clientes;
void NoCaixa(float delay1) {
fl... | 0 |
#include <pthread.h>
int fib;
pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
void* fibonacci(void *n)
{
int a=0,b=1,c,i;
pthread_mutex_lock(&counter_lock);
if(atoi(n)==1){
printf("Fibonacci sequence: ");
printf("%d\\n",a);
exit(0);
}
else if(atoi(n)==2){
printf... | 1 |
#include <pthread.h>
double pe_final;
double *a;
double *b;
pthread_mutex_t sb;
void *calc(void *threadarg)
{
int i,j,thid;
double pe;
thid =(intptr_t) threadarg;
for(i=thid;i<100000000;i+=8){
pe += a[i]*b[i];
}
pthread_mutex_lock(&sb);
pe_final+=pe;
pthread_mutex_unlock(&sb);
}
i... | 0 |
#include <pthread.h>
void *functionA();
void *functionB();
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t con_var1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t con_var2 = PTHREAD_COND_INITIALIZER;
int counter = 1;
int main(){
pthread_t thread1, thre... | 1 |
#include <pthread.h>
static unsigned int *mod[TILES];
static void
compress_row (size_t row)
{
short first_zero = -1, first_non_zero = -1;
if (row > 3)
return;
for (int i = 0; i < 4; i++) {
if (*mod[row*4 +i] == 0 && first_zero < 0)
first_zero = i;
if (*mod[row*4 +i] == 0 ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void* thread1(void* arg);
void* thread2(void* arg);
void* thread3f(void* arg);
void* thread4f(void* arg);
int main(){
pthread_t thread;
pthread_t thread3;
pthread_t thr... | 1 |
#include <pthread.h>
const int THREAD_NUMBER = 3;
pthread_mutex_t thread_mutex[THREAD_NUMBER];
pthread_cond_t thread_cond[THREAD_NUMBER];
bool thread_wait_flag[THREAD_NUMBER];
pthread_mutex_t mutex;
int thread_turn;
void *thread_func(void *arg);
int main(int argc, char **argv)
{
pthrea... | 0 |
#include <pthread.h>
int curRow,curCol;
int ar , ac , br , bc;
struct arg_struct {
int row,col;
};
int A[1000][1000],B[1000][1000],C[1000][1000];
void nextTask();
void *multiply(void *arguments)
{
struct arg_struct *args = (struct arg_struct *)arguments;
int row=args->row , co... | 1 |
#include <pthread.h>
double a;
double b;
int n;
double approx;
int thread_amount;
pthread_mutex_t approx_lock;
double static NEG_1_TO_POS_1 = 0.66666666666667;
double static ZERO_TO_POS_10 = 333.333;
double f(double a) {
return a * a;
}
void trap() {
double h = (b-a) / n;
approx = ... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5];
pthread_mutex_t getting_forks_mx;
pthread_cond_t getting_forks_cond;
pthread_t phils[5];
void *philosopher (void *id);
int food_on_table ();
void get_forks (int, int, int);
void down_forks (int, int);
pthread_mutex_t foodlock;
int sleep_seconds... | 1 |
#include <pthread.h>
int sum = 0;
int arr[8][100];
pthread_mutex_t sum_mutex;
void* do_work(void* num)
{
int i, j, start, end;
int* int_num;
int local_sum = 0;
int_num = (int *) num;
start = *int_num * 8 / 4;
end = start + 8 / 4;
printf ("Thread %d summing arr[%d][%d]... | 0 |
#include <pthread.h>
struct clientinfo {
int s;
struct sockaddr_in sin;
};
struct line {
char *s;
int status;
struct line *next;
} *head, **ptail;
int n_sent = 0, n_received=0, n_flushed=0;
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t clients_mutex... | 1 |
#include <pthread.h>
int thread_count;
double data[] = {1.3, 2.9, 0.4, 0.3, 1.3, 4.4, 1.7, 0.4, 3.2, 0.3,
4.9, 2.4, 3.1, 4.4, 3.9, 0.4, 4.2, 4.5, 4.9, 0.9};
int bin_count = 5;
int data_count, sum, local_d_count;
int *bin_counts, *local_bin_count;
double min_meas, max_meas, bin_wi... | 0 |
#include <pthread.h>
pthread_mutex_t resource1;
pthread_mutex_t resource2;
void *threadOne(void *args)
{
pthread_mutex_lock(&resource1);
pthread_mutex_lock(&resource2);
printf("Thread 1 has both resources, and is running!\\n");
pthread_mutex_unlock(&resource2);
pthread_mut... | 1 |
#include <pthread.h>
{
int stock;
pthread_t thread_store;
pthread_t thread_clients[5];
pthread_mutex_t mutex_stock;
pthread_cond_t cond_stock;
pthread_cond_t cond_clients;
}
store_t;
static store_t store =
{
.stock = 20,
.mutex_stock = PTHREAD_MUTEX_INITIALIZER,
.cond_stock = P... | 0 |
#include <pthread.h>
int stoj = 0;
int pocet_chlebov;
int pocet_pekarov = 0;
pthread_mutex_t mutex_pocet_chlebov = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_pocitadlo_pekarov = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_turniket = PTHREAD_MUTEX_INITIALIZER;
sem_t sem_pece;
sem_t... | 1 |
#include <pthread.h>
struct Data *table[ 29 ];
pthread_mutex_t tablelock = PTHREAD_MUTEX_INITIALIZER;
struct Data {
int count;
pthread_mutex_t lock;
struct Data *next;
int id;
int number;
};
struct Data *data_alloc( void ) {
struct Data *data;
int index;
if ( (data = ma... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int* vet;
} Vector;
Vector V;
int t;
void merge(int *vet, int left, int middle, int right);
void* threadedMergeSort(int* args);
int main(int argc, char** argv) {
int i, n;
int args[2];
if (argc != 3) {
fprintf (stderr, "Wrong number of ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex [4];
pthread_cond_t cond [4];
int flag[4];
void *thread_cond(void *args) {
int id = (*(int *)args);
free(args);
if (id != 0)
{
pthread_mutex_lock(&mutex[id]);
if (!flag[id])
{
pthread_cond_wait(&co... | 0 |
#include <pthread.h>
void * Lector(void * p);
void * Escritor(void * p);
int dato=5;
pthread_mutex_t mutex;
pthread_cond_t leer,escribir;
int leyendo=0,escribiendo=0;
int main()
{
pthread_t l1,l2,e1,e2;
int i;
pthread_mutex_init(&mutex,0);
pthread_cond_init(&leer,0);
... | 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(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_m... | 0 |
#include <pthread.h>
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t stats_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_rider = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_driver = PTHREAD_COND_INITIALIZER;
const int MAX_SLEEP = 40 / 2;
int ride... | 1 |
#include <pthread.h>
void *static_guard_page;
void static_fixup_init(void)
{
static_guard_page = alloc_guard_page(1);
if (!static_guard_page)
abort();
}
static int
add_static_fixup_site(enum static_fixup_type type, struct insn *insn,
struct vm_field *vmf, struct compilation_unit ... | 0 |
#include <pthread.h>
char buf[128];
int wpos;
int rpos;
pthread_cond_t cv;
pthread_mutex_t mtx;
void * printer(void * data){
pthread_cond_wait(&cv,&mtx);
while (1){
write(1,buf+wpos+1,buf[wpos]);
wpos += 16;
wpos %= 128;
pthread_cond_wait(&cv,&mtx);
}
}
void * reader(void * data){
s... | 1 |
#include <pthread.h>
pthread_t ledThread;
pthread_mutex_t ledStatusChange;
void *ledHandler(void*);
int main()
{
short status=PASS;
ioperm(0x80,2,1);
int ledStatus=0x00;
unsigned int i=0;
ledStatus = 0x0F;
pthread_mutex_init (&ledStatusChange, 0);
if (pthr... | 0 |
#include <pthread.h>
void *worker(){
int workNum;
int readnum, i;
int newsock;
int connectionsNum = 0;
int state, end, choice;
double t2;
struct timeval tim;
FILE *fd;
vote *v;
pthread_mutex_lock (& worker_id);
workNum = workerNumber;
workerNumber += 1;
pthread_mutex_unlock (& wor... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex;
pthread_mutex_t stop_mutex;
pthread_cond_t count_empty_cond;
pthread_cond_t count_full_cond;
int count=0;
int iteration=0;
enum THREAD_ENUM{
FILL_THREAD=0,
EMPTY_THREAD=1,
ALL_THREADS
};
char THREAD_NAMES[ALL_THREADS][64]=... | 0 |
#include <pthread.h>
void *sum(void *p);
unsigned long int psum[8][8];
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);
... | 1 |
#include <pthread.h>
int size;
int used;
struct __node_t *next;
} node_t;
struct __list_t {
struct __node_t *head;
pthread_mutex_t lock;
} list_t;
struct __list_t *L;
void *heap_start;
int heap_end;
int mymalloc_init() {
L = sbrk(4096);
if (L == (void *) -1) {
... | 0 |
#include <pthread.h>
pthread_mutex_t memory_mutex = PTHREAD_MUTEX_INITIALIZER;
extern int mmcamera_stacktrace(intptr_t* addrs, size_t max_entries);
struct hdr_t {
struct hdr_t *prev;
struct hdr_t *next;
intptr_t bt[15];
int bt_depth;
};
static unsigned num;
static hdr_t *l... | 1 |
#include <pthread.h>
struct shape *s;
pthread_mutex_t blok;
void exit_tetris( void ){
erase();
move( startY, startX );
printw( "Game over!\\n" );
move( startY + 5, startX );
printw( "You scored %d!\\n", score );
refresh();
sleep_t( 3. );
endwin();
free( s );
pthread_mutex_de... | 0 |
#include <pthread.h>
unsigned int nthreads = 30;
int load_grid(int grid[][9], char *filename);
int grid[9][9];
int reorgGrid[9][9];
int nextCell = 0;
int nextReorgCell = 0;
int erros = 0;
pthread_t tidpai;
pthread_mutex_t mutexCell, mutexReorg, mutexErr;
pthread_barrier_t trump;
void checkCol(... | 1 |
#include <pthread.h>
static int thread_exit;
static pthread_t thread_id;
static int thread_inuse;
static pthread_cond_t thread_cond;
static pthread_mutex_t thread_mutex;
static void (*thread_func)(void*, int, int);
static void* thread_arg;
static void* thread_proc(void* arg)
{
pthread_mutex_loc... | 0 |
#include <pthread.h>
void *ihome_read ( void *prm)
{
struct hostent *server;
struct sockaddr_in serv_addr;
int bytes, sent, received, total, l_indx;
char response[1000], *e1, *e2, *e3;
while (1)
{
for (l_indx = 0; l_indx < nb_Of_Input_Elements; l_indx++)
{
pthread_m... | 1 |
#include <pthread.h>
static unsigned int avail = 0;
static int work_pipe[2];
static pthread_mutex_t mtx_work;
static unsigned int producers = 10000;
unsigned int random_uint(unsigned int max)
{
float tmp = (float)rand()/(float)32767 * (float)max;
return (unsigned int)ceilf(tmp);
}
... | 0 |
#include <pthread.h>
volatile unsigned char program_runs;
static pthread_mutex_t mikes_lock;
volatile unsigned short threads_running;
volatile unsigned char user_control;
volatile unsigned char user_dir;
volatile unsigned char start_automatically;
void threads_running_add(short x)
{
pthread_mu... | 1 |
#include <pthread.h>
pthread_mutex_t db_source_mutex = PTHREAD_MUTEX_INITIALIZER;
char sname[32];
char dbname[32];
char uname[32];
char auth[32];
char dbport[32];
int _db_connect(struct db_context_t *dbc)
{
const char *conninfo;
char tmp[256];
pthread_mutex_lock(&db_source_mutex);
sprintf... | 0 |
#include <pthread.h>
int NumProcs;
pthread_mutex_t SyncLock;
pthread_cond_t SyncCV;
int SyncCount;
pthread_mutex_t ThreadLock;
int Count;
void Barrier()
{
int ret;
pthread_mutex_lock(&SyncLock);
SyncCount++;
if(SyncCount == NumProcs) {
ret = pthread_cond_broadcast(&SyncCV);
S... | 1 |
#include <pthread.h>
int main(){
pthread_mutexattr_t attributes;
pthread_mutexattr_init(&attributes);
pthread_mutexattr_setpshared(&attributes,PTHREAD_PROCESS_SHARED);
int handle = shm_open("/shm",O_CREAT|O_RDWR,0777);
ftruncate(handle,1024*sizeof(int));
char *mem=(char *)mmap(0,... | 0 |
#include <pthread.h>
void
tcp_read ( struct chat_client *chat_client_p ){
char buffer[MAX_BUFFER_LEN];
char message[MAX_MESSAGE_LEN];
int retval;
int retval_command;
int nsfd;
char *hello = "Bitte gib deinen Nickname ein: ";
int len;
int message_termi... | 1 |
#include <pthread.h>
int shmid;
char *addr;
pthread_mutex_t *p_mutex;
pthread_mutexattr_t mutex_attr;
void sigint_handler(int signal)
{
int ret;
ret = shmctl(shmid, IPC_RMID, 0);
if (ret < 0)
{
perror("shmctl");
}
pthread_mutexattr_destroy(&mutex_attr);
}
vo... | 0 |
#include <pthread.h>
{
int value;
struct cell *next;
}
*cell;
{
int length;
cell first;
cell last;
}
*list;
list add (int v, list l)
{
cell c = (cell) malloc (sizeof (struct cell));
c->value = v;
c->next = 0;
if (l == 0){
l = (list) malloc (sizeof (struct list)... | 1 |
#include <pthread.h>
struct foo {
int count;
pthread_mutex_t mutex;
char s[3];
};
struct foo * fp;
struct foo * init_foo() {
struct foo * fp;
if ((fp = (struct foo *) malloc(sizeof(struct foo))) != 0) {
fp->count = 1;
fp->s[0] = 'a';
fp->s[1] = 'b';
fp->s[2] = 'c';
if (pth... | 0 |
#include <pthread.h>
pthread_mutex_t lockFlow;
pthread_mutex_t lockHillA;
pthread_mutex_t lockHillB;
pthread_mutex_t lockTurn;
void * flowAtoB (void * arg);
void * flowBtoA (void * arg);
int monAtoB = 0,
monBtoA = 0;
int main (int argc, char * argv[])
{
pthread_t monkeysAB[10 + 10];
int * id ... | 1 |
#include <pthread.h>
static char OUTPUT_FILENAME[100] = "sequence.log";
static char IF_FILENAME[100] = "occurrence.log";
static long LOOPS = 190000;
static unsigned int THREAD_NUMS = 4;
static unsigned int MCODE_NUMS = 4;
static int sequence[100];
int sequenceOrder;
unsigned int order = 0;
... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
};
struct foo * foo_alloc() {
struct foo * fp;
if((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
if(pthread_mutex_init(&fp->f_lock, 0) != 0) {
free(fp);
r... | 1 |
#include <pthread.h>
int tam_vet;
int MAX_THREADS;
unsigned long int prod;
int count = 0;
pthread_mutex_t mutex;
unsigned long int *a, *b;
void calculo_produto() {
pthread_mutex_lock(&mutex);
++count;
if (count == tam_vet) return;
prod += a[count] * b[count];
pthread_mutex_unlock(&mut... | 0 |
#include <pthread.h>
void error(const char*);
void *thread_run(void *arg) {
char buffer[65536];
char bigbuf[65536];
char *pch;
int i, j, n, newsockfd;
int abort;
int small_sum;
int addvals[10000];
int tot_vals;
newsockfd = *(unsigned int *)arg;
bzero(... | 1 |
#include <pthread.h>
{
int id;
int cineId;
int status;
int ocupados;
} Sala;
{
int id;
int cineId;
} Taquilla;
{
int id;
} Usuario;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int atendidos = 0;
int iCola = 0;
Usuario * cola;
Sala * salas;
Taquilla * taquill... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.