text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct header_t {
size_t size;
unsigned is_free;
struct header_t *next;
};
struct header_t *head = 0, *tail = 0;
pthread_mutex_t global_malloc_lock;
struct header_t *get_free_block(size_t size)
{
struct header_t *curr = head;
while(curr) {
if (curr->is_free && cu... | 1 |
#include <pthread.h>
volatile int val = 0;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *test_thread(void*data)
{
pthread_mutex_lock(&mutex);
val = 1;
pthread_mutex_unlock(&mutex);
pthread_cond_broadcast(&cond);
return 0;
}
int main()
... | 0 |
#include <pthread.h>
int buff[10];
int buff_index;
pthread_mutex_t buff_mutex;
sem_t buff_sem_full;
sem_t buff_sem_empty;
int push_front(int val)
{
if(buff_index < 10) {
buff[buff_index++] = val;
return 0;
} else
return -1;
}
int pop_front()
{
if(buff_index > 0)
return buff[--buff_i... | 1 |
#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) {... | 0 |
#include <pthread.h>
void search_by_thread( void* ptr);
{
char* start_ptr;
char* end_ptr;
int num;
char match_str[16];
} thread_data;
pthread_mutex_t mutex;
int main()
{
FILE* fRead;
char line[16];
char search_str[16];
char* array_ptr;
char* temp_ptr;
int i = 0;
int j = 0;... | 1 |
#include <pthread.h>
static int si_init_flag = 0;
static int s_conf_fd = -1;
static struct sockaddr_un s_conf_addr ;
static int s_buf_index = 0;
static char s_conf_buf[4][(16384)];
static pthread_mutex_t s_atomic;
static char CONF_LOCAL_NAME[16] = "/tmp/cfgClient";
inline int cfgSockSetLocal... | 0 |
#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 < 5; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count < 7) {
... | 1 |
#include <pthread.h>
int somme_alea;
int cpt;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_cpt = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_cpt = PTHREAD_COND_INITIALIZER;
void* thread_rand(void * arg){
int random_val = (int) ((float) 10 * rand()... | 0 |
#include <pthread.h>
double intervalWidth, mypi = 0.0;
int *MyIntervals;
int MyRank, Numprocs, Root = 0, MyCount = 0;
pthread_mutex_t mypi_mutex = PTHREAD_MUTEX_INITIALIZER;
void * MyPartOfCalc(int myID)
{
int myInterval;
double myIntervalMidPoint;
double myArea = 0.0, result;
myIntervalMidP... | 1 |
#include <pthread.h>
int num = 0;
pthread_mutex_t mutex;
void* function1()
{
printf("Hello from function 1!\\n");
for (size_t i = 0; i < 1000000; i++) {
pthread_mutex_lock(&mutex);
num++;
pthread_mutex_unlock(&mutex);
}
return 0;
}
void* function2()
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t mainThreadReady;
pthread_cond_t childThreadReady;
void *new_start_routine( void * arg ) {
for (int i = 0; i < 10; i++) {
if (i != 10 - 1) pthread_mutex_lock(&mutex);
printf("CHILD\\n");
pthread_cond_signal(&childThreadReady);
... | 1 |
#include <pthread.h>
void *func(int n);
pthread_t philosopher[15];
pthread_mutex_t chopstick[15];
int N;
int main()
{
int i,k;
void *exit_status;
printf("\\nenter the no of philosohers :");
scanf("%d",&N);
for(i=0;i<N;i++)
{
k=pthread_mutex_init(&chopstick[i],0);
if(k==-... | 0 |
#include <pthread.h>
void *hilo1(void *p);
void *hilo2(void *p);
int acabar;
char cadena[50];
pthread_mutex_t muti = PTHREAD_MUTEX_INITIALIZER;
int main(void)
{
pthread_t th1;
pthread_t th2;
int i;
int res;
void *result;
printf("main: Comenzando la primera prueba, sin mute... | 1 |
#include <pthread.h>
struct thread_info {
pthread_t thread_id;
int *forks;
pthread_mutex_t *forkMutexs;
int philoId;
};
int forks[4] = {0,1,2,3};
pthread_mutex_t forkMutexs[4] =
{ PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER };... | 0 |
#include <pthread.h>
pthread_mutex_t buffer_mutex;
int fill = 0;
char buffer[100][50];
char *fetch(char *link) {
int fd = open(link, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "failed to open file: %s", link);
return 0;
}
int size = lseek(fd, 0, 2);
assert(size >= 0);
char *buf = Mall... | 1 |
#include <pthread.h>
pthread_attr_t attr=PTHREAD_INITIALZER;
pthread_cond_t even,odd;
pthread_mutex_t lock;
int i=0;
void func_attributes(void )
{
pthread_attr_setdetachstate(&attr,PTHREAD_JOINABLE);
pthread_cond_init(&even);
pthread_cond_init(&odd);
pthread_mutex_init(&lock,0);
}
void even(voi... | 0 |
#include <pthread.h>
void accueil()
{
int choix;
printf("Tripote et Mascagne, bonjour : \\n \\n");
printf("Que pouvons nous faire pour vous : \\n");
printf(" 1: Des vis \\n");
printf(" 2: Des étagères \\n");
printf(" 3: Des chaises \\n");
printf(" 4: Des armoires \\n");
printf(" 5: Des p... | 1 |
#include <pthread.h>
const int capacity = 100;
const int round_max = 50000;
int capacity;
int size;
item_t* space;
pthread_mutex_t lock;
pthread_cond_t some_space;
pthread_cond_t some_items;
} storage_t;
void* produce(void* param) {
storage_t* storage = (storage_t*) param;
... | 0 |
#include <pthread.h>
int g = 0;
pthread_mutex_t mutexsum;
void *myThreadFun(void *vargp)
{
int i = (int)vargp;
pthread_mutex_lock (&mutexsum);
printf("%i Global: %d\\n", i, ++g);
pthread_mutex_unlock (&mutexsum);
}
int threadCount(int num_threads)
{
int i;
pthread_t ti... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
{
int lb;
int ub;
int arr[100];
}param;
int part(int a[],int lb,int ub)
{
int c,up=lb,down=ub;
int x=a[lb];
while(up<down)
{
while(a[up]<=x && up<=down)
up++;
while(a[down]>x)
down--;
if(up<down)
{
c=a[up];
a[up]=a[down];
... | 0 |
#include <pthread.h>
pthread_mutex_t kran;
pthread_mutex_t kufle;
int l_kl, l_kf, l_kr;
void * watek_klient (void * arg);
int kufle_pobrane = 0;
int main(){
pthread_t *tab_klient;
int *tab_klient_id;
int i;
printf("\\nLiczba klientow: "); scanf("%d", &l_kl);
printf("%d\\n",l_kl);
... | 1 |
#include <pthread.h>
double start_time;
double end_time;
double cur_time;
static enum {
SIM_START,
SIM_INITIALIZED,
SIM_IN_PROGRESS,
SIM_TERMINATED,
} state;
static struct cal *cal;
static bool new_element_added;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
size_t get_head(vo... | 0 |
#include <pthread.h>
int q[4];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 4)
... | 1 |
#include <pthread.h>extern void __VERIFIER_error();
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[400];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)... | 0 |
#include <pthread.h>
struct kufle {
pthread_mutex_t mut_kuff;
int * tab_kufli;
int l_kf;
} kuf;
pthread_mutex_t mut_kran;
void * watek_klient (void * arg_wsk){
int moj_id = * ((int *)arg_wsk);
int a, i, j, kufel, result;
int wybralem = 0;
a = 0;
int ile_musze_wypic = 2;
printf(... | 1 |
#include <pthread.h>
int estado [(5)];
pthread_mutex_t mutex;
pthread_mutex_t mux_filo [(5)];
pthread_t jantar[(5)];
void * filosofo ( void * param );
void pegar_hashi ( int id_filosofo );
void devolver_hashi ( int id_filosofo );
void intencao ( int id_filosofo );
void comer ( int id_filosofo );
... | 0 |
#include <pthread.h>
int total = 0;
pthread_mutex_t mutexTotal = PTHREAD_MUTEX_INITIALIZER;
pthread_t * hilos;
void * suma (void * arg);
clock_t begin, end;
double time_spent;
int fragment;
int * numberArray;
int inicio;
int fin;
}info;
int main(int argc, char const *argv[])
{
FILE *myFil... | 1 |
#include <pthread.h>
void throw_one();
void throw_two();
void determine_round_winner();
void determine_winner();
int* p_one_ptr;
int* p_two_ptr;
const char *rps[3];
int player_one_score;
int player_two_score;
pthread_t tid[2];
int choice[2];
int command[2];
pthread_mutex_t lock[2];
pthrea... | 0 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mut;
int number=0,i;
void *thread1()
{
printf("thread1:i'm thread 1\\n");
for(i=0;i<10;i++)
{
printf("threead1:number=%d\\n",number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&mut);
sleep(2);
}
printf("threa... | 1 |
#include <pthread.h>
int NUMBER_OF_PRODUCTS;
pthread_mutex_t lock;
void increase_products(int i){
pthread_mutex_lock(&lock);
if(NUMBER_OF_PRODUCTS < 10){
NUMBER_OF_PRODUCTS+=1;
}
else
printf("Production limit reached.\\n\\n");
pthread_mutex_unlock(&lock);
sleep(rand()%3+1);
ret... | 0 |
#include <pthread.h>
sem_t semEste;
sem_t semOeste;
pthread_mutex_t mutexEste;
pthread_mutex_t mutexOeste;
void* cruzarEste(void*);
void* cruzarOeste(void*);
int main() {
sem_init(&semEste, 0, 0);
sem_init(&semOeste, 0, 0);
srand((int) time(0));
pthread_t* threads = (pthread_t*) malloc(... | 1 |
#include <pthread.h>
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *doexec (void *arg);
void
init (void)
{
pthread_t thr;
pthread_attr_t thread_attr;
if (pthread_attr_init(&thread_attr))
do { fprintf(st... | 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 = (struct foo*)malloc(sizeof(struct f... | 1 |
#include <pthread.h>
void station_init(struct station *station){
station->waiting_passenger_count=0;
station->available_seat_count=0;
station->boarded_passenger_count=0;
station->max_allowed_passengers=0;
station->train_left=0;
pthread_mutex_init(&station->station_key, 0);
pthread... | 0 |
#include <pthread.h>
int use_mutex;
pthread_mutex_t mutex;
volatile int global = 0;
void *compute(void *arg)
{
int i;
for (i = 0; i < 100 * 100 * 100; i++) {
if (use_mutex) {
pthread_mutex_lock(&mutex);
global++;
... | 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;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
pthread_mutex_unlock(&my);
a =... | 0 |
#include <pthread.h>
int chop = 5;
struct timespec timeout;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lockp = PTHREAD_MUTEX_INITIALIZER;
void *pcon(void *num)
{
int flag = 1;
while(1)
{
flag =(flag ? 0:1);
if(!flag)
... | 1 |
#include <pthread.h>
int A = 0;
int B = 0;
pthread_mutex_t lock_A = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_B = PTHREAD_MUTEX_INITIALIZER;
void * thread_a(void * para)
{
int i = 0;
srandom(time(0L));
while(i < 100)
{
i++;
usleep(random()%100);
pthread_mutex_lock(&lock_A);
... | 0 |
#include <pthread.h>
static const unsigned int NUM_PHILOSOPHERS = 5;
static const unsigned int NUM_CHOPSTICKS = 5;
static int chopsticks[5];
static pthread_mutex_t mutex[5];
static pthread_t philosophers[5];
int isdead(){
int i;
for (i = 0; i < NUM_CHOPSTICKS; i++){
if (chopsticks[i]... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void multiThreadCopy(char*, char*);
void sectionCopy(void**);
int main(int argc, char* argv[])
{
if (argc < 3)
{
printf("Expected input and output files as parameters\\n");
return 0;
}
multiThreadCopy(argv[1]... | 0 |
#include <pthread.h>
void kern_mutex_init(kern_mutex_t* mtx)
{
pthread_mutex_init(mtx, 0);
}
void kern_mutex_destroy(kern_mutex_t* mtx)
{
pthread_mutex_destroy(mtx);
}
void kern_mutex_lock(kern_mutex_t* mtx)
{
pthread_mutex_lock(mtx);
}
void kern_mutex_unlock(kern_mutex_t *mtx)
{
pt... | 1 |
#include <pthread.h>
{
char buff[100];
char end;
int numthr;
int wtime;
sem_t semaphore_io;
sem_t semaphore_caps;
}
shared_data;
int tsrandom (void);
void * io (void *);
void * caps (void *);
int main (int argc, char * argv[])
{
pthread_t tids[200];
int i, e;
... | 0 |
#include <pthread.h>
void *producer(void *arg);
void *consumer(void *arg);
int buffer_num = 0;
pthread_mutex_t mutex;
int running = 1;
int main(void) {
pthread_t producer_pt;
pthread_t consumer_pt;
pthread_mutex_init(&mutex, 0);
pthread_create(&producer_pt, 0, (void*)producer, 0);
pt... | 1 |
#include <pthread.h>
extern int errno;
int gridsize = 0;
int grid[10][10];
int threads_left;
pthread_mutex_t lock;
time_t start_t, end_t;
void print_grid(int grid[10][10], int gridsize)
{
int i, j;
for (i = 0; i < gridsize; i++)
{
for (j = 0; j < gridsize; j++)
fprintf(stdout, "%d\... | 0 |
#include <pthread.h>
int g = 0;
pthread_mutex_t mutexsum;
void *myThreadFun(void *vargp)
{
int i = (int)vargp;
pthread_mutex_lock (&mutexsum);
printf("%i Global: %d\\n", i, ++g);
pthread_mutex_unlock (&mutexsum);
}
int threadCount(int num_threads)
{
int i;
pthread_t ti... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int buffer[5] = {0};
sem_t empty;
sem_t full;
void *producer(void *arg)
{
int in = 0;
int* arr = (int*) arg;
for (int i = 0; i < 10; i++) {
sem_wait(&empty);
pthread_mutex_lock(&mutex);
buffer[in] = arr[i];
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int fd_gprs=0;
extern struct state *g_state;
int xfer_init()
{
if((fd_gprs=open_com_port("/dev/ttySP2"))<0)
{
perror("open_port lcd error");
return -1;
}
if(set_opt(fd_gprs,115200,8,'N',1)<0)
{
perror(" set_opt cap error");
close(fd_gprs);
... | 1 |
#include <pthread.h>
char buf[4];
int occupied;
int nextin, nextout;
pthread_mutex_t mutex;
pthread_cond_t more;
pthread_cond_t less;
} buffer_t;
buffer_t buffer;
void * producer(void *);
void * consumer(void *);
pthread_t tid[2];
main( int argc, char *argv[] )
{
int i;
... | 0 |
#include <pthread.h>
void* mathProf(void* t);
void* csProf(void* t);
void* dean(void* t);
void delay(int);
void shuffle(int*, int);
pthread_mutex_t sherriLock;
int waiting[4];
int inlounge[4];
const char* names[] = {"open", "math prof", "cs prof", "dean"};
int main(){
srand(time(0));... | 1 |
#include <pthread.h>
int SharedVariable = 0;
pthread_mutex_t lock_x;
bool isNumber(char number[])
{
int i = 0;
if (number[0] == '-')
return 0;
for (; number[i] != 0; i++)
{
if (!isdigit(number[i]))
return 0;
}
return 1;
}
void SimpleThread... | 0 |
#include <pthread.h>
pthread_mutex_t djedbozicnjak, K, godisnji;
int br_sobova;
int br_patuljaka;
int semId;
void *Djed_Bozicnjak(void)
{
do{
pthread_mutex_lock(&djedbozicnjak);
pthread_mutex_lock(&K);
if(br_sobova == 10 && br_patuljaka > 0){
pthread_mutex_... | 1 |
#include <pthread.h>
void* ta_helping();
void* stu_listening(void *i);
void srand_sleep();
sem_t *sem_stu;
sem_t *sem_ta;
pthread_mutex_t lock;
int chair[3] = {-1,-1,-1};
int count = 0;
int next_student = 0;
int next_seat = 0;
int student_has_teached;
int main() {
int number_of_stude... | 0 |
#include <pthread.h>
int buffer[1024];
int count=0;
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
pthread_mutex_t mutex3;
pthread_mutex_t mutex4;
void *threadFun1(void *arg)
{
int i;
while(1)
{
pthread_mutex_lock(&mutex1);
pthread_mutex_lock(&mutex2);
printf("Thread 1\\n");
coun... | 1 |
#include <pthread.h>
static pthread_mutex_t *locks;
static void die_with_error(char *message)
{
perror(message);
exit(1);
}
static void radix_tree_init(struct radix_tree *tree, int bits, int radix)
{
if (radix < 1) {
perror("Invalid radix\\n");
return;
}
if (bits < 1) {
perror("I... | 0 |
#include <pthread.h>
static char g_log_filename[256];
static FILE *g_log_fp = 0;
static int g_log_level = 0;
static pthread_mutex_t g_log_lock;
static char *g_log_level_str[] = {
"EMERG",
"ALERT",
"CRIT",
"ERR",
"WARNING",
"NOTICE",
"INFO",
"DEBUG",
0
};
stat... | 1 |
#include <pthread.h>
pthread_t pr[4];
pthread_mutex_t se[4];
pthread_mutex_t seEnd[4];
pthread_mutex_t seIndex;
int pIndex = 0;
int fIndex = 0;
int mIndex = 15;
int files[15] = {1,2,3,1,2,3,1,2,3,1,2,3,1,2,3};
int lockTimes[4] = {0,3,4,5};
int file;
int z = 0;
void * print(void *arg){
pt... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *another(void *arg) {
printf("In child thread, lock the mutex\\n");
pthread_mutex_lock(&mutex);
sleep(5);
pthread_mutex_unlock(&mutex);
}
int main()
{
pthread_mutex_init(&mutex, 0);
pthread_t tid;
pthread_create(&... | 1 |
#include <pthread.h>
struct q_log_ctx {
int ql_init;
int ql_fd;
char *ql_file;
int ql_level;
pthread_mutex_t ql_mtx;
};
static struct q_log_ctx log_ctx = {
.ql_init = 0,
.ql_fd = -1,
.ql_file = Q_LOG_FILE,
.ql_level = Q_LOG_LEVEL,
.ql_mtx = PTHREAD_MUTEX_INITIALIZER,
};
static char *lv... | 0 |
#include <pthread.h>
int *array;
int length, count;
pthread_t *ids;
int length_per_thread;
pthread_mutex_t ex = PTHREAD_MUTEX_INITIALIZER;
void * count3s_thread(void *id){
int i;
int start = length_per_thread*(int)id;
int end = start + length_per_thread;
for(i=start; i < end; i++){
if(ar... | 1 |
#include <pthread.h>
int threads=1024;
int threads_max=100;
int counter1=0;
int counter1_start=180000;
int counter1_warn=200000;
int counter_de_nr=0;
int koniec=0;
int sleep_time=1000;
int manager_cmd=0;
int key=0;
pthread_cond_t warunek1 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex1 = P... | 0 |
#include <pthread.h>
void *referee(void*);
void *player(void*);
void print_board();
int check_winner();
int check_horizonatal_tiles();
int check_diagonal_tiles();
int board_filled();
char board[6][7];
int play_game,game_finished;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t... | 1 |
#include <pthread.h>
struct foo* fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
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->... | 0 |
#include <pthread.h>
pthread_mutex_t semaforo;
static char *path_log;
void iniciarYEstablecerRutaArchivoLog(char *ruta)
{
path_log = strdup(ruta);
pthread_mutex_init(&semaforo,0);
}
void borrarSemaforoLogs()
{
pthread_mutex_destroy(&semaforo);
}
void logDebug(char *mensaje)
{
pthread_mutex... | 1 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
struct tree {
long data;
struct tree *left;
struct tree *right;
};
struct tree *root = 0;
struct tree *newnode(long data) {
struct tree *newnode = (struct tree*)malloc(sizeof(struct tree));
newnode->data = dat... | 0 |
#include <pthread.h>
struct job {
int id;
struct job *next;
};
void process_job (struct job *one_job)
{
printf("Thread_%d is process job %d\\n", (int)pthread_self (), one_job->id);
}
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_count;
void *thread_func... | 1 |
#include <pthread.h>
pthread_t stu_thread[2];
pthread_mutex_t mutex_lock;
int number = 0;
void * studentA()
{
int i = 0;
for(i = 0; i < 5; i++)
{
pthread_mutex_lock(&mutex_lock);
number++;
printf("studentA has finished the work one time\\n");
pthread_... | 0 |
#include <pthread.h>
FILE *fp;
struct userinfo
{
char username[100];
int socket;
}u[1000];
pthread_t thread;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char buffer[256],user[100],str[100],pass[30];
struct sockaddr_in serv_addr, cli_addr;
int n,nu=1,i;
void error(char *msg)
{
perror... | 1 |
#include <pthread.h>
void *productor(void *);
void *consumidor(void *);
void yield();
struct buffer_sync_s {
int buffer[16 +1];
int pr,pw;
pthread_mutex_t mutex;
sem_t vacios;
sem_t llenos;
} buffer_sync;
int main(int argc, char *argv[]) {
pt... | 0 |
#include <pthread.h>
struct tex_circle tex_circles[TEX_CIRCLES_MAX];
unsigned int tex_circle_draw_order[TEX_CIRCLES_MAX];
struct tex_circle tex_ripples[TEX_CIRCLES_MAX];
int sizeof_tex_circles_e = sizeof(tex_circles)/sizeof(tex_circles[0]);
int sizeof_tex_circles = sizeof(tex_circles);
void step... | 1 |
#include <pthread.h>
int buffer[100] = { 0 };
int front = 0, rear = -1;
int size = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t empty_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t full_cond = PTHREAD_COND_INITIALIZER;
bool producer_wait = 0;
bool consumer_wait = 0;
vo... | 0 |
#include <pthread.h>
struct account{
int balance;
int credits;
int debits;
pthread_mutex_t lock;
};
struct account accounts[10];
void * transactions(void * args){
int i,v;
int a1,a2;
for(i=0;i<100;i++){
v = (int) random() % 100;
a1 = (int) random() % 10;
w... | 1 |
#include <pthread.h>
int array[] = {1,3,2,4,5,7,6,9,10,11,12,13,0,3,7,8,1,3,5,7,9,2,4,6,8,0,1,2,3,4,5,6,7,8};
int length = sizeof(array)/sizeof(array[0]);
int shared_index = 0;
pthread_mutex_t shared_index_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t shared_index_cv = PTHREAD_COND_INITIALIZ... | 0 |
#include <pthread.h>
pthread_cond_t table_free_cv, sticks_cv[5];
pthread_mutex_t monitor = PTHREAD_MUTEX_INITIALIZER;
int is_eating[5] = {0};
int table_free = 2, sticks[5] = {1, 1, 1, 1, 1};
void print_status ()
{
int i;
for (i=0 ; i<5 ; ++i)
if (is_eating[i])
printf ("jede\\t");... | 1 |
#include <pthread.h>
int memory[(2*320+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top;
int index_malloc(){
int curr_alloc_idx = -1;
pthread_mutex_lock(&m);
if(next_alloc_idx+2-1 > (2*320+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx... | 0 |
#include <pthread.h>
int buffer[10];
pthread_mutex_t mutex;
sem_t emptyCount;
sem_t fillCount;
int produceItem()
{
return rand();
}
void putItemIntoBuffer(int item)
{
int pos;
sem_getvalue(&fillCount, &pos);
buffer[pos] = item;
}
int removeItemFromBuffer()
{
int pos;
s... | 1 |
#include <pthread.h>
int TA_Sleeping;
sem_t semTA;
sem_t chairs;
pthread_mutex_t Helpmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t TAcreated = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t helping = PTHREAD_MUTEX_INITIALIZER;
void helpStudent(){
while(1){
int availableChairs;
sem_getvalu... | 0 |
#include <pthread.h>
pthread_mutex_t mutex[3];
int firstIndex;
int secondIndex;
} Indexes;
Indexes additionalThreadIndexes[3] = {{0, 1}, {2, 0}, {1, 2}};
Indexes mainThreadIndexes[3] = {{2, 0}, {1, 2}, {0, 1}};
void* doIt(void *arg) {
pthread_mutex_lock(&mutex[0]);
pthread_mutex_loc... | 1 |
#include <pthread.h>
int sem_post(sem_t *sem)
{
int result = 0;
if (!sem)
{
result = EINVAL;
}
else if (!pthread_mutex_lock(&sem->mutex))
{
if (++(sem->value) <= 0)
{
pthread_con... | 0 |
#include <pthread.h>
extern unsigned volatile int *lock;
FILE *fileout_pbm_stringsearch;
FILE *fileout_bmh_stringsearch;
FILE *fileout_fft;
FILE* fileout_adpcmencoder;
FILE* filein_adpcmencoder;
volatile int procCounter = 0;
volatile int barrier_in = 0;
volatile int procsFinished = 0;... | 1 |
#include <pthread.h>
struct argumentos{
int *cont;
pthread_mutex_t *mutex;
};
void *incrementa(void *arg){
ARGS *para = (ARGS *) arg;
int *p = para->cont;
pthread_mutex_t *m = para->mutex;
int i;
for(i=0; i<100000; i++){
pthread_mutex_lock(m);
(*p)++;
pthread_mutex_unlock(m);... | 0 |
#include <pthread.h>
int g_sum = 0;
int g_min = 32767;
int g_minX = -1;
int g_minY = -1;
int g_max = INT_MIN;
int g_maxX = -1;
int g_maxY = -1;
pthread_mutex_t lock;
int numWorkers;
double startTime, endTime;
int size, stripSize;
int matrix[10000][10000];
void *Worker(void *);
double readT... | 1 |
#include <pthread.h>
int PBSD_msg_put(
int c,
char *jobid,
int fileopt,
char *msg,
char *extend)
{
int rc = 0;
int sock;
struct tcp_chan *chan = 0;
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
if ((chan = DIS_tcp_setup(sock)) == 0)
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_1;
pthread_mutex_t mutex_2;
void *child1(void *arg)
{
while (1) {
pthread_mutex_lock(&mutex_1);
sleep(3);
pthread_mutex_lock(&mutex_2);
printf("thread 1 get running\\n");
pthread_mutex_unlock(&mutex_2);
... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void* producer(void *ptr) {
int i;
for (i = 1; i <= 10; i++) {
pthread_mutex_lock(&the_mutex);
while (buffer != 0)
pthread_cond_wait(&condp, &the_mutex);
buffer = i;
printf("... | 0 |
#include <pthread.h>
struct node_t {
int length;
char data[80];
struct node_t *next;
pthread_mutex_t mut;
} head;
void* sort_loop(void* param) {
struct node_t *prev, *cur0, *cur1;
int mess;
while (1) {
sleep(5);
mess = 1;
while (mess) {
mess = 0;
prev = ... | 1 |
#include <pthread.h>
static int maxThreads;
static int threadsTotal;
static pthread_mutex_t fileMutex;
static pthread_cond_t fileCond;
void FileAccess(int n)
{
maxThreads = n - 1;
threadsTotal = 0;
pthread_mutex_init(&fileMutex, 0);
pthread_cond_init(&fileCond, 0);
}
void* startAccess(... | 0 |
#include <pthread.h>
pthread_cond_t cond_notFull = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_notEmpty = PTHREAD_COND_INITIALIZER;
pthread_mutex_t bufferFull_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
int maxBufferSize = 1;
int bufferSize = 0;
int... | 1 |
#include <pthread.h>
int max(const int a, const int b)
{
return a > b ? a : b;
}
int largest = 0;
pthread_mutex_t largest_mutex;
void *thread_main(void *arg)
{
int cpu_nr = sched_getcpu();
pthread_mutex_lock(&largest_mutex);
if (cpu_nr > largest)
{
largest = cpu_... | 0 |
#include <pthread.h>
pthread_barrier_t barrier;
pthread_mutex_t consoleMutex;
struct CalculateExpArgs
{
double value;
unsigned int maxNumberOfOperations;
double result;
};
void CalculateExp(struct CalculateExpArgs* args)
{
pthread_mutex_lock(&consoleMutex);
printf("Calcu... | 1 |
#include <pthread.h>
extern pthread_mutex_t global_data_mutex;
void update_humidity_data (int humidity_fd) {
char humidity[6];
float realhumidity;
int read_rc;
lseek(humidity_fd,0,0);
read_rc = read(humidity_fd,humidity,5);
if(0 > read_rc)
{
close(humidity_fd);
global_... | 0 |
#include <pthread.h>
struct Message {
struct Message *next;
};
struct Message *work_queue;
pthread_cond_t queue_ready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t queue_lock = PTHREAD_MUTEX_INITIALIZER;
void process_message( void ) {
struct Message *mp;
while ( 1 ) {
pthread_mutex... | 1 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
{
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
}to_info;
void clock_gettime(int id, struct timespec *tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
t... | 0 |
#include <pthread.h>
static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
static int malloc_trim_count=0;
static void mymalloc_install (void);
static void mymalloc_uninstall (void);
static void (*old_free_hook) (void *, const void *);
static void myfree(void *ptr, const void *caller)
{
... | 1 |
#include <pthread.h>
int printed_lines = 0;
int lines_before[10];
int lines_after[10];
pthread_mutex_t mutex;
pthread_t *threads;
int n;
int activated;
void *send_output(void *arg)
{
int* idx = (int*)arg;
lines_before[*idx] = printed_lines;
int i;
while(!activated... | 0 |
#include <pthread.h>
void *lcthread(void *argv);
int total_lines = 0;
pthread_mutex_t total_line_lock = PTHREAD_MUTEX_INITIALIZER;
main(int argc, char**argv)
{
pthread_t * t = malloc(500);
int index_create;
for(index_create = 1; index_create < argc; index_create++)
{
pthread_create(&t[... | 1 |
#include <pthread.h>
enum {
NUMTHREADS = 3
};
struct bag_t_ {
int threadnum;
int started;
};
static bag_t threadbag[NUMTHREADS + 1];
pthread_mutex_t stop_here = PTHREAD_MUTEX_INITIALIZER;
void *
mythread(void * arg)
{
bag_t * bag = (bag_t *) arg;
assert(bag == &threadbag[bag->th... | 0 |
#include <pthread.h>
const size_t N_THREADS = 20;
pthread_mutex_t mutex;
struct timespec timeout;
int use_timeout;
void *run(void *arg) {
int *argi = (int *) arg;
int my_tidx = *argi;
int retcode;
printf("in child %d: sleeping\\n", my_tidx);
sleep(2);
if (use_timeout) {
while... | 1 |
#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++)... | 0 |
#include <pthread.h>
int status;
int size;
struct freelist* next;
}freelist;
freelist* head = 0;
int allocated = 0;
int
Mem_Init(int sizeOfRegion){
int pagesize = getpagesize();
int initsize = sizeOfRegion;
if(allocated != 0 || sizeOfRegion <= 0){
fprintf(stderr, "ERROR!\\n");
return... | 1 |
#include <pthread.h>
static pthread_mutex_t cook_meal_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cook_meal_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t deliver_meal_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t deliver_meal_cond = PTHREAD_COND_INITIALIZER;
static... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.