text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct job {
struct job* next;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
void initialize_job_queue ()
{
job_queue = 0;
sem_init(&job_queue_count, 0, 0);
}
void* thread_function (v... | 1 |
#include <pthread.h>
static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
static int g_db_group_ptr = -1;
static void group_set_db_ptr(int i)
{
pthread_mutex_lock(&g_mutex);
g_db_group_ptr = i;
pthread_mutex_unlock(&g_mutex);
}
static struct group_t *group_new(void)
{
... | 0 |
#include <pthread.h>
unsigned long long main_counter, counter[3];
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_worker(void*);
void* thread_worker(void* p)
{
int thread_num;
thread_num = *(int *)p;
for(;;)
{
pthread_mutex_lock(&mutex);
... | 1 |
#include <pthread.h>
struct prodcons {
int buffer[4];
pthread_mutex_t key;
int read, write;
pthread_cond_t notEmpty;
pthread_cond_t notFull;
} buffer;
void init(struct prodcons * b)
{
pthread_mutex_init(&b->key, 0);
pthread_cond_init(&b->notEmpty, 0);
pthread_cond_init(&b->notFull... | 0 |
#include <pthread.h>
static struct tbf_st *atbf[CHN_NUMS];
pthread_mutex_t tbf_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_t tid_timer;
pthread_once_t once_control = PTHREAD_ONCE_INIT;
static int get_index(void)
{
int i;
for (i = 0; i < sizeof atbf / sizeof atbf[0]; ++i) {
if (atbf[i] == 0) {
... | 1 |
#include <pthread.h>
int quitflags;
sigset_t mask;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static void *thr_fn(void *arg)
{
int err, signo;
for( ; ; ){
err = sigwait(&mask, &signo);
if(err != 0){
perror("sigwait error");
ret... | 0 |
#include <pthread.h>
struct thread_data{
char * buffer;
unsigned int chunk_size;
int id;
unsigned int *histo;
int* howfar;
pthread_mutex_t * mutex;
};
void* parallel(void* threadArg){
struct thread_data *data = threadArg;
unsigned int chunk_size = data->chu... | 1 |
#include <pthread.h>
pthread_mutex_t alarm_lock= PTHREAD_MUTEX_INITIALIZER;
extern const char * id;
int win = 0;
int nombre_aleatoire = 0;
{
char addr [TAILLE_ADDRESS + 1];
struct Fifo * next;
} Fifo;
Fifo* fifoDebut;
Fifo* fifoFin;
void createElementFifo(char *addr, Fifo * f)
{
strcpy(... | 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(struct foo)... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
int wake;
int stop;
void *
thr_routine(void *arg)
{
pthread_mutex_lock(&m);
while (wake == 0)
pthread_cond_wait(&cv, &m);
pthread_mutex_unlock(&m);
while (stop == 0)
pthre... | 0 |
#include <pthread.h>
int state[5];
pthread_mutex_t mutex;
sem_t s[5];
pthread_t fil[5];
void test(int i){
if (state[i] == 1 && state[(i+5 -1)%5] != 2 && state[(i+1)%5] != 2){
state[i] = 2;
sem_post(&(s[i]));
}
}
void think(int i){
printf("%d: THINKING\\n", i);
}
void eat(int i){
... | 1 |
#include <pthread.h>
void *direccion;
char *archivo;
pthread_mutex_t mutex;
}MAPA;
pthread_mutex_t mutex;
int
calculate_position(char char1, char char2){
int a = toascii(char1);
int b = toascii(char2);
int posicion = ((a*128) + b);
return posicion;
}
void
agregarAMap... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[800];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
... | 1 |
#include <pthread.h>
pthread_barrier_t br;
pthread_cond_t cv;
pthread_mutex_t lock;
bool exiting;
int fd, count, spins, nn;
void *
tf (void *id)
{
pthread_setschedparam_np(0, SCHED_FIFO, 0, 0xF, PTHREAD_HARD_REAL_TIME);
pthread_barrier_wait(&br);
pthread_mutex_lock (&lock);
if ((long) ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int i, n, N, n_start, n_master, n_slave;
int *ids;
double sum;
void *Summator( void * );
int main( int argc, char **argv ) {
if ( argc != 3 ) {
printf( "Wrong numbers of parameters. Add n and N.\\n" );
... | 1 |
#include <pthread.h>
pthread_mutex_t accion= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond= PTHREAD_COND_INITIALIZER;
char vendedor_actual[10];
char comprador_actual[10];
int num_vend, precio_actual;
boolean compra;
int vendo(int precio, char *vendedor, char *comprador){
pthread_mutex_lock(&a... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
int main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0... | 1 |
#include <pthread.h>
bool flag_completo = 0;
int x, y, z;
int par1_sensores[2];
int par2_sensores[2];
int cont_pos = -1;
int resultados[24][3];
long double resultados_sumarizados[10];
int pares_especificos[10] = {2,3,4,5,6,8,10,12,15,20};
char* nome_sensores[10] = {"1 e 2", "1 e 3", "1 e 4",... | 0 |
#include <pthread.h>
double *a;
double *b;
double sum;
int veclen;
} dotdata;
dotdata dotstr;
pthread_t thread_id[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg) {
int i, start, end, offset, len ;
double mysum, *x, *y;
offset = (int)arg;
len = dotstr.veclen;
st... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void handler(void *data)
{
printf("线程退出后调用我!\\n");
pthread_mutex_unlock(&mutex);
}
void * odd(void *arg)
{
int i;
for (i=1; ; i+=2) {
pthread_cleanup_push(handler, 0);
pthread_mutex_lock(&mutex);
printf("odd number : %d\\n", i);
pthread_mu... | 0 |
#include <pthread.h>
uint8_t grab_new_frame;
void tick(int signum) { grab_new_frame = 1; }
void * grabber(void * args)
{
struct thread_arg * ta = (struct thread_arg *)args;
struct channel * output = ta->output;
struct timeval tv;
struct sigaction sa;
struct itimerval tmr;
uint... | 1 |
#include <pthread.h>
int N;
int *v;
pthread_mutex_t *lock;
}Counter;
Counter ca, cb;
void initialize_array(int *array, int N);
void *thFuncA(void *arg);
void *thFuncB(void *arg);
int main(int argc, char *argv[]){
pthread_t *tha, *thb;
int i;
if(argc != 2){
return -1;
}
N = at... | 0 |
#include <pthread.h>
pthread_t threads[5];
pthread_mutex_t forks[5];
void fail() {
printf("Could not lock a mutex.\\n");
exit(1);
}
void* worker (void * arg) {
int id = *(int *) arg;
int left = id;
int right = (id + 1) % 5;
if (left > right) {
int tmp = left;
left =... | 1 |
#include <pthread.h>
int send_request(struct client_connection *conn, struct Message *req) {
int rc = 0;
pthread_mutex_lock(&conn->mutex);
rc = send_msg(conn->fd, req);
pthread_mutex_unlock(&conn->mutex);
return rc;
}
int receive_response(struct client_co... | 0 |
#include <pthread.h>
int value;
char padding[60];
} padded_int;
int count=0;
padded_int counter[8];
int *array;
pthread_mutex_t lock;
void * global_counter_scalar(void *thread_id){
int *int_pt=array+(*((int*)thread_id)*(800000000/8));
int i;
for (i=0;i<800000000/8;i++){... | 1 |
#include <pthread.h>
FILE *foto, *video, *chave;
unsigned char **imagem;
char h_imagem[7],w_imagem[7],h_video[7],w_video[7];
int i_img=0,j_img=0, num_bits;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
void *desestenografar(){
int i,j,k;
unsigned char temp, temp1 =0,temp2=0,mask1 = 0x1,... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
long long number_in_circle;
long long threads_tosses;
long long ramain_tosses;
int SEED;
void* tossDarts(void*);
int main(int argc, char **argv) {
pthread_t* threads;
long long number_of_tosses = atoll(argv[1]);
long long ramain_tosses;
... | 1 |
#include <pthread.h>
int nbr_endormies;
int client;
pthread_mutex_t mutex;
pthread_cond_t nb_changed;
pthread_cond_t client_changed;
struct fool{
int val;
struct fool *next;
};
struct fool *first;
void consomme_req(struct fool *p);
void* traiter_requete(void* ... | 0 |
#include <pthread.h>
static const int DEFAULT = 0644;
static pthread_mutex_t bank[10000] = {PTHREAD_MUTEX_INITIALIZER};
void* connection(int pipe[2]);
void printHelp(char* programName);
struct option longopts[] = {
{"file", required_argument, 0, 'f'},
{"jobs", required_argument, 0, 'j'}
};
in... | 1 |
#include <pthread.h>
struct queue_type *reorder_buffer;
void alloc_reorder_buffer(struct ftl_request p_ftl_req)
{
struct queue_node *q_node_iter;
for (q_node_iter = reorder_buffer->head; q_node_iter != 0; q_node_iter = q_node_iter->next)
{
if (q_node_iter->ftl_req.id == p_ftl_req.id)
{
... | 0 |
#include <pthread.h>
{
char key[8];
char data[56];
} Record;
{
Record *array;
int tid;
int lowRec;
int hiRec;
} ThdArg;
void *runner(void *param);
int compare(const void *a, const void *b);
void mergesort(Record *array, int arrayLength);
int curNumThreads;
int minThreadSize;
pthread_mute... | 1 |
#include <pthread.h>
int
pthread_cancel (pthread_t t)
{
int err = 0;
struct pthread_internal_t *p = (struct pthread_internal_t*) t;
pthread_init();
pthread_mutex_lock (&p->cancel_lock);
if (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_PENDING)
{
pthread_mutex_unlock (&p->cancel_... | 0 |
#include <pthread.h>
int func_num;
} tagTHDATA;
pthread_mutex_t g_mutex;
void *thread_func0(void* pData)
{
tagTHDATA* pThdata = (tagTHDATA*)pData;
while (1) {
printf("--func%d --wait mutex-----\\n", pThdata->func_num);
pthread_mutex_lock(&g_mutex);
pr... | 1 |
#include <pthread.h>
pthread_cond_t exit_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t exit_mutex = PTHREAD_MUTEX_INITIALIZER;
int log_priority = LOG_ERR;
int use_syslog;
FILE *logfd;
static void *
signal_set(int signo, void (*func) (int))
{
int r;
struct sigaction sig;
struct siga... | 0 |
#include <pthread.h>
pthread_t bg_manager;
pthread_mutex_t bg_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t bg_wait = PTHREAD_COND_INITIALIZER;
pthread_mutex_t net_lock = PTHREAD_MUTEX_INITIALIZER;
int acquire_netlock() {
pthread_mutex_lock(&net_lock);
int s = get_mode();
if(s == -... | 1 |
#include <pthread.h>
char buffer_teste[40];
void iniciaRede(){
int te, tr,tet,trt;
pthread_t te_rede, tr_rede, te_tabela_rotas,tr_tabela_rotas;
te = pthread_create(&te_rede, 0, Prod_rede, 0);
if (te) {
printf("ERRO: impossivel criar a thread");
exi... | 0 |
#include <pthread.h>
struct job {
struct job* next;
int dato;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex;
pthread_cond_t thread_flag_cv;
int thread_flag;
void initialize_flag (){
pthread_mutex_init (&job_queue_mutex, 0);
pthread_cond_init (&thread_flag_cv, 0);
thread_fla... | 1 |
#include <pthread.h>
void gw_dm_failed ( void *_job_id )
{
gw_job_t * job;
int job_id;
if ( _job_id != 0 )
{
job_id = *( (int *) _job_id );
job = gw_job_pool_get(job_id, GW_TRUE);
if ( job == 0 )
{
gw_log_print("DM",'E',"Job %i does not exist (JOB_STATE_FAILED).\\n",jo... | 0 |
#include <pthread.h>
struct img_struct* current_frame;
unsigned long seqNumF;
double dt2;
int locX, locY;
pthread_t object_detect_thread;
pthread_mutex_t location_access_mutex=PTHREAD_MUTEX_INITIALIZER;
struct point findBlob(struct img_struct* frame, unsigned char Ymin, unsigned char Ymax, u... | 1 |
#include <pthread.h>
int number;
pthread_mutex_t mu= PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *dummy)
{
int printed= 0;
" now\\"\\n", pthread_self());
while (1)
{
pthread_mutex_lock(&mu);
pthread_mutex_unlock(&mu);
if (number == 10)
{
printf... | 0 |
#include <pthread.h>
int hilos_entradaActivo;
int active_work;
void *KEY;
int bufSize = 0;
FILE *file_in;
FILE *file_out;
pthread_mutex_t mutexIN;
pthread_mutex_t mutexWORK;
pthread_mutex_t mutexOUT;
char data;
off_t offset;
char state;
} BufferItem;
BufferItem *result;
void thread_sle... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
uint32_t goal = UINT32_MAX - 100;
void run_atomic(uint32_t *bob) {
while(*bob < goal)
__sync_fetch_and_add(bob, 1);
}
void run_mutex(uint32_t *bob) {
while(*bob < goal) {
pthread_mutex_lock(&mutex);
(*bob)++;
pthread_mutex_u... | 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(struct foo))) != 0){
fp-... | 1 |
#include <pthread.h>
pthread_mutex_t mutex ;
void thread1(void *arg) ;
void thread2(void *arg) ;
int main(void)
{
int *status1, *status2 ;
pthread_t thid1 ,thid2;
pthread_mutexattr_t mutexattr ;
mutexattr.__align = PTHREAD_MUTEX_RECURSIVE_NP ;
pthread_mutex_init (&m... | 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<5; i++) {
pthread_mutex_lock(&count_mutex);
count++;
printf("(%ld) co... | 1 |
#include <pthread.h>
struct mymesg {
long mtype;
char mtext[512 + 1];
};
struct threadinfo {
int qid;
int fd;
int len;
pthread_mutex_t mutex;
pthread_cond_t ready;
struct mymesg m;
};
void *
helper(void *arg)
{
int n;
struct threadinfo *tip = arg;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t semaphore;
int platforms;
int * station;
} Data;
Data * data;
int id;
} Tuple;
int randomRange(int min, int max) {
return rand() % (max - min + 1) + min;
}
struct tm getTime() {
time_t now = time(0);
return *localtime(&now);
}
st... | 1 |
#include <pthread.h>
void *ThreadMain(void *arg);
struct ThreadArgs {
int clntSock;
};
unsigned short cur_clients;
pthread_mutex_t lock;
int main(int argc, char *argv[]) {
int servSock;
int clntSock;
unsigned short servPort;
unsigned short max_clients;
pthread_t threadID;
struct Thr... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
};
static struct foo *g_foop = 0;
static struct foo *foo_alloc(void)
{
struct foo *fp;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
if (pthread_mutex_init(&fp->f_lock, 0... | 1 |
#include <pthread.h>
unsigned int led_speed;
pthread_mutex_t lock;
static void *LEDMod(void *dummy)
{
unsigned int led_period;
int tmp;
tmp = open("/sys/class/leds/motherboard_buzzer/brightness", O_WRONLY);
if (tmp < 0)
exit(1);
while (1) {
pthread_m... | 0 |
#include <pthread.h>
struct student{
int id;
int numQuestions;
int questionNum;
};
int totalStudents;
int inOffice, studentZ;
sem_t readyForQuestion, questionWait, answerWait, capacity;
pthread_t professor;
pthread_mutex_t question_lock;
int identification;
void Professor();
void *StartPr... | 1 |
#include <pthread.h>
void fileTransfer(void *arg);
static int threadCount = 0;
pthread_mutex_t alock = PTHREAD_MUTEX_INITIALIZER;
char file_name[512];
int main(int argc,char **argv)
{
struct sockaddr_in serv_addr;
struct sockaddr_in clie_addr;
int sock_id;
int clie_addr... | 0 |
#include <pthread.h>
void PANIC(char *msg);
struct sockaddr_in dest;
char request[1024];
size_t request_count = 0;
const size_t request_limit = 100000;
pthread_mutex_t count_mutex;
static size_t make_request(void* p) {
int sockfd, bytes_read;
char buffer[1024];
size_t response_len... | 1 |
#include <pthread.h>
int N=100;
int T=2;
pthread_mutex_t mutexMin, mutexMax;
int *v;
int min_min;
int max_max;
int ocurrencias=0;
double dwalltime(){
double sec;
struct timeval tv;
gettimeofday(&tv,0);
sec = tv.tv_sec + tv.tv_usec/1000000.0;
retu... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *pforsend(void *_sock){
char sendbuf[4096];
long sockfd = (long)_sock;
char sexit[10] = {'e','x','i','t','\\n',0};
while(1){
fgets(sendbuf, 4096, stdin);
if(strcmp(sendbuf,sexit)==0){
exit(0);
... | 1 |
#include <pthread.h>
pthread_mutex_t garfo[5] = PTHREAD_MUTEX_INITIALIZER;
int garfos[5]={0,0,0,0,0};
pthread_cond_t c[5] = {0,0,0,0,0};
void *filosofo(void *threadid) {
long tid;
tid = (long)threadid;
while (1){
printf("Thread %ld tentando obter garfo à esquerda!\\n", tid);... | 0 |
#include <pthread.h>
int count = 0;
int isDisponible = 0;
void *p;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void compartir(void *ptr){
printf("Compartir...\\n");
pthread_mutex_lock(&m);
if(count==0){
pthread_mutex_unlock(&m);
print... | 1 |
#include <pthread.h>
double sum=0.0, a[10000000];
pthread_mutex_t sum_mutex;
void *do_work(void *tid)
{
int i, start, *mytid, end;
double mysum=0.0;
mytid = (int *) tid;
start = (*mytid * 10000000 / 32);
end = start + 10000000 / 32;
printf ("Thread %d doing iterations %d to %d\... | 0 |
#include <pthread.h>
void *thread_function(void*);
int run_row=1;
pthread_mutex_t test_mutex;
void practice_mutex(){
int result;
pthread_t a_thread[4];
pthread_mutex_init(&test_mutex, 0);
for (long i = 0 ; i < NUM_THREADS; i++) {
printf("In main: creating thread %ld\\n",... | 1 |
#include <pthread.h>
static pthread_mutex_t comm_lockout;
int init_commfd(const char *sockpath)
{
if(pthread_mutex_init(&comm_lockout, 0) != 0)
return -1;
int sock = socket(PF_LOCAL, SOCK_STREAM, PF_UNSPEC);
if(sock < 0)
return -1;
fcntl(sock, F_SETFD, 1);
... | 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(struct foo))) != 0)
{
... | 1 |
#include <pthread.h>
static int glob = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static void * threadFunc(void *arg)
{
int loops = *((int*) arg);
int loc, j;
for (j = 0; j < loops; j++)
{
pthread_mutex_lock(&lock);
loc = glob;
loc++;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_garfo[5];
pthread_t ninja[5];
int id[5];
void pegar_garfos(int *filo){
pthread_mutex_lock(&(mutex_garfo[*filo]));
if(*filo < 4){
pthread_mutex_lock(&(mutex_garfo[*filo + 1]));
}else{
pthread_mutex_lock(&(mutex_garfo[0]));
}
}
void larga... | 1 |
#include <pthread.h>
int items = 0;
pthread_mutex_t itemsLock;
void * increment(void * args) {
int tid = (int) args;
int counter;
printf("Thread [%d]: Starting execution ...\\n", tid);
printf("Thread [%d]: Initial value of items = %d\\n", tid, items);
for (counter = 0; counter < 500... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static const char * const caller[2] = {"mutex_thread", "signal handler"};
static pthread_t mutex_tid;
static pthread_t sleep_tid;
static volatile int signal_handler_exit = 0;
static void hold_mutex(int c)
{
print... | 1 |
#include <pthread.h>
int get_shmid_from_headers(struct http_header_t headers[], int num_headers)
{
int shmid = -1;
for (int i = 0; i < num_headers; i++) {
if (!strcmp(headers[i].name, IPC_HTTP_HEADER)) {
shmid = atoi(headers[i].value);
break;
}
}
assert(shmid > 0);
return shmid;... | 0 |
#include <pthread.h>
static const int min_eat_ms[5] = {300, 300, 300, 300, 300};
static const int max_eat_ms[5] = {600, 600, 600, 600, 600};
static const int min_think_ms[5] = {300, 300, 300, 300, 300};
static const int max_think_ms[5] = {600, 600, 600, 600, 600};
static void philosoph... | 1 |
#include <pthread.h>
extern sigset_t signal_set;
extern unsigned int bwritten;
extern pthread_mutex_t bwritten_mutex;
int parse_pasv_reply2(char *, int, struct sockaddr_in *);
int parse_list_reply(char *rbuf, int len);
int ftp_get_size(struct sockaddr_in *sin, char *url, int type);
void *ftp_ge... | 0 |
#include <pthread.h>
double accounts[4];
pthread_mutex_t account_locks[4];
void* worker(void* fname) {
FILE* f = fopen((char*) fname, "r");
if (!f) {
fprintf(stderr, "Error could not open file '%s'!\\n", (char*) fname);
}
while (1) {
int to, from;
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int total_grade = 0;
void *class_total(void *curr_grade){
pthread_mutex_lock (&mutex);
total_grade += (int)curr_grade;
pthread_mutex_unlock (&mutex);
return 0;
}
int main(void)
{
int curr_grade = 0;
pthread_t threads[10];
char ... | 0 |
#include <pthread.h>
long timeval_diff(struct timeval *t2, struct timeval *t1)
{
long diff = (t2->tv_usec + 1000000 * t2->tv_sec) - (t1->tv_usec + 1000000 * t1->tv_sec);
return (diff);
}
void error(int err, char *msg) {
fprintf(stderr,"%s a retourné %d, message d'erreur : %s\\n",msg,err,s... | 1 |
#include <pthread.h>
extern pthread_mutex_t __sfp_mutex;
extern pthread_cond_t __sfp_cond;
extern int __sfp_state;
FILE *
freopen(file, mode, fp)
const char *file, *mode;
register FILE *fp;
{
int f, flags, oflags;
FILE *ret;
if ((flags = __sflags(mode, &oflags)) == 0) {
(void) fclose... | 0 |
#include <pthread.h>
struct arg_set {
char *fname;
int count;
int thread_id;
};
struct arg_set *mailbox;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
int main(int argc,char *argv[]) {
pthread_t t1,t2,t3;
struct arg_set args1,args2,ar... | 1 |
#include <pthread.h>
int storehouse[5];
int buyer_demands[3];
pthread_mutex_t store_lock[5];
bool release_condition;
void InitializeStores() {
int i;
srand(time(0));
for (i = 0; i < 5; i++) {
storehouse[i] = (rand() % 499) + 1001;
}
}
void InitializeDemands() {
int i;
for (i =... | 0 |
#include <pthread.h>
struct data{
unsigned int n;
int * list;
};
int topstack;
pthread_mutex_t mutex_q;
pthread_mutex_t mutex_r;
void *sieve_primes(void *arg);
int find_twins(int* list, unsigned int n, int verbose);
void *sieve_primes(void *arg)
{
unsigned int k;
unsigned int m, i;
st... | 1 |
#include <pthread.h>
char *time_str = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread_create_str(void *arg)
{
time_t timeval;
char *tmp = (char *)malloc(50);
sleep(10);
time(&timeval);
bzero(tmp, 50);
sprintf(tmp, "T... | 0 |
#include <pthread.h>
int buffer[5];
pthread_mutex_t mutex;
sem_t pattySem;
sem_t cheeseSem;
sem_t bunSem;
sem_t pattyFullSem;
sem_t cheeseFullSem;
sem_t bunFullSem;
void *assemblyRobot(void *param);
void *bunSupplyRobot(void *param);
void *pattySupplyRobot(void *param);
void *cheeseSu... | 1 |
#include <pthread.h>
int Q[20];
int front = -1;
int rear = -1;
pthread_mutex_t mutex;
sem_t full;
sem_t empty;
void *Supervisor(void *arg){
int student = (int)arg;
pthread_detach(pthread_self());
sem_wait(&empty);
pthread_mutex_lock(&mutex);
rear = rear + 1;
if (rear >= 20) rear = 0;
... | 0 |
#include <pthread.h>
char ch;
time_t end_time;
sem_t customer,barber;
pthread_mutex_t accessSeats;
int NumberOfFreeSeats=15 ;
int NumberHairCutDone=0;
void *barber_function(void *arg);
void *customer_function(void *arg);
int main(int argc, char **argv)
{
pthread_t customerid[20], b... | 1 |
#include <pthread.h>
int buffer=0;
int data_ready = 0;
int toconsume =0;
int i=0;
pthread_t con;
pthread_t pro;
pthread_mutex_t mumu ;
pthread_cond_t condc;
pthread_cond_t condp;
void* producer (void* arg);
void* consumer (void* arg);
void* producer (void* arg)
{ for (int i=0; i<5; i++){
p... | 0 |
#include <pthread.h>
pthread_mutex_t mutex[2];
void *thread_one(void *arg) {
pthread_mutex_lock(&mutex[0]);
sleep(1);
pthread_mutex_lock(&mutex[1]);
printf("go %s\\n", __func__);
pthread_mutex_unlock(&mutex[0]);
pthread_mutex_unlock(&mutex[1]);
return (void *)0;
}
v... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t famoso_durmiendo;
pthread_cond_t autografo;
int ocupacion = 0;
int firmado = 0;
void *famoso(void *kk) {
int i;
while(1) {
pthread_mutex_lock(&mutex);
while (ocupacion < 5) {
pthread_cond_wait(&famoso_durmiendo, &mute... | 0 |
#include <pthread.h>
{
char buffer[5];
int number;
}PRODUCT;
PRODUCT product ={"",0};
char ch = 'A';
pthread_mutex_t mutex;
pthread_cond_t cond;
void * producer_func(void * arg)
{
pthread_t p_id;
p_id = pthread_self();
printf("producer %ld:Starting\\n",p_id);
while(ch!='Z')
{
pthread_... | 1 |
#include <pthread.h>
static int num = 0;
static pthread_mutex_t mut_num = PTHREAD_MUTEX_INITIALIZER;
static void *thr_primer(void *p);
int main()
{
int err,i;
pthread_t tid[4];
for(i = 0 ; i < 4; i++)
{
err = pthread_create(tid+i,0,thr_primer,(void *)i);
if(err)
{
fprintf(stder... | 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");
free(... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int count;
void *print(void *arg) {
int no = *(int *)arg;
while (count < 20) {
pthread_mutex_lock(&mutex);
if (count < 20) {
printf("no.%d locking.....\\n", no);
count++;
printf("thread no... | 0 |
#include <pthread.h>
struct csema
{
pthread_mutex_t m_mutex;
pthread_cond_t m_cond;
int m_count;
};
void csema_ctr(struct csema* p)
{
memset(p, 0, sizeof(*p));
pthread_mutex_init(&p->m_mutex, 0);
pthread_cond_init(&p->m_cond, 0);
}
void csema_dtr(struct csema* p)
{
pthread_cond... | 1 |
#include <pthread.h>
int threadIdx;
}threadParams_t;
pthread_t threads[3];
threadParams_t threadParams[3];
pthread_attr_t rt_sched_attr[3], attr;
int rt_max_prio, rt_min_prio;
struct sched_param rt_param[3];
struct sched_param main_param;
pthread_attr_t main_attr;
pid_t mainpid;
pthread_t... | 0 |
#include <pthread.h>
struct job {
struct job* next;
};
struct job* job_queue;
extern void process_job (struct job*);
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
void* thread_function (void* arg)
{
while (1) {
struct job* next_job;
pthread_mutex_lock ... | 1 |
#include <pthread.h>
void * thread_fcn(void * thread_arg);
void enter_cr(int threadID);
void leave_cr(int threadID);
void init_synch();
void finish_synch();
void show_usage_and_exit(char* arg0);
int num_threads = 0;
int num_trips = 0;
int max_cr_delay = 0;
int max_non_cr_delay = 0;
volatile i... | 0 |
#include <pthread.h>
int buffer[3];
int add = 0;
int rem = 0;
int num = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_cons = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_prod = PTHREAD_COND_INITIALIZER;
void *producer (void *param);
void *consumer (void *param);
int main(i... | 1 |
#include <pthread.h>
unsigned char uart = 0;
pthread_mutex_t rt_mutex;
void* pthreat_recv_data(void* para)
{
int i = 0;
int res = 0;
unsigned long recv_count = 0;
char recv_buf[254] = {0};
if ((uart == 1) || (uart == 2) || (uart == 3))
{
while (1)
{
pthread_mutex_lock(&r... | 0 |
#include <pthread.h>
struct Queue_Node {
int value;
struct Queue_Node *next;
};
struct Queue_Header {
struct Queue_Node *head;
struct Queue_Node *tail;
pthread_mutex_t head_Lock;
pthread_mutex_t tail_Lock;
};
struct Queue_Header Q_header = { 0, 0 };
void *mythread(void *arg);
void Queu... | 1 |
#include <pthread.h>
int q[2];
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 < 2)
... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t cond_women;
pthread_cond_t cond_man;
int gender;
int number=0;
void woman_wants_to_enter() {
pthread_mutex_lock(&the_mutex);
if (gender == 1) pthread_cond_wait(&cond_women, &the_mutex);
number += 1;
if (number == 1)
{
gend... | 1 |
#include <pthread.h>
int Mat_Size;
int No_of_Threads;
int rw = 0, cl = 0;
double **I_Matrix;
double **Pt_Matrix;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
double get_rand(int n)
{
return ( ((double) rand()) / 32767 ) * n;
}
void Init_Mat()
{
int i,j,k;
I_Matrix = (do... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t b;
sem_t f;
void* erzeuger( void* notused ) {
while(1) {
sem_wait(&f);
pthread_mutex_lock(&mutex);
printf("Erzeuger: Element hinzugefügt\\n");
pthread_mutex_unlock(&mutex);
sem_post(&b);
int b_val... | 1 |
#include <pthread.h>
void startTrain();
void getOff();
void TrainReturn();
void * Passenger();
int timesToRun, passLeft,noBoard, capacity, flag;
pthread_mutex_t entry, board, end, ready, ride;
int main (int argc, char* argv[]){
int i, noPass, thrCheck;
pthread_t *pasThread;
noBoard=0;... | 0 |
#include <pthread.h>
struct foo{
int f_count;
pthread_mutex_t f_lock;
};
struct foo * foo_alloc(void)
{
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);
... | 1 |
#include <pthread.h>
char fileName[256];
long int fileSize;
int fileMode;
struct fileStruct *next;
} fileStruct;
extern int verbose_mode;
void SwitchMemory(int *currentMemory, void **writeMemory, void *memory1,
void *memory2, pthread_mutex_t *m1lockw, pthread_mutex_t *m1lockr, pthr... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.