text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t gLock;
int val = 10;
void *Print(void *pArg)
{
int id = getpid();
printf("I am the PTHREAD. My PID is %d\\n", id);
pthread_mutex_lock(&gLock);
val += 1;
pthread_mutex_unlock(&gLock);
return 0;
}
int main (int argc, char **argv, char **envp)
{
pthre... | 1 |
#include <pthread.h>
void interface(){
while(1){
pthread_mutex_lock(&mutexEjecuta);
mostrarMenu();
pthread_mutex_unlock(&mutexEjecuta);
scanf("%i",&opcion);
switch(opcion) {
case 1 :
pthread_mutex_lock(&mutexEjecuta);
iniciarPrograma();
break;
case 2:
pth... | 0 |
#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->n... | 1 |
#include <pthread.h>
static int the_msgq;
static pthread_t the_thread;
static pthread_mutex_t the_mutex = PTHREAD_MUTEX_INITIALIZER;
static short must_continue;
int added_sensors[32];
unsigned int sensor_count;
int add_sensor( unsigned int id )
{
int i = 0;
pthread_mutex_lock( &th... | 0 |
#include <pthread.h>
pthread_mutex_t g_qlock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_qready = PTHREAD_COND_INITIALIZER;
int id = 0;
struct message {
int m_msg_id;
};
struct message_queue {
struct message * p_next;
};
struct message_queue workq;
void deal_msg(struct message * ... | 1 |
#include <pthread.h>
void sig_handler_quit (int);
void *find_file (void *arg);
void *dispatch_executer (void *arg);
int files_sent, files_found = 0;
pthread_mutex_t mutex_total_time, retrieved, sent;
int total_time = 0;
int
main (int argc, char **argv)
{
srand (time (0));
pt... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void* thr_fn(void* arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0) {
fprintf(s... | 1 |
#include <pthread.h>
void init_matrix (int **matrix, int fils, int cols) {
int i, j;
for (i = 0; i < fils; i++) {
for (j = 0; j < cols; j++) {
matrix[i][j] = 1;
}
}
}
int **matrix1;
int **matrix2;
int **matrixR;
int matrix1_fils;
int matrix1_cols;
int matrix2_fils;
int matrix2_cols;
... | 0 |
#include <pthread.h>
int
oskit_sem_close(sem_t *sem)
{
int enabled;
pthread_mutex_lock(&semn_space.semn_lock);
save_preemption_enable(enabled);
disable_preemption();
pthread_lock(&sem->sem_lock);
if (--(sem->sem_refcount) == 0 && (sem->sem_flag & SEM_UNLINK_FLAG)) {
sem_remove(sem)... | 1 |
#include <pthread.h>
int BufferSize;
void *Producer_Function();
void *Consumer_Function();
int BufferIndex=0;
int sleepTime = 10;
char *BUFFER;
pthread_cond_t Buffer_Not_Full=PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar=PTHREAD_MUTEX_I... | 0 |
#include <pthread.h>
int num_threads;
pthread_t p_threads[65536];
pthread_attr_t attr;
int list[268435456];
int list_size;
pthread_mutex_t lock_minimum;
int minimum;
int count;
void *find_minimum (void *s) {
int j;
int thread_id = (int) s;
int chunk_size = list_size/num_thread... | 1 |
#include <pthread.h>
pthread_mutex_t Mutex;
pthread_cond_t Condition;
int Value;
} semaphore_type;
void Wait(semaphore_type *Semaphore) {
pthread_mutex_lock(&(Semaphore->Mutex));
Semaphore->Value--;
if (Semaphore->Value < 0) {
pthread_cond_wait(&(Semaphore->C... | 0 |
#include <pthread.h>
char forks_action(
char action,
char chopstick,
struct s_arg_philosopher_thread *pharg,
struct s_philosopher *ph)
{
pthread_mutex_t *mutex[2];
mutex[0] = &pharg->philosophe... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t blanks;
sem_t datas;
int ringBuf[30];
void *productRun(void *arg)
{
int i = 0;
while(1)
{
sem_wait(&blanks);
int data = rand()%1234;
ringBuf[i++] = data;
i %= 30;
printf("product is done... data... | 0 |
#include <pthread.h>
struct control_info {
int workload;
int rounds;
};
char g_buffer[(4*1024) * (4*1024)];
pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
unsigned int overlap_count = 0;
void unit_work(void)
{
int i;
int f,f1,f2;
struct timeinfo begin, end;
f1 =12441331;
f2... | 1 |
#include <pthread.h>
uint16_t breakpoints[MAX_BREAKPOINTS] = {0};
uint8_t breakpoints_len = 0;
char cmd[32] = {0};
extern volatile uint8_t RUNNING;
extern volatile uint8_t STEP;
pthread_mutex_t mutex;
pthread_cond_t condA;
void* debugger_main(void *running) {
pthread_mutex_init(&mutex, 0);
RUN... | 0 |
#include <pthread.h>
pthread_t tid[] = {100, 200, 300, 400};
pthread_mutex_t lock1, lock2, lock3, lock4;
int pages[5000][3];
void* thread1(void *arg)
{
while(1)
{
pthread_mutex_lock(&lock1);
int randPage = rand() % 5000;
int randOperation = rand() % 2;
if(pages[randPage][0] == 0)
{... | 1 |
#include <pthread.h>
int *array;
int length, count= 0;
pthread_t *ids;
pthread_mutex_t mtx=PTHREAD_MUTEX_INITIALIZER;
int length_per_thread;
void * count3p(void *myI){
int i, myStart, myEnd, myIdx= (int)myI;
myStart= length_per_thread * myIdx; myEnd= myStart + length_per_thread;
printf(... | 0 |
#include <pthread.h>
{
char *file;
char *command;
int bufferSize;
char *directory;
} s_request;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int bytes = 0;
void *scanFile( s_request *request )
{
pthread_mutex_lock(&mutex);
struct rusage usage;
struct timeval ... | 1 |
#include <pthread.h>
key_t key;
int shmid;
int *lost;
pthread_mutex_t lock;
Window window;
Display* display;
int users;
int main(int argc, char *argv[]) {
key = 42;
shmid = shmget(key, 1, 0644 | IPC_CREAT);
lost = shmat(shmid, (void *)0, 0);
*lost = 0;
pthread_mutex_init(&lock... | 0 |
#include <pthread.h>
void rw_init(struct rw_lock_s *rwLock)
{
pthread_mutex_init(&rwLock->mutex, 0);
pthread_cond_init(&rwLock->noWriters, 0);
pthread_cond_init(&rwLock->noActiveWriter, 0);
pthread_cond_init(&rwLock->noReaders, 0);
rwLock->readers = 0;
rwLock->writers = 0;
rwLock->write... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t thr1, thr2, thr3;
pthread_attr_t attr1, attr2, attr3;
void * fonction_2(void * unused)
{
int i, j;
fprintf(stderr, " T2 demarre\\n");
fprintf(stderr, " T2 travaille...\\n");
for (i = 0; i < 100000; i ++)
for (j = 0; j < 10000; j +... | 0 |
#include <pthread.h>
pthread_mutex_t mx1=PTHREAD_MUTEX_INITIALIZER;
int st;
int vec;
int *ar;
void *f1(void *arg)
{
int i,j;
while(st)
{
pthread_mutex_lock(&mx1);
j=0;
for(i=1;i<1000;i++)
if (ar[i]==1)j++;
printf("Vec %d %d \\n",j,ar[0]);
pthread... | 1 |
#include <pthread.h>
struct thread_arg {
pthread_t tid;
int idx;
char *x, *y;
} t_arg[3];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *start_func(void *);
void clean_thread(struct thread_arg *);
char *sum_strnum(const char *, const char *);
int main()
{
t_arg[0].idx = 0;
t_arg... | 0 |
#include <pthread.h>
struct timespec start;
struct timespec stop;
int num = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* FirstThread(void *n)
{
while(num == 1)
{
pthread_mutex_lock(&mutex);
num=0;
pthread_mutex_unlock(&mutex);
}
}
void* SecondThread(void *n)
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex ;
pthread_cond_t cond ;
void *thread1( void *arg )
{
pthread_cleanup_push(pthread_mutex_unlock ,&mutex);
while(1)
{
printf("thread1 is running !! \\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond ,&mutex)... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
static struct foo *g_fp = 0;
struct foo *foo_alloc(int id) {
struct foo *fp;
if((fp = malloc(sizeof(struct foo))) != 0){
fp->f_count = 1;
fp->f_id = id;
if(pthread_mutex... | 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;
int f_id;
struct foo *f_next;
char name[20];
};
struct foo *
foo_alloc(int id)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo)))... | 0 |
#include <pthread.h>
void do_one_thing(int *);
void do_another_thing(int *);
void do_wrap_up(int, int);
int r1 = 0, r2 = 0, r3 = 0;
pthread_mutex_t r3_mutex=PTHREAD_MUTEX_INITIALIZER;
extern int
main(int argc, char **argv)
{
pthread_t thread1, thread2;
if (argc > 1)
r3 = atoi(argv[1]);
... | 1 |
#include <pthread.h>
int promedio=0;
int maximo=0;
int minimo=1000;
int longitud=0;
pthread_mutex_t bloqueo;
void* Valor_minimo(void *l){
int *p = (int*)l;
int a=0;
pthread_mutex_lock(&bloqueo);
for (a=0; a < longitud; a++)
{
if (p[a]<=minimo){
minimo=p[a];
}
}
pthread_mutex_un... | 0 |
#include <pthread.h>
int tid;
double stuff;
} thread_data_t;
int shared_x;
pthread_mutex_t lock_x;
void* thread_func(void *arg) {
thread_data_t* data = (thread_data_t*) arg;
pthread_mutex_lock(&lock_x);
printf("In thread_func, thread id: %d\\n", data->tid);
shared_x += data->stuff;... | 1 |
#include <pthread.h>
static pthread_mutex_t q_mutex;
{
char ch;
int num;
struct link *next;
}*Link;
{
Link rear;
Link front;
}Link_queue;
Link_queue my_queue;
int is_empty_queue(Link_queue *my_queue)
{
if((my_queue->rear == 0) && (my_queue->front == 0))
{
... | 0 |
#include <pthread.h>
int **matrice = 0;
int rows = 0, cols = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int maggiore = 0;
int running_threads = 4 -1;
void *calcola( void *arg){
int somma = 0;
int pos = *(int * )arg;
printf("\\n\\nPosizione %d\\n", pos);
if(pos == 0){
for (int... | 1 |
#include <pthread.h>
int make_listen(int port);
void handle_connection(FILE* fin, FILE* fout);
int remove_trailing_whitespace(char* buf);
static pthread_mutex_t mutex;
static int n_connection_threads;
void* connection_thread(void* arg) {
FILE* f = (FILE*) arg;
pthread_mutex_lock(&mutex)... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5];
void eat(void *temp){
int *me;
me = temp;
printf("Philo %i initializing\\n\\r", *me);
int right_fork;
int left_fork;
if((*me)%2==0) {
left_fork = *me;
right_fork = *me+1;
if(*me == 4) {
right_fork = 0;
}
} else {
left_fork = *me+1... | 1 |
#include <pthread.h>
pthread_t t[5];
int self[5];
pthread_mutex_t mutex;
pthread_cond_t condition[5];
philstat status[5];
int foodEaten[5];
} table;
table * tab;
void printstate(void){
static char stat[] = "THE";
int i;
for (i=0; i<5; i++) {
printf("%5c", stat[(int)(tab->sta... | 0 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static pthread_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void thread_init( void ) {
pthread_key_create( &key, free );
}
char *getenv( const char *env_name ... | 1 |
#include <pthread.h>
void mux_2_memtoreg(void *not_used){
pthread_barrier_wait(&threads_creation);
while(1){
pthread_mutex_lock(&control_sign);
if (!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait,&control_sign) != 0);
}
... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static char key_buffer[256];
static unsigned int read_idx;
static unsigned int write_idx;
static int shift;
static int caps;
static const unsigned char keymap[2][128] = {
{
0,
0xFF, '1', '2'... | 1 |
#include <pthread.h>
int *array;
int result = 0;
pthread_mutex_t mutex;
struct range {
int begin;
int end;
};
void sum(void *arg) {
struct range ran = *((struct range *)arg);
int res = 0;
for (int i = ran.begin; i < ran.end; i++) {
res += array[i];
}
pthre... | 0 |
#include <pthread.h>
{
RET_OK = 0,
RET_FAIL
}Ret;
{
int r_cursor;
int w_cursor;
size_t length;
void* data[0];
}FifoRing;
FifoRing* fifo_ring_create(size_t length)
{
FifoRing* thiz = 0;
if(!(length > 1)) return 0;;
thiz = (FifoRing*)malloc(sizeof(FifoRing) + length * sizeof(void*));... | 1 |
#include <pthread.h>
int g_buffer[10];
unsigned in = 0;
unsigned out = 0;
unsigned produce_id = 0;
unsigned consume_id = 0;
sem_t g_sem_full;
sem_t g_sem_empty;
pthread_mutex_t g_mutex;
pthread_t g_thread[1 + 5];
void *consume(void *arg)
{
int num = (int) arg;
while (1) {
... | 0 |
#include <pthread.h>
int othm_thread_stop_check(struct othm_thread *thread)
{
int value;
pthread_mutex_lock(&thread->stop_mutex);
value = thread->stop_bool;
pthread_mutex_unlock(&thread->stop_mutex);
return value;
}
void othm_thread_stop_mutate(struct othm_thread *thread, int value)
{
pthre... | 1 |
#include <pthread.h>
char quit[] = ":quit";
char nomore[] = "No more connection // MAX 10\\n";
char greet0[] = "------------------------------------------------------------------\\n";
char greet1[] = "------------------- Welcome to CSRC chat server ------------------\\n";
char greet2[] = "-------... | 0 |
#include <pthread.h>
pthread_t tabla_hilos[8];
int suma=0;
pthread_mutex_t mutex;
int id;
char *cadena;
}hilos_param;
int id;
char *cadena;
}orden;
orden posiciones [8];
hilos_param parametros [8];
void *funcion_coches(hilos_param *p){
int aleatorio;
printf(" Salida %s %d \\n", p->caden... | 1 |
#include <pthread.h>
pthread_mutex_t usertable_mutex = PTHREAD_MUTEX_INITIALIZER;
void send_response (const int, const char *);
void server_doit (struct connection_info *c)
{
ssize_t s;
int error;
char cmd;
int i;
char hbuf[NI_MAXHOST];
char sbuf[NI_MAXSERV];
char rbuf[MAXBU... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_t... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int *comm_fd;
void *accept_client_co(void *communication_fd);
int stream_socket(int port);
void sig_handler(int sig);
void sig_handler(int sig) {
switch(sig){
case SIGINT:
free(comm_fd);
printf("Server was stopped by user action.\\n... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *
inc_count (void* arg)
{
count++;
pthread_mutex_lock (&count_mutex);
pthread_mutex_unlock (&count_mutex);
return 0;
}
void *
watch_count (void *idp)
{
pthread_mutex_lock (&coun... | 1 |
#include <pthread.h>
void *Enqueuer();
void *Dequeuer();
unsigned int readIndex = 0;
unsigned int writeIndex = 0;
char dataBuffer[2][20];
pthread_cond_t bufferNotFull=PTHREAD_COND_INITIALIZER;
pthread_cond_t bufferNotEmpty=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutexLock=PTHREAD_MUTEX_INIT... | 0 |
#include <pthread.h>
static int error(int cod,const char*const msg)
{
if (cod<0)
{
perror(msg);
exit(1);
}
return cod;
}
{
pthread_mutex_t guard;
volatile unsigned val;
} Shared;
Shared theShared;
static void* increment(void* data)
{
unsigned long count=(1ul<<20);
... | 1 |
#include <pthread.h>
int indice_philo;
int nbr_portion;
}philo_t;
pthread_cond_t cond;
philo_t *philo;
struct file_baguette *next;
}file_baguette_t;
void prendre_baguettes(philo_t *p);
void poser_baguettes(int i);
int manger(int i);
void wait_in_fifo(int i, philo_t *p);
... | 0 |
#include <pthread.h>
const int size = 1000;
unsigned char *image;
int yc = 0;
pthread_mutex_t lock_yc = PTHREAD_MUTEX_INITIALIZER;
static void calcul(int x, int y, unsigned char *pixel)
{
long double p_x = (long double)x/size * 2.0l - 1.0l;
long double p_y = (long double)y/size * 2.0l -... | 1 |
#include <pthread.h>
static void main_loop (int rpipe, int wpipe, struct listen_info * info)
{
while (1) {
int fd;
int priority;
char * message;
int result = receive_pipe_message_any (50, &message, &fd, &priority);
if (result != 0) {
snprintf (log_buf, LOG_SIZ... | 0 |
#include <pthread.h>
int idx=0;
int ctr1=1, ctr2=0;
int readerprogress1=0, readerprogress2=0;
pthread_mutex_t mutex;
void __VERIFIER_atomic_use1(int myidx) {
__VERIFIER_assume(myidx <= 0 && ctr1>0);
ctr1++;
}
void __VERIFIER_atomic_use2(int myidx) {
__VERIFIER_assume(myidx >= 1 && ctr... | 1 |
#include <pthread.h>
static pthread_mutex_t send_nl_mutex;
int GetNetLinkInterface(int prototype,int group,int pid)
{
struct sockaddr_nl sock_addr;
int sockfd;
sockfd = socket(AF_NETLINK, SOCK_RAW, prototype);
if(sockfd == -1){
printf("socket create error\\n");
return -1;
}
memset(&so... | 0 |
#include <pthread.h>
int thread_flag;
pthread_cond_t thread_flag_cv;
pthread_mutex_t thread_flag_mutex;
void wait_n_secs(int seconds, unsigned char show_output)
{
int i;
for (i = 1; i <= seconds; ++i)
{
usleep(1000000);
if (show_output)
printf("Second %d\\n", i);
}
}
v... | 1 |
#include <pthread.h>
static int globalVar = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* threadFunction(void* arg){
int local = 0;
int x;
for(x = 0; x < 100000000; x++){
pthread_mutex_lock(&mutex);
local = globalVar;
local++;
globalVar = local;
pthrea... | 0 |
#include <pthread.h>
int array[4];
int array_index = 0;
pthread_mutex_t mutex;
void *thread(void * arg)
{
pthread_mutex_lock(&mutex);
array[array_index] = 1;
pthread_mutex_unlock(&mutex);
return 0;
}
void *main_continuation (void *arg);
pthread_t t[4];
int main()
{
int i;
... | 1 |
#include <pthread.h>
pthread_mutex_t mut1;
pthread_mutex_t mut2;
void *t1_main(void *unused);
void *t2_main(void *unused);
void *t2_main(void *unused) {
pthread_mutex_lock(&mut1);
printf("t2 has mut2\\n");
pthread_mutex_lock(&mut2);
printf("t2 has mut2\\n");
pthread_mutex_unl... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_tabaco = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_papel = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_fosforos = PTHREAD_MUTEX_INITIALIZER;
void * agente(void * arg){
pthread_mutex_lock(&mutex_tabaco);
pthread_mutex_lock(&mutex_... | 1 |
#include <pthread.h>
void *TransmitThread(void *arg)
{
struct sigevent sig_event;
struct timespec ts_period;
sig_event.sigev_notify = SIGEV_UNBLOCK;
ts_period.tv_sec = 0;
ts_period.tv_nsec = TRANSMIT_WAIT_TIME*1000*1000;
while (0 == *(int *)arg)
{
unsigned char buffer1[BUFFER_SIZE] = {0... | 0 |
#include <pthread.h>
pthread_mutex_t cadeados[NUM_CONTAS];
int contasSaldos[NUM_CONTAS];
int sinal = 0;
int somaCreditos = 0;
FILE *sim;
int contaExiste(int idConta) {
return (idConta > 0 && idConta <= NUM_CONTAS);
}
void inicializarContas() {
int i;
for (i=0; i<NUM_CONTAS; i++)
contasS... | 1 |
#include <pthread.h>
void *thread0(void *);
void *thread1(void *);
pthread_t tid[4];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int main(int argc, char* argv[], char* envp[]) {
int i = 0;
int id[4];
id[0] = 0;
pthread_creat... | 0 |
#include <pthread.h>
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int num;
void* thr_fn1(void* arg)
{
while (1)
{
pthread_mutex_lock(&mutex);
num++;
printf("thread1: num = %d\\n", num);
pthread_mutex_un... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_num = PTHREAD_COND_INITIALIZER;
struct arg{
int i;
};
void cal(int i, void* p);
static void* func(void *p);
int main(int argc, const char *argv[])
{
int err, i;
... | 0 |
#include <pthread.h>
int ticketcount = 10;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *salewindow(void *args)
{
while(1){
pthread_mutex_lock(&mutex);
if(ticketcount > 0){
printf("window %d start sale ticket! The ticket is : %d\\n", (int)args, ticketcount);
... | 1 |
#include <pthread.h>
int thread_count;
double sum;
clock_t starttime,endtime;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
int main(int argc, char* argv[])
{
starttime=clock();
long thread;
pthread_t* thread_handles;
double error;
thread_count = strtol(argv[1]... | 0 |
#include <pthread.h>
long a = 0;
long b = 0;
pthread_mutex_t a_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t b_mutex = PTHREAD_MUTEX_INITIALIZER;
void *a_thread(void *arg) {
printf("This thread increments a and adds to b\\n");
int ret = pthread_mutex_lock(&a_mutex);
if(ret == EINVAL)... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* doit(void *arg)
{
printf("pid = %d begin doit ...\\n", (int)getpid());
pthread_mutex_lock(&mutex);
struct timespec ts = {2, 0};
nanosleep(&ts, 0);
pthread_mutex_unlock(&mutex);
printf("pid = %d end doit ...\\n", ... | 0 |
#include <pthread.h>
sem_t sem_fila[4];
sem_t sem_cliente[4];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int tamanho_fila[4];
int clientes[4 * 100];
int index_cliente;
int clientes_restantes;
void inicializar() {
index_cliente = -1;
clientes_restantes = 4 * 100;
pthread_... | 1 |
#include <pthread.h>
void init_users(int sock, struct connected_users* users_list) {
int i=0;
users_list->current_user = -1;
users_list->sock_serv = sock;
users_list->nb_users = 0;
pthread_mutex_init( &(users_list->mutex), 0 );
for (i=0; i<CLIENTS_NB; i++)
{
... | 0 |
#include <pthread.h>
pthread_t tid[25];
pthread_mutex_t lock1, lock2, lock3;
struct Airplane {
int id;
int fuel;
bool emergency;
};
struct Runway {
int id;
bool occupied;
};
struct Runway runways[3];
struct Airplane airplanes[25];
void init(){
int i, j;
for(i = 0; i < sizeof runways... | 1 |
#include <pthread.h>
int market() {
srand(time(0));
_market_value = 100 * _stocks;
pthread_t threads[_stocks];
pthread_create(&_up_watch, 0, (void*)watch_up, 0);
pthread_create(&_down_watch, 0, (void*)watch_down, 0);
for(int i = 0;i < _stocks;i++) {
pthread_create(&... | 0 |
#include <pthread.h>
struct CRYPTO_dynlock_value
{
pthread_mutex_t mutex;
};
pthread_mutex_t *openssl_mutex = 0;
unsigned long openssl_thread_id( void )
{
return( (unsigned long)pthread_self() );
}
void openssl_mutex_lock( int mode, int n, const char *file,
int line )
{
if( mode &... | 1 |
#include <pthread.h>
static int (*real_pthread_mutex_lock)(pthread_mutex_t *);
static int (*real_pthread_mutex_unlock)(pthread_mutex_t *);
static void
init()
{
static int inited;
if (inited++ > 0) {
return;
}
real_pthread_mutex_lock = dlsym(RTLD_NEXT, "pthread_mutex... | 0 |
#include <pthread.h>
extern struct FileList* root;
int selectPiece(struct FileList* file, struct PeerList* peer)
{
struct PeerList* cursor = file->peer;
char* sum;
int* index;
int i, j;
srand(time(0));
sum = (char*)malloc((file->file_size + MAXLEN) / MAXLEN);
memset(sum, 0x00, (file->fil... | 1 |
#include <pthread.h>
int cont;
int id;
} estrutura;
volatile estrutura estr;
pthread_mutex_t mutex;
pthread_cond_t cond;
volatile int lendo = 0, escrevendo = 0, filaEscrever = 0;
volatile int continua;
void * escrever (void * tid) {
int id = * (int *) tid;
free(tid);
while (1) {
p... | 0 |
#include <pthread.h>
int produce = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *thread_pro(void *argv)
{
for (;;)
{
pthread_mutex_lock(&mutex);
printf("thead_pro product [%d]\\n", produce++);
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
usleep(500*1000);
}
}
vo... | 1 |
#include <pthread.h>
void*
pack(void *data)
{
const char *COLORS[] = {"AliceBlue","AntiqueWhite","Aqua","Aquamarine","Azure","Beige","Bisque","Black","BlanchedAlmond","Blue","BlueViolet","Brown","BurlyWood","CadetBlue","Chartreuse","Chocolate","Coral","CornflowerBlue","Cornsilk","Crimson","Cyan... | 0 |
#include <pthread.h>
enum { STATE_A, STATE_B } state = STATE_A;
pthread_cond_t condA = PTHREAD_COND_INITIALIZER;
pthread_cond_t condB = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *threadA()
{
int i = 0, rValue, loopNum;
while(i<5)
{
... | 1 |
#include <pthread.h>
pthread_t thd[2];
pthread_mutex_t mutex;
int global;
static pid_t get_current_tid()
{
return syscall(SYS_gettid);
}
void foo(int*p) {
int j = 0;
int i = 0;
int sum = 0;
int tid = get_current_tid();
int *q = (int*)malloc(1000);
for (j = 0; j < 600... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond_var[5];
pthread_t threadID[5];
void * philospher(void *num);
void pickup_forks(int);
void return_forks(int);
void philosopher_can_eat(int);
int state[5];
int philosophers[5]={0,1,2,3,4};
void *philospher(void *num) {
while(1)... | 1 |
#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... | 0 |
#include <pthread.h>
struct Node
{
int data;
struct Node *next;
};
int Member(int value, struct Node *head_p);
int Insert(int value, struct Node **head_pp);
int Delete(int value, struct Node **head_pp);
void *Operations(void *rank);
void freeMemory(struct Node **head_pp);
int n, m, samp... | 1 |
#include <pthread.h>
void *thread_fun(void* arg);
pthread_mutex_t work_mutex;
char workarea[1024];
int time_to_exit = 0;
int main(void)
{
int res;
pthread_t thread_a;
void * thread_result;
res = pthread_mutex_init(&work_mutex,0);
if (res != 0) {
perror("Semaphore ini... | 0 |
#include <pthread.h>
char coup_tcp[13];
char coup_part[13];
char rdy = 0;
pthread_mutex_t synchro_mutex;
pthread_cond_t synchro_cv;
char * send_plateau_a()
{
static int player = 0;
static int first = 1;
static pthread_t th;
int retour = 0;
if (first)
{
first = 0;
c... | 1 |
#include <pthread.h>
static void clean_sys_thread(void *arg){
if(arg){
free(arg);
}
}
void *sys_thread(void *arg){
FILE *fp;
struct Sysinfo *siptr;
struct Sysinfo *tail;
char buffer[100];
struct SysCPU syscpu;
struct tms procpu;
long lastctime, curctime;
long lastitime, curitime;
lon... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int count;
void * chunk(void * thread_id){
int id=*(int *) thread_id;
int counter=0;
int i;
for(i=id*((100000*8)/100);i<(id+1)*((100000*8)/100);i++){
if(is_prime(i))
counter++;
}
pthread_mutex_lock(&lock);
count+=counte... | 1 |
#include <pthread.h>
int table[128];
pthread_mutex_t cas_mutex[128];
pthread_t tids[13];
int cas(int * tab, int h, int val, int new_val)
{
int ret_val = 0;
pthread_mutex_lock(&cas_mutex[h]);
if ( tab[h] == val ) {
tab[h] = new_val;
ret_val = 1;
}
pthread_mutex_unlock(&c... | 0 |
#include <pthread.h>
struct entry_s *create_network_map_entry(struct workspace_mount_s *workspace, struct directory_s *directory, struct name_s *xname, unsigned int *error)
{
struct stat st;
st.st_mode=S_IFDIR | S_IRUSR | S_IXUSR | S_IWUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOT... | 1 |
#include <pthread.h> static char rcsId[]="$Id: ikcbl.c,v 1.1 1999/12/16 21:58:23 lanzm Exp lanzm $";
int ikcbl_init_bl(struct ikc_backlog_head* list_head, pthread_mutex_t* mutex)
{
list_head->list = 0;
list_head->mutex = mutex;
return 0;
}
int ikcbl_add_request(struct ikc_backlog_h... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int counter, global_sum_done;
void *work_thread(void* tParam){
struct thread_data *myData;
myData=(struct thread_data*) tParam;
long me;
int NUM_THREADS, xsize, ysize, part_start, part_length,i;
pixel* src;
int *sum;
float *... | 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(struc... | 0 |
#include <pthread.h>
void *thread_main(void *arg);
struct sync_var {
pthread_mutex_t mutex;
pthread_cond_t waitq;
int num, num2wait;
};
static void
sync_var_init(struct sync_var *v, int num, int num2wait) {
pthread_mutex_init(&v->mutex, 0);
pthread_cond_init(&v->waitq, 0);
v->num=num;
v->... | 1 |
#include <pthread.h>
struct arg_set {
char *fname;
int count;
};
struct arg_set *mailbox;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
int main(int ac, char *av[])
{
pthread_t t1, t2;
struct arg_set args1, args2;
void *coun... | 0 |
#include <pthread.h>
int archivos_Inicia();
int escrbirArchivo(char * contenido, char *url);
void *hiloWriteWEB(void *dummyPtr);
int numeroHilos = 0;
pthread_t thread_id [2];
pthread_mutex_t mutexEscritura = PTHREAD_MUTEX_INITIALIZER;
int counterCache = 0;
in... | 1 |
#include <pthread.h>
pthread_mutex_t disk_mutex = PTHREAD_MUTEX_INITIALIZER;
int log_to_disk(int from_lan)
{
extern char hiscall[];
extern char comment[];
extern char my_rst[];
extern char his_rst[];
extern char last_rst[4];
extern char qsonrstr[5];
extern char l... | 0 |
#include <pthread.h>
struct pid_data{
pthread_mutex_t pid_mutex;
pid_t pid;
};
char buffer[1500];
int set_priority(int priority);
int get_priority();
int message_server();
int main(int argc, char *argv[]) {
printf("Welcome to the QNX Momentics IDE\\n");
int f_desc = shm_open("/dev/shme... | 1 |
#include <pthread.h>
const char direction_array[]={'E','N','W','S'};
int direction_int(char ch)
{
switch(ch)
{
case 'e': return 0;
case 'n': return 1;
case 'w': return 2;
case 's': return 3;
default : return 0;
}
}
pthread_mutex_t crossing[4]={PTHREAD_MUTEX_INITIALIZER , PTHREAD... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.