text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int Escritores;
int EscritoresEsp;
int Lectores;
pthread_mutex_t mutex;
pthread_cond_t AccesoEs;
pthread_cond_t AccesoLec;
}mutex_rw;
int mutex_create( mutex_rw* x){
x->Lectores=0;
x->Escritores=0;
x->EscritoresEsp=0;
pthread_con... | 1 |
#include <pthread.h>
pthread_mutex_t *f_lock = 0;
struct shared_context{
int ref_cnt;
int last_process;
};
struct shared_context * sctx = 0;
int main()
{
int ret;
f_lock = (pthread_mutex_t *)mmap(0, sizeof(pthread_mutex_t),
PROT_READ|PROT_WRITE, MAP_SH... | 0 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
};
struct s *new(int x) {
struct s *p = malloc(sizeof(struct s));
p->datum = x;
p->next = 0;
return p;
}
void list_add(struct s *node, struct s *list) {
struct s *temp = list->next;
list->next = node;
node->next = temp... | 1 |
#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 = ... | 0 |
#include <pthread.h>
struct node {
struct node * next;
char * str;
};
pthread_mutex_t mutex;
node_t * head = 0;
node_t * add_node(node_t * node, node_t * head) {
node->next = head;
return node;
}
void show_list(node_t * head) {
node_t * cur = head;
while(cur) {
printf("%s\\n", cur->st... | 1 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node {
int num;
struct node *next;
};
struct node *head = 0;
static void *thread_func(void *arg)
{
struct node *p;
while (1) {
pthread_mutex_lock(&mtx);
while (h... | 0 |
#include <pthread.h>
static int rescheduled = 0;
static pthread_mutex_t eventMutex;
static pthread_cond_t eventCond;
static pthread_mutex_t eventListMutex;
struct testEvent {
struct rxevent *event;
int fired;
int cancelled;
};
static struct testEvent events[10000];
static ... | 1 |
#include <pthread.h>
void *produce(void *i);
void *consume(void *i);
pthread_mutex_t mutex[5] = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
int counter = 0;
int buffer[5];
main(int argc, char **ar... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full,empty;
int buffer[10],counter;
pthread_t tid;
void initialize()
{
pthread_mutex_init(&mutex,0);
sem_init(&full,0,0);
sem_init(&empty,0,10);
counter=0;
}
void insert_item(int item)
{
buffer[counter++]=item;
}
int r... | 1 |
#include <pthread.h>
int fd;
static uint8_t spi_mode,spi_bits;
static uint32_t spi_speed;
static uint16_t spi_delay;
pthread_mutex_t spi_mutex;
int fpga_open()
{
int ret;
pthread_mutex_init ( &spi_mutex, 0 );
spi_mode = SPI_MODE;
spi_bits = SPI_BITS_PER_WORD;
spi_speed = SPI_SPEED_... | 0 |
#include <pthread.h>
int *array;
int array_size;
int begin;
int interval;
} Array_arg;
int global_sum;
pthread_mutex_t lock;
void *sum (void *argument)
{
Array_arg *arg = (Array_arg *)argument;
int i, sum = 0;
for (i = arg->begin; i < arg->begin + arg->interval; i++) {
sum += ar... | 1 |
#include <pthread.h>
int* vet;
pthread_mutex_t mutex;
} Data;
Data data;
void merge(int *vet, int left, int middle, int right) {
int i, j, k;
int n1 = middle - left + 1;
int n2 = right - middle;
int L[n1], R[n2];
for (i = 0; i <= n1; i++)
L[i] = vet[left + i];
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t freePos,
filledPos;
int prod_pos = 0,
cons_pos = 0,
stock = 0,
buffer[20];
void * producer (void * arg);
void * consumer (void * arg);
int main (int argc, char * argv[])
{
pthread_t producer... | 1 |
#include <pthread.h>
int file_flag[25]={0};
pthread_mutex_t mutex;
int check_file(char filename[])
{
pthread_mutex_lock(&mutex);
char buf[2];
buf[0]=filename[6];
if(filename[7]!='.')
{buf[1]=filename[7];}
int tmp=atoi(buf);
if(file_flag[tmp-1]==0)
{
file_flag[tmp-1]=1;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int num = 0;
FILE *fp[4];
int file = 1;
void *write_func(void *arg)
{
int i;
int j;
int count = (int)arg;
for(i = 0; i < 10; i++)
{
pthread_mutex_lock(&mutex);
while(count != num)
{
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void busyWait(int i) {
int j = 21474;
i = i < 0 ? 1 : i;
while (i>=0) {
while (j>=0) {j--;}
i--;
}
}
void *funThread1() {
printf("Thread 1 trying to lock the mutex now\\n");
pthread_mutex_lock(&mutex);
printf("Thread 1 suce... | 0 |
#include <pthread.h>
{
int num_threads,id, plate_size,num_cycles;
pthread_barrier_t * barrier;
pthread_mutex_t * lock;
double ***sheet;
double * min;
double * max;
} Params;
static void *slave(void * param)
{
Params * p = (Params *) param;
int id = -1;
... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
data_t _data;
struct node * _next;
}node_t,*node_p,**node_pp,*list_head;
list_head head = 0;
static node_p buy_node(data_t data)
{
node_p new_node = (node_p)malloc(sizeof(node_t));
if(new_node == 0){
printf... | 0 |
#include <pthread.h>
int thID;
int min;
int max;
} arg;
int **a, *b, *c;
int N, M, T;
pthread_mutex_t mx;
void tres (arg *args) {
int i, j;
int *cl;
cl = malloc (N * sizeof (int));
for (i=0; i<N; i++) cl[i] = 0;
for (j=args->min; j<args->max; j++)
for (i=0; i<N; i++)
... | 1 |
#include <pthread.h>
pthread_mutex_t bucket_lock;
int uma_page_mask;
struct uma_page_head *uma_page_slab_hash;
void
thread_bucket_lock(void)
{
pthread_mutex_lock(&bucket_lock);
}
void
thread_bucket_unlock(void)
{
pthread_mutex_unlock(&bucket_lock);
}
| 0 |
#include <pthread.h>
int N=3;
int mailBox[2];
int readCount=0;
pthread_mutex_t read_mutex;
pthread_mutex_t write_mutex;
void* ring(void*arg){
int *id;
int content;
id=(int*)arg;
char flag=0;
int writeCount=2;
while(writeCount>=0){
pthread_mutex_lock(&read_mutex);
if(readCount==0)
pthr... | 1 |
#include <pthread.h>
void* compute_thread (void*);
pthread_mutex_t my_sync;
main( )
{
pthread_t tid;
pthread_attr_t attr;
char hello[ ] = {"Hello, "};
char thread[ ] = {"thread"};
pthread_attr_init (&attr);
pthread_mutex_init (&my_sync,0);
pthread_create(&tid, &attr, comput... | 0 |
#include <pthread.h>
char* ipAddress = "192.168.250.";
pthread_mutex_t bloqueo;
int estado=0;
int Comando_ping(char *Direccion) {
char *comando = 0;
char buffer[1024];
FILE *fp;
int stat = 0;
asprintf (&comando, "%s %s", "ping", Direccion);
printf("%s\\n", comando);
fp = po... | 1 |
#include <pthread.h>
int kupon[6] = {1,10,23,40,42,45};
int rezultat[7] = {0,0,0,0,0,0,0};
struct lotto{
int *vkupon;
int *vrezultat;
int s_pos;
int k_pos;
};
pthread_mutex_t mtx;
void* losuj(void *vlotto);
int main()
{
struct lotto s_lotto[1];
int k;
for(k = 0; k<1; k++)
{
... | 0 |
#include <pthread.h>
int main(int argc, char* argv[]) {
int i = 0;
int buffer_size = 2048;
if(argc != 1) {
buffer_size = atoi(argv[1]);
}
int pixel_buffer_size = buffer_size+1;
data.buffer_size = buffer_size;
data.pixel_buffer_size = pixel_buffer_size;
if((data.buffer = malloc(buffe... | 1 |
#include <pthread.h>
enum job_cmd {
JOB_CMD_RUN,
JOB_CMD_END
};
struct job {
struct job *j_next;
struct job *j_prev;
pthread_t j_id;
enum job_cmd j_cmd;
};
struct queue {
struct job *q_head;
struct job *q_tail;
pthread_rwlock_t q_lock;
};
struct thr_cond {
pthread_t tid;
pthread_c... | 0 |
#include <pthread.h>
extern int makethread(void *(*) (void *), void *);
struct to_info {
void (*to_fn) (void *);
void *to_arg;
struct timespec to_wait;
};
void
clock_gettime(int id, struct timespec *tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
tsp->tv_nsec = tv... | 1 |
#include <pthread.h>
int lines_read = 0;
static ssize_t
get_line(int fdin, char *buffer)
{
ssize_t result = read(fdin, buffer, BOOKZ_LENGTH);
return result;
}
static ssize_t
display_line(int fdin, int fdout)
{
char line[BOOKZ_LENGTH+2];
ssize_t result = get_line(fdin, line);
if (resu... | 0 |
#include <pthread.h>
char valor;
int ocorrencias;
}simbolo;
pthread_mutex_t mutex;
pthread_cond_t cond_leitor, cond_contador;
FILE *arq_entrada;
simbolo *vetor_contagem_total;
char *buffer[1000];
int count=0, nthreads;
void insereBuffer (char *cadeia) {
static int in = 0;
char *cad;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t vacio,lleno;
int buffer[16], numdatos;
*consumidor(){
struct datos_tipo *datos_proceso;
int a,i,j,p,posicion=0,dato;
for(i=0;i<1000;i++){
pthread_mutex_lock(&mutex);
while(numdatos==0)
pthread_cond_wait(&vacio,&mutex);
dat... | 0 |
#include <pthread.h>
int main(int argc, char const *argv[])
{
int err;
struct timespec tout;
struct tm *tmp;
char buf[64];
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&lock);
printf("mutex is lock!\\n");
clock_gettime(CLOCK_REALTIME, &tout);
tmp = localtime(&tout... | 1 |
#include <pthread.h>
extern char* bloomArray;
extern int k;
extern long int size;
extern pthread_mutex_t* mutexes;
extern long int sections;
extern int section_bytes;
void print(const char* str) {
char c;
int i;
for(i=0; str[i] != 0 ; i++ ) {
c = str[i];
if((c >32) && (c < 127)) {
... | 0 |
#include <pthread.h>
struct
{
char data[10];
int top;
} Stack={{0,0,0,0,0,0,0,0,0,0}, 0};
pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER;
void* Child(void* arg)
{ int i;
char c;
int timeout = 3;
do
{
pthread_mutex_lock(&mutx);
if ( Stack.top > 0 )... | 1 |
#include <pthread.h>
int i = 0;
pthread_mutex_t mtx;
void* adder(){
for(int x = 0; x < 1000000; x++){
pthread_mutex_lock(&mtx);
i++;
pthread_mutex_unlock(&mtx);
}
return 0;
}
void* subtraher(){
for(int x = 0; x < 100000; x++){
pthread_mutex_lock(&mtx);
i--;
p... | 0 |
#include <pthread.h>
char char1[419430400], char2[419430400], char3[419430400];
long max = 419430400, load_div, buffer_size;
struct timeval t;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void file(long max)
{
printf("\\nGenerating file in Memory...\\n");
int i;
for (i = ... | 1 |
#include <pthread.h>
int lastrow,lastcol;
int win=0;
int end=0;
int row =12;
int col= 30;
pthread_cond_t cv;
pthread_mutex_t mu;
int map[20][60];
int getch (void)
{
int ch;
struct termios oldt, newt;
tcgetattr(STDIN_FILENO, &oldt);
memcpy(&newt, &oldt, sizeof(newt));
newt.c_lf... | 0 |
#include <pthread.h>
struct Settings
{
int output_result;
unsigned long long N;
int M;
};
struct Settings read_settings(int argc, char** argv)
{
struct Settings settings;
if (argc < 3)
{
printf("wrong arguments count\\n");
exit(-1);
}
if (strcmp(argv[1], "-p") == 0)
{
settings.ou... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_once = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t prt_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void thread_init()
{
pthread_key_create(&key, ... | 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);
pthrea... | 1 |
#include <pthread.h>
int number;
int phil_number;
double timing;
sem_t *lock;
} arg_struct;
THINKING = 0,
WAITING = 1,
EAT = 2,
TERMINATE = 3
} State;
State *philoStates;
pthread_mutex_t *forks;
pthread_t *philosopher;
pthread_t watcher;
int *fork_array;
void dis... | 0 |
#include <pthread.h>
char *pais[3] = {"Peru", "Bolivia", "Colombia"};
void proceso(int i, int segment_id) {
SEMAFORO *sem;
sem = shmat(segment_id,0,0);
int k;
int c = 0;
for(k=0;k<10;k++)
{
c = sem->count;
waitsem((sem));
c = sem->count;
printf("Entra %s %d",pais[i], (int)g... | 1 |
#include <pthread.h>
int u,r;
int *A;
int *B;
float *C;
float nMax, nMin;
double sum;
pthread_mutex_t m;
} results_t;
results_t m_myResults;
void* do_parallel(void *idx)
{
int i = (int) idx;
int s = i * u + (i > r ? r : i);
int e = s + u + ((i+1) > r ? 0 : 1);
int... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
void *my_func(void *args) {
printf("child %ld start\\n", (long)args);
dbug_off();
dbug_on();
pthread_mutex_lock(&mutex);
printf("child %ld\\n", (long)args);
pthread_mutex_unlock(&mutex);
dbug_off();
pthread_mute... | 1 |
#include <pthread.h>
char salle = 'A';
int nb_A = 0;
int nb_B = 0;
pthread_mutex_t group_A;
pthread_mutex_t group_B;
pthread_mutex_t fifo;
void* f_group_A(void *arg) {
int id = *((int*) arg);
int i;
for (i = 0; i < 5; i++) {
printf("L'étudiant %d (A) veut entrer\\n", id);
pthread_mutex... | 0 |
#include <pthread.h>
int count;
int reader_count;
pthread_mutex_t write_mutex;
pthread_mutex_t read_mutex;
struct thread_data {
int number;
int iterations;
int sleep;
};
void*
writer(void* threadarg)
{
struct thread_data* my_data;
my_data = (struct thread_data*) threadarg;
int loo... | 1 |
#include <pthread.h>
struct ozy_buffer* ozy_input_buffers_head;
struct ozy_buffer* ozy_input_buffers_tail;
sem_t ozy_input_buffer_sem;
int ozy_input_sequence=0;
int ozy_input_buffers=0;
pthread_mutex_t ozy_input_buffer_mutex;
struct ozy_buffer* ozy_free_buffers_head;
struct ozy_buff... | 0 |
#include <pthread.h>
int mediafirefs_opendir(const char *path, struct fuse_file_info *file_info)
{
printf("FUNCTION: opendir. path: %s\\n", path);
(void)path;
(void)file_info;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pthread_mut... | 1 |
#include <pthread.h>
int in = 0;
int out = 0;
int buff[10] = {0,0,0,0,0,0,0,0,0,0};
sem_t empty_sem;
sem_t full_sem;
pthread_mutex_t mutex;
void print()
{
int i;
for(i = 0; i < 10; i++)
printf("%d ", buff[i]);
printf("\\n");
}
void *produce(void *num)
{
while(1)
{
sem_wait(&emp... | 0 |
#include <pthread.h>
int clk_t_1 = 0,clk_t_2 = 0,clk_t_3 = 0;
int sender = 1;
pthread_mutex_t var;
void *increament1(void *interval)
{
int *interval1 = (int *)interval;
while(1)
{
clk_t_1 += *interval1;
printf("\\nclk1 : %d",clk_t_1);
sleep(3);
}
}
void *increament2(void *interval)
... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t not_empty, not_full;
int cokes = 5;
void* thread_function(void* function);
void refill_coke(void);
void consume_coke(void);
int main(int argc, const char * argv[]) {
int i;
pthread_t producers[2];
pthread_t consumers... | 0 |
#include <pthread.h>
int nitems;
struct {
pthread_mutex_t mutex;
int buffer[1000000];
int nput;
int nval;
} shared = { PTHREAD_MUTEX_INITIALIZER };
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
} ready = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t fill;
int counter;
int* buffer;
int size;
void* producer(void*);
void* consumer(void*);
void initialize_variables();
void insert(void);
void remove_item(void);
int main(int argc, char *arg... | 0 |
#include <pthread.h>
struct kt_for_t;
struct kt_for_t *t;
long i;
} ktf_worker_t;
int n_threads;
long n;
ktf_worker_t *w;
void (*func)(void*,long,int);
void *data;
} kt_for_t;
static inline long steal_work(kt_for_t *t)
{
int i, min_i = -1;
long k, min = LONG_MAX;
for (i = 0; i < t... | 1 |
#include <pthread.h>
int how_much_are_ready;
char tipo_de_velocidade;
int d, n;
int **pista_de_corrida;
pthread_mutex_t start=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t launch_condition;
pthread_mutex_t *coordenador_de_acesso_a_estrada;
int plano;
int subida;
int descida;
} vel;
void help(cha... | 0 |
#include <pthread.h>
{
pthread_mutex_t mut;
pthread_cond_t inserimento[2][2][3];
int coda[2][2][3];
int temperatura;
int n_piastrelle[2];
}monitor;
monitor m;
{
int id;
int t;
int qta;
int tipo;
int temperatura;
}lot;
lot new_lot(int id)
{
lot s;
s.id = id;
s.t= rand()%10;
s.qta =... | 1 |
#include <pthread.h>
static pthread_mutex_t list_mutex;
{
int len;
int seqid;
struct _data_t* next;
void* data;
}data_t;
{
data_t* first;
data_t* tail;
int count;
int seqid;
}list_t;
list_t list_cb;
void list_tool_init(void)
{
pthread_mutex_init(&list_mutex... | 0 |
#include <pthread.h>
void *allocate_medium(size_t size)
{
void *block;
pthread_mutex_lock(&g_global_lock);
if (g_book_keeper.medium.head == 0)
{
g_book_keeper.medium.head = allocate_new_zone(MEDIUM_MAX);
divide_zone((void*)&(g_book_keeper.medium.head),
(void*)&(g_book_keeper.medium.ta... | 1 |
#include <pthread.h>
static int data = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_m = PTHREAD_COND_INITIALIZER;
static pthread_cond_t cond_j = PTHREAD_COND_INITIALIZER;
static int is_prime(int data)
{
int i;
for (i = 2; i < data / 2; i++) {
i... | 0 |
#include <pthread.h>
int ca = 0;
int ce = 0;
int ci = 0;
int co = 0;
int cu = 0;
int c;
FILE * fp;
pthread_t h[3];
pthread_mutex_t candl;
pthread_mutex_t cande;
int cuentaLineas();
void contador(void * ptr);
int main(int argc, char **argv){
int i;
int lin = 0;
char *nomarch;
c... | 1 |
#include <pthread.h>
struct queue_node_s *next;
struct queue_node_s *prev;
char c;
} queue_node_t;
struct queue_node_s *front;
struct queue_node_s *back;
pthread_mutex_t lock;
} queue_t;
void *producer_routine(void *arg);
void *consumer_routine(void *arg);
long g_num_prod;
pt... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int putters;
int getters;
int putwaiters;
int getwaiters;
pthread_cond_t putable;
pthread_cond_t getable;
} Lock;
static Lock lock;
extern void rwl_report() {
if (lock.putters+lock.getters+lock.putwaiters>1)
LOG("report(): putters=%d gett... | 1 |
#include <pthread.h>
inline void room_set_id(struct room_t *target, unsigned id)
{
target->rm_id = id;
}
inline size_t room_mem_count(struct room_t *target)
{
return target->rm_mem_count;
}
static size_t check_if_member(struct room_t *target, struct client_t *victim)
{
size_t i = 0;
while... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *threadCount1();
void *threadCount2();
int count = 0;
int main(int argc, char *argv[])
{
pthread_t thread1, thread2;
int i;
pthread_creat... | 1 |
#include <pthread.h>
static int counter = 0;
static pthread_mutex_t counter_mutex;
static void *thread_foo(void *args)
{
int i = 0;
for(i = 0; i < 5; i++)
{
pthread_mutex_lock(&counter_mutex);
{
counter = counter + 1;
printf("foo: counter is %d... | 0 |
#include <pthread.h>
void * threadPartialSum(void * args);
double globalSum;
int numberOfThreads;
long length;
float * myArray;
pthread_mutex_t updateSumLock;
int main(int argc, char* argv[]) {
long i;
pthread_t * threadHandles;
int errorCode;
double seqSum;
long startTime, endTime,... | 1 |
#include <pthread.h>
struct _matrix {
unsigned int size;
unsigned int elements[6][6];
};
static void matrix_print(struct _matrix *m)
{
int i, j;
printf(" \\r\\n Master : Linux : Printing results \\r\\n");
for (i = 0; i < m->size; ++i) {
for (j = 0; j < m->size; ++j)
printf(" %d ", ... | 0 |
#include <pthread.h>
static pthread_mutex_t perf_mutex = PTHREAD_MUTEX_INITIALIZER;
static FILE *perf_file;
void perf_map_open(void)
{
char filename[32];
pid_t pid;
pid = getpid();
sprintf(filename, "/tmp/perf-%d.map", pid);
perf_file = fopen(filename, "w");
if (!perf_file)
die("fopen"... | 1 |
#include <pthread.h>
int hashCount = 0,currentH = 0,pasCount = 0;
char **hashes, **passes;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
int main(int argc, char *argv[]){
FILE *fp, *fp2;
int threads, x;
hashes = malloc(20000 * sizeof(char*... | 0 |
#include <pthread.h>
int count = 0;
int in = 0;
int out = 0;
int buffer [20];
pthread_mutex_t mutex;
pthread_t tid;
pthread_cond_t full;
pthread_cond_t empty;
int memory_size = 0;
int free_memory = 32;
int sleep_time = 5;
int allocate(){
int item = free_memory;
pthread_mutex_lock(&mute... | 1 |
#include <pthread.h>
int chopstick[5] = {0,0,0,0,0};
int state[5];
pthread_cond_t chopstic_cond[5] = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
void pick_chopstick(int id)
{
pthread_mutex_lock(&mutex_lock);
if(state[id] == 1 && chopstick[id]==0){
... | 0 |
#include <pthread.h>
int value = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cvar = PTHREAD_COND_INITIALIZER;
void* alarm_thr(void* data)
{
int new_value;
int old_value = 0;
while(1)
{
pthread_mutex_lock(&mutex);
while(value == old_value) pthread_cond_wait... | 1 |
#include <pthread.h>
struct shared_mem{
bool flag;
int sender;
int receiver;
int clients;
};
int shmid;
struct shared_mem* shm;
pthread_t *reader_threads,*writer_threads;
pthread_cond_t *write_cond,*read_cond;
pthread_mutex_t *write_mutex,*read_mutex;
void Error(char *msg){
perror("Error ... | 0 |
#include <pthread.h>
struct data {
int *Tab1;
int *Tab2;
int i;
};
pthread_mutex_t verrou = PTHREAD_MUTEX_INITIALIZER;
void * Mul(void * par){
pthread_t moi =pthread_self();
int *res=(int *)malloc(sizeof(int));
struct data *mon_D1 = (struct data*)par;
*res=(*mon_D1)... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i < 10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
printf("inc_count(): thr... | 0 |
#include <pthread.h>
void *fhilo1();
void *fhilo2();
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char **argv)
{
pthread_t hilo1,hilo2;
printf("inicio main()\\n");
pthread_mutex_lock(&m2);
pthread_create(&hilo1,0,fhilo1,0... | 1 |
#include <pthread.h>
pthread_mutex_t x,wsem;
pthread_t tid;
int readcount;
void intialize()
{
pthread_mutex_init(&x,0);
pthread_mutex_init(&wsem,0);
readcount=0;
}
void * reader (void * param)
{
int waittime;
waittime = rand() % 5;
printf("\\nReader is trying to enter");... | 0 |
#include <pthread.h>
int source[30];
int minBound[8];
int maxBound[8];
int channel[8];
int th_id = 0;
pthread_mutex_t mid;
pthread_mutex_t ms[8];
void sort (int x, int y)
{
int aux = 0;
for (int i = x; i < y; i++)
{
for (int j = i; j < y; j++)
{
if (source[i] > source[j... | 1 |
#include <pthread.h>
pthread_mutex_t mutex[5];
void* dine(void* arg)
{
int num = (int)arg;
int left, right;
if(num < 4)
{
right = num;
left = num+1;
}
else if(num == 4)
{
right = 0;
left = num;
}
while(1)
{
pthr... | 0 |
#include <pthread.h>
int dimension;
double **matrix;
int *bestTour;
int *currentTour;
int *nextTour;
double temperature;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void printTour(int *tour)
{
int i;
printf("TOUR: ");
for (i = 0; i < dimension; i++)
... | 1 |
#include <pthread.h>
int head_index = 0;
int tail_index = 0;
int hw_buffer[1000];
pthread_t p1, p2, p3;
pthread_t k1, k2, k3;
pthread_mutex_t p_lock;
pthread_mutex_t k_lock;
int get_zufallszahl(int max_randomnummer){
int randomnummer = rand() % max_randomnummer + 1;
return randomnummer;
... | 0 |
#include <pthread.h>
{
void *(*process) (void *arg);
void *arg;
struct worker *next;
} CThread_worker;
{
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker *queue_head;
int shutdown;
pthread_t *threadid;
int max_thread_num;
int ... | 1 |
#include <pthread.h>
struct Data {
int count;
pthread_mutex_t lock;
int number;
};
static struct Data *data = 0;
struct Data *data_alloc( void ) {
struct Data *data;
if ( (data = malloc( sizeof( struct Data ) )) != 0 ) {
data->count = 1;
if ( pthread_mutex_init( &data->l... | 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>
int count_par = 0;
int child_arr[15] = {0};
int child_time_arr[15];
int count = 0;
pthread_mutex_t mutex, mut_write;
void getChild(){
printf("В комнате находятся дети: ");
for(int i=0;i<15;i++)
if(child_arr[i]!=0){
printf("%i ",i);
}
printf("\\n");
}
void... | 0 |
#include <pthread.h>
int count = 0;
double finalresult=0.0;
pthread_mutex_t count_mutex;
pthread_cond_t count_condvar;
void *sub1(void *t)
{
int i;
long tid = (long)t;
double myresult=0.0;
sleep(1);
pthread_mutex_lock(&count_mutex);
printf("sub1: thread=%ld going into wait. count=%d\... | 1 |
#include <pthread.h>
static char *gWorkloadPathArray[100];
static unsigned short int gUniqueWorkloadPaths = 0;
static pthread_mutex_t counter_mutex;
static int counter = 0;
static int mode = WORKLOAD_SEQ;
int workload_init(const char *workload_path)
{
int i = 0;
char temp_buf[256];
FILE ... | 0 |
#include <pthread.h>
pthread_mutex_t theMutex;
pthread_cond_t condProducer, condConsumer;
int buffer [1000];
int buffer_top = 0;
void* producerCode(void* ptr) {
srand(time(0));
int i,rand_num;
for(i = 1; i <= 10000000; i++) {
pthread_mutex_lock(&theMutex);
while(buffer_top... | 1 |
#include <pthread.h>
int state[5];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t s[5] = PTHREAD_MUTEX_INITIALIZER;
void put_forks(int);
void* philosopher(int*);
void take_forks(int);
void test(int);
void think(int i){
printf("philosopher %d is thinking\\n",i);
sleep(1... | 0 |
#include <pthread.h>
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
{
int value;
int flag;
}matrix;
void* function1(int *x)
{
*x=1;
pthread_exit(0);
}
void* function2(int array[2] )
{
pthread_mutex_lock(&mutex);
if (array[0]<array[1])
{
array[0]=0;
... | 1 |
#include <pthread.h>
{
void *(*process) (void *arg);
void *arg;
struct worker *next;
} CThread_worker;
{
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker *queue_head;
int shutdown;
pthread_t *threadid;
int max_thread_num;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond_leitor;
pthread_cond_t cond_escritor;
int escritores = 0;
int leitores = 0;
{
int contador;
int idThread;
}Arquivo;
Arquivo arquivo;
void inicializa_leitor(){
pthread_mutex_lock(&mutex);
while(escritores > 0){
pthre... | 1 |
#include <pthread.h>
int available[3];
int maximum[5][3];
int allocation[5][3];
int need[5][3];
pthread_mutex_t mutexavail;
pthread_mutex_t mutexalloc;
pthread_mutex_t mutexneed;
int request_resources(int customer_num, int request[]);
int release_resources(int customer_num, int request[]);... | 0 |
#include <pthread.h>
{
long int from;
long int to;
} arg_t;
long double pi_x = 0.0;
pthread_mutex_t lock_x;
void* crunch(void *ptr)
{
int n;
long double pi = 0.0;
arg_t *args = (arg_t*)ptr;
for (n = args->from; n < args->to; n++)
pi = pi + (double)(1 - ((((int)(n)) & 1) << ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int cant = 0;
void* entrada(void *arg) {
int i, r, ent;
printf("Se abrieron las puertas.\\n");
for(i = 0; i < 50; i++) {
pthread_mutex_lock(&mutex);
r = (rand() % 10) + 1;
ent = (rand(... | 0 |
#include <pthread.h>
struct pp_thread_info {
int *msgcount;
char *msg;
int modval;
pthread_mutex_t *mutex;
pthread_cond_t *cv;
};
void *
pp_thread(void *arg)
{
struct pp_thread_info *infop;
int c;
infop = arg;
while (1) {
pthread_mutex_lock(infop-... | 1 |
#include <pthread.h>
pthread_t phil[5];
pthread_mutex_t chops[5];
void* func(int n)
{
int p= (n)%5;
while(1){
printf("\\n Philosopher %d is thinking", n);
pthread_mutex_lock(&chops[n-1]);
pthread_mutex_lock(&chops[p]);
printf("\\n Philosopher %d is eati... | 0 |
#include <pthread.h>
int a[1000];
int global_index = 0;
int sum = 0;
pthread_mutex_t mutex1;
void *slave(void *ignored)
{
int local_index, partial_sum = 0;
do{
pthread_mutex_lock(&mutex1);
local_index = global_index;
global_index++;
pthread_mutex_unlock(&mutex1);
if(local_in... | 1 |
#include <pthread.h>
int count = 0;
int tnums[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_cv = PTHREAD_COND_INITIALIZER;
void *change_count(void *idp){
int i;
int my_id = *(int *)idp;
int start = my_id;
int stop = 60 + start;
for (i=start; i < stop; i++) {
p... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
pthread... | 1 |
#include <pthread.h>
static struct dlm_lksb lksb;
static int use_threads = 0;
static int quiet = 0;
static pthread_cond_t cond;
static pthread_mutex_t mutex;
static int ast_called = 0;
static int modetonum(char *modestr)
{
int mode = LKM_EXMODE;
if (strncasecmp(modestr, "NL", 2) == ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.