text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t *mutex;
int pid;
char birth[25];
char clientString[10];
int elapsed_sec;
double elapsed_msec;
} stats_t;
int i;
stats_t *shm_ptr;
void exit_handler(int sig) {
pthread_mutex_lock(mutex);
shm_ptr[i].pid = -1;
pthread_m... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
int count = 0;
void *functionCount1()
{
for(;;)
{
pthread_mutex_lock( &count_mutex );
pthread_cond_wait( &condition_var, &co... | 0 |
#include <pthread.h>
struct foo {
int f_reference;
pthread_mutex_t f_lock;
int f_id;
struct foo* f_next;
};
struct foo* foo_hash[29];
pthread_mutex_t foo_hash_lock = PTHREAD_MUTEX_INITIALIZER;
struct foo* foo_alloc(int id)
{
int index = (((unsigned long)id) % 29);
str... | 1 |
#include <pthread.h>
void
diskfs_nref (struct node *np)
{
int new_hardref;
pthread_spin_lock (&diskfs_node_refcnt_lock);
np->references++;
new_hardref = (np->references == 1);
pthread_spin_unlock (&diskfs_node_refcnt_lock);
if (new_hardref)
{
pthread_mutex_lock (&np->lock)... | 0 |
#include <pthread.h>
static struct npc_list *dead_npcs;
static pthread_mutex_t dead_npcs_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct npc_list *aggro_npcs;
static pthread_mutex_t aggro_npcs_mutex = PTHREAD_MUTEX_INITIALIZER;
static struct map_list *maps;
static void respawn_npcs();
stat... | 1 |
#include <pthread.h>
int RUNNING = 0;
char buffer[BUFFER_SIZE];
int START = -1, END = 0;
long long HOLD_TIME = 2000;
bool isSetup = 0;
bool setup( int pinA, int pinB, int pinC )
{
wiringPiSetup();
pinMode( pinA, INPUT );
pullUpDnControl( pinA, PUD_UP );
pinMode( pinB, INPUT );
pullUpDn... | 0 |
#include <pthread.h>
{
int id;
int dir;
int row;
long floatduration;
} Log;
int state = 0;
Log logs[15];
char lines[15 +2][161];
pthread_mutex_t display_lock = PTHREAD_MUTEX_INITIALIZER;
static int frog_row = 1 + 15 + 1, frog_col = (5 * 4);
char under_frog = '|';
const char frog =... | 1 |
#include <pthread.h>
int n = 0, m = 0, w = 0, c = 0;
pthread_mutex_t lock;
int work(int a, int b) {
return a * b;
}
void* PrintHello(void* threadid)
{
int i,j;
for (i = 0; i < m; ++i) {
pthread_mutex_lock(&lock);
printf("%ld", (pthread_t)threadid);
pthread_mutex_unlock(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int main(int argc, char** argv)
{
int err;
pthread_mutexattr_t mtxattr;
err = pthread_mutexattr_init(&mtxattr);
if(err)
err_abort(err, "pthread_mutexattr_init");
pthread_mutex_init(&mutex, &mtxattr);
pthread_mutex_lock(&mutex);
printf("ma... | 1 |
#include <pthread.h>
void
_pager_clean (void *arg)
{
struct pager *p = arg;
if (p->pager_state != NOTINIT)
{
pthread_mutex_lock (&p->interlock);
_pager_free_structure (p);
pthread_mutex_unlock (&p->interlock);
}
pager_clear_user_data (p->upi);
}
| 0 |
#include <pthread.h>
struct node {
int val;
struct node* next;
struct node* prev;
};
pthread_mutex_t mt;
pthread_mutexattr_t attr;
struct list {
int count;
struct node *head;
struct node *tail;
pthread_mutex_t *mutex;
};
struct list *memhead = 0;
struct node* getn... | 1 |
#include <pthread.h>
void
pbuf_debug(void)
{
}
struct pbuf *
pbuf_alloc(unsigned int len)
{
struct pbuf *p;
p = malloc(sizeof(struct pbuf));
if (p != 0) {
p->len = len;
}
return p;
}
int
pbuf_free(struct pbuf *p)
{
free(p);
return 0;
}
int
pbufq_init(struct pbufq *pbuf... | 0 |
#include <pthread.h>
extern pthread_mutex_t write_log_mutex ;
void write_log(const char logtype, const char *format, ...)
{
char buf[256];
va_list arg;
memset(buf, 0, 256);
switch(logtype & 126)
{
case 2:
strcat(buf, "[--]\\t");
break;
case 4:
strcat(buf, "[WW]\\t");
... | 1 |
#include <pthread.h>
extern int K;
extern int VECT_SIZE;
extern int aHash[10];
extern int bHash[10];
extern int m[10];
pthread_t ids[48];
int nextLoc = -1;
pthread_mutex_t m_nextLoc;
int totalOnes = 0;
pthread_mutex_t m_totalOnes;
int numMemberships = 0;
pthread_mutex_t m_numMemberships;
in... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int brightness, duration;
struct Node* next;
} Node_t;
Node_t* front;
Node_t* back;
} Queue_t;
void addToQueue(Queue_t* queue, int brightness, int duration) {
Node_t* newNode = malloc(sizeof(Node_t));
newNode->brightness = brightness;
n... | 1 |
#include <pthread.h>
void funcCreateThread();
void *evenThread(void *);
void *oddThread(void *);
int evenOddThread(int);
int count;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
int main ()
{
funcCreateThread();
while(1);
return 0... | 0 |
#include <pthread.h>
pthread_mutex_t m;
void handle(void* data){
printf("thread [%s] exit........\\n",data);
pthread_mutex_unlock(&m);
}
void* runo(void*d){
int i;
for(i = 0 ;;i += 2){
pthread_mutex_lock(&m);
printf("%d\\n",i);
pthread_mutex_unlock(&m);
}
}
void* runa(void*d){
int i... | 1 |
#include <pthread.h>
int a = 0;
int threadsNum;
pthread_mutex_t mut;
int* massiv;
int mas_size;
int limit;
int next;
pthread_mutex_t mut;
void initializing(){
massiv[0] = 1;
massiv[3] = 1;
massiv[5] = 1;
massiv[7] = 1;
massiv[8] = 1;
massiv[9] = 1;
}
void get_next(){
wh... | 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) {... | 1 |
#include <pthread.h>
void * other(void * unused){
while(1)
kitsune_update("testkick");
}
void * testwait(void * unused){
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
while(1)
{
kitsune_update("testwait");
pt... | 0 |
#include <pthread.h>
pthread_t thread[3];
pthread_mutex_t mut;
int number = 0, i, j;
void *woker(pthread_t consumer)
{
printf("threadx: I'm thread %lu\\n", consumer);
pthread_mutex_lock(&mut);
for(i = 0; i < 10; ++ i)
{
++ number;
printf("thread: number =... | 1 |
#include <pthread.h>
int N;
int *X;
int gSum[4];
pthread_mutex_t mutex;
void InitializeArray(int **X, int *N)
{
int i;
*N = 20;
*X = (int *)malloc(sizeof(int)*(*N));
for (i = 0; i < *N; i++) {
(*X)[i] = 0;
}
return;
}
void *thread_func(void *pArg)
{
int tNum = *((int *) pAr... | 0 |
#include <pthread.h>
pthread_mutex_t child_mutex = PTHREAD_MUTEX_INITIALIZER;
volatile int child_waiting = 0;
double endtime;
void usage(void)
{
rt_help();
printf("testpi-1 specific options:\\n");
}
int parse_args(int c, char *v)
{
int handled = 1;
switch (c) {
case 'h':
usage();
exit(... | 1 |
#include <pthread.h>
static pthread_t soundid;
int stopmp3;
void *madplay_run( void *arg)
{
char buff[1024], mp3name[512], *item, *start;
int i = 0;
struct st_action_unit *unit = (struct st_action_unit *)arg;
printf("== madplay_run ==\\n");
printf("mp3 = %s\\n", unit->mp3sdata);
age:
start = ... | 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>
pthread_mutex_t M1= PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t M2= PTHREAD_MUTEX_INITIALIZER;
void* producer_routine(void* arg)
{
while(1)
{
if( 0 == pthread_mutex_lock(&M1))
{
if( 0 ==pthread_mutex_lock(&M2))
{
printf("\\n %s Got lock M1 and M2\\n",__func__);
}... | 0 |
#include <pthread.h>
void *philosopher (void *id);
void grab_chopstick (int, int, char*);
void down_chopsticks (int, int);
int food_on_table ();
int get_token ();
void return_token ();
pthread_mutex_t chopstick[5];
pthread_mutex_t print;
pthread_t philo[5];
pthread_mutex_t food_lock;
pthre... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
void *threadCounter(void *param){
int *args = (int *)param;
int i;
for(i = 0; i < 1000000; i++){
pthread_mutex_lock(&lock);
(*args)++;
pthread_mutex_unlock(&lock);
}
}
int main(int argc, char** argv){
pthread_t t1;
pthread_t t2;
int shared =... | 0 |
#include <pthread.h>
static int global = 0;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
void *func(void *arg)
{
int local, i;
for (i=0; i<1000000; i++) {
pthread_mutex_lock(&mylock);
local = global;
local++;
global = local;
pthread_mutex_unlock(&mylock);
... | 1 |
#include <pthread.h>
static int Resource_Counter = 0;
static pthread_mutex_t Resource_Counter_Mutex =
PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t Got_Resources_Condition =
PTHREAD_COND_INITIALIZER;
static void *producer_start(void *arg) {
static const size_t TIMES_TO_PRODUCE =... | 0 |
#include <pthread.h>
int value;
int n_wait;
pthread_mutex_t lock;
pthread_cond_t cond;
}sem_t;
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t *sem);
int sem_post(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_getvalue(sem_t *sem, int *sval);
int sem_des... | 1 |
#include <pthread.h>
struct data_t
{
char q[100][1025];
pthread_mutex_t lock;
pthread_cond_t cond;
int now;
int next;
int isfull;
int tnum;
};
char cmdlist[100][2048];
int cmdlist_len = 0;
pthread_mutex_t lock_fd;
void parse_cmd(char *args[100], char *cmd)
{
int in_q = 0;
int is_q_doubl... | 0 |
#include <pthread.h>
void * fonc_P0(void *num)
{
while (*stop==0){
pthread_mutex_lock (&voieGL);
if(aig2->occupee == 0 && aig2->reservee == 0){
if(aig2->TGV >0){
sem_post(aig2->semTGV);
}
else if(aig2->GL>0){
sem_post(aig2->semGL);
}
}
if((voieC->occupee+voieC->reserv... | 1 |
#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)
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex[2];
pthread_cond_t cond[2];
pthread_mutex_t mutexMain;
pthread_cond_t condMain;
double **matrixA;
double **matrixB;
double **matrixC;
int mA, nA, mB, nB;
int row;
int col;
int valid;
} Job;
Job jobs[2];
double** createMatrix(int m, int n) {
... | 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 = localt... | 0 |
#include <pthread.h>
static pthread_mutex_t CS;
void XoInitCS(void)
{
pthread_mutex_init(&CS,0);
}
void XoEnterCS(void)
{
pthread_mutex_lock(&CS);
}
void XoLeaveCS(void)
{
pthread_mutex_unlock(&CS);
}
| 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail... | 0 |
#include <pthread.h>
static pthread_mutex_t my_mutex;
int sockfd;
int gcondition=1;
void *writing_process(void *arg){
int i=0;
char buffer[256];
while(1){
bzero(buffer,256);
fprintf(stderr,"%d Please enter the message: ", i++);
fgets(buffer,255,stdin);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t sig_consumer = PTHREAD_COND_INITIALIZER;
pthread_cond_t sig_producer = PTHREAD_COND_INITIALIZER;
int buffer, waiting;
int result[100];
void calculate_result(int task_id)
{
int i, t_result = 0;
for(i... | 0 |
#include <pthread.h>
lge_t lock_table[TBLENTRIES];
pthread_mutex_t initializer_lock = PTHREAD_MUTEX_INITIALIZER;
int
page_lock(void *va)
{
int i;
lge_t *lge = &lock_table[PGX(va)];
if(! *lge) {
pthread_mutex_lock(&initializer_lock);
*lge = malloc(sizeof(lue_t) * TBLENTRIES);
... | 1 |
#include <pthread.h>
int is_prime(uint64_t p)
{ uint64_t premier = 0;
uint64_t i=2;
while (i<p && premier==0)
{ if (p%i==0)
{ premier=1;
}
i++;
}
return premier;
}
void print_prime_factors(uint64_t n)
{ printf("%lu:", n);
uint64_t i=2;
while (i<=n)
{ if (n%i==0)
{ printf(" %lu"... | 0 |
#include <pthread.h>
int feed_conn(int fd)
{
char buffer[1024];
int retval;
if ((retval = recv(fd, buffer, 1024, 0)) <= 0)
return retval;
struct http_head request_head;
parser_head(buffer, &request_head, retval);
char head[HEAD_MAX_LEN];
if (request_head.metho... | 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 thread_lock;
sem_t thread_count;
int *arr;
struct node
{
int l;
int r;
};
void merge(int low, int high)
{
int mid = (low+high)/2;
int left = low;
int right = mid+1;
int b[high-low+1];
int i, cur = 0;
... | 1 |
#include <pthread.h>
int max;
long nbThreads;
int attente;
pthread_cond_t sync_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t sync_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t nbT_mutex = PTHREAD_MUTEX_INITIALIZER;
void* func_ecoute(void* arg) {
pthread_mutex_lock(&nbT_mutex);
nbThr... | 0 |
#include <pthread.h>
float choix(void* code, int nb_fichiers, float* retour_chef){
if(code == max){
return max_tab(nb_fichiers, retour_chef);
}
if(code == min){
return min_tab(nb_fichiers, retour_chef);
}
if(code == avg){
return avg_tab(nb_fichiers, retour_chef);
}
if(code == sum){
... | 1 |
#include <pthread.h>
int num_chunks = 0;
char *chunks[30000];
int tasks = 0;
int dtasks = 0;
pthread_mutex_t lock;
extern int vm_overload;
void* allocator(void* arg)
{
int i;
(void) arg;
while( 1 ) {
while( vm_overload ) {
sched_yield();
}
pthread_mutex_lock( &lo... | 0 |
#include <pthread.h>
pthread_mutex_t mutex, mutex2;
pthread_cond_t conditions[5];
int sum = 0;
void* thread(void *arg) {
int thread_id = (int)arg;
int local_num;
pthread_mutex_lock(&mutex);
pthread_cond_wait(&conditions[thread_id], &mutex);
pthread_mutex_unlock(&mutex);
printf("Zdra... | 1 |
#include <pthread.h>
int thread_flag;
pthread_cond_t thread_flag_cv;
pthread_mutex_t thread_flag_mutex;
int value;
void initialize_flag()
{
pthread_mutex_init(&thread_flag_mutex, 0);
pthread_cond_init(&thread_flag_cv, 0);
thread_flag = 0;
}
void do_work()
{
value++;
printf("+1: %d\\n", value... | 0 |
#include <pthread.h>
int total_produced = 0;
void *produce(void *);
void *consume(void *);
int tmp[5];
int main(int argc, char* argv[]){
pthread_t thread1[5];
pthread_t thread2;
int i, j;
for (j=0; j<5; j++) {
tmp[j] = j;
if ((i=pthread_create(&thread1[j], 0, ... | 1 |
#include <pthread.h>
buffer_item buffer[5];
void initializeBuffer();
void *producer(void *param);
void *consumer(void *param);
int insert_item(buffer_item item);
int remove_item(buffer_item *item);
void sig_handler(int);
pthread_mutex_t mutex;
int counter, first, last;
int flag = 0;
se... | 0 |
#include <pthread.h>
char *resurs;
pthread_mutex_t mutex;
int max;
}resurs_t;
resurs_t res;
int goodbye;
void *tr_consol (void *n) {
static int y = 0;
int ii = 0;
int one = 0;
int zero = 0;
while (!goodbye) {
pthread_mutex_lock (&res.mutex);
for (ii=0; ii<r... | 1 |
#include <pthread.h>
struct async_buffer {
pthread_cond_t cond;
pthread_mutex_t mtx;
void *buffer;
size_t buffer_read_index;
size_t buffer_write_index;
size_t buffer_size;
size_t buffer_room_left;
int flags;
};
struct async_buffer *
async_buffer_new(size_t s, i... | 0 |
#include <pthread.h>
int sum;
int cpt=0;
int print_flag=0, fin_flag=0;
pthread_mutex_t mutex, mutex_fin;
pthread_cond_t cond_print, cond_fin;
void * thread_rand(void * i){
int random_val = (int) (10*((double)rand())/ 32767);
printf("tid: %u;\\trandom_val: %d\\n",(unsigned int)pthread_se... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t thereAreOxygen, thereAreHydrogen;
pthread_t oxygen, hydrogen[2];
int numberOxygen = 0 , numberHydrogen=0;
int activeOxygen = 0 , activeHydrogen=0;
int currentOxygen = 0 , currentHydrogen=0;
void dataIn(){
int var=0;
if(numberHydrog... | 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;
static void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
... | 1 |
#include <pthread.h>
static pid_t tids[128];
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
int tlocker_acquire() {
int i;
int rem = -1;
pid_t ctid = syscall(SYS_gettid);
;
pthread_mutex_lock(&mtx);
for (i = 0; i < 128; i++ ){
if (rem == -1 && tids[i... | 0 |
#include <pthread.h>
struct to_info {
void *(*fn)(void *);
void *to_arg;
int to_wait;
};
void *timer_helper(void *arg) {
struct to_info *tip;
tip = (struct to_info *)arg;
printf("sleep for %d secs\\n", tip -> to_wait);
sleep(tip -> to_wait);
(tip -> fn)(tip -> to... | 1 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int value = 0;
void* thread(void* arg) {
int id = (int)arg;
char run = 1;
while (run) {
pthread_mutex_lock(&mut);
pthread_cond_wait(&cond, &mut);
if (value < 0)
run ... | 0 |
#include <pthread.h>
int c[10];
pthread_mutex_t global_mutex;
pthread_mutex_t local_mutex[10];
pthread_cond_t nains;
unsigned int num_nains = 0;
void enter_critical_local(int i, int j){
pthread_mutex_lock (&local_mutex[(i<j)?i:j]);
pthread_mutex_lock (&local_mutex[(i<j)?j:i]);
pthr... | 1 |
#include <pthread.h>
static void *process_function(void *);
static void process_function_actual(int job_type);
static int process_judege(struct Job *job);
static char current_dictionary[100];
extern void save_environment_init(){
time_t nowtime;
memset(current_dictionary,0,sizeof(current... | 0 |
#include <pthread.h>
void *customerMaker();
void *barberShop();
void *waitingRoom();
void checkQueue();
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t sleep_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t barberS... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t threads[MAX_THREADS];
struct timespec start_ts[MAX_THREADS];
struct timespec end_ts[MAX_THREADS];
int request_serviced[MAX_THREADS];
int n_threads = DEFAULT_N_THREADS;
int job_size = DEFAULT_JOB_SIZE;
int n_jobs = (DEFAULT_N_THREADS*DEFAUL... | 0 |
#include <pthread.h>
pthread_cond_t taxiCond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t taxiMutex = PTHREAD_MUTEX_INITIALIZER;
void *traveler_arrive(void *name){
printf("Traveler %s needs a taxi now!\\n", (char *)name);
pthread_mutex_lock(&taxiMutex);
pthread_cond_wait(&taxiCond, &taxiMut... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condc, condp;
{
pthread_t evm[5];
int buffer[5];
}booth;
booth booths[3];
pthread_t voters[15];
int buffer = 0;
int no_booths = 3,no_voters =15, no_evms = 5,no_slots = 2;
void* polling_ready_booth(void *ptr)
{
int i;
for (i = 1; i <= no... | 0 |
#include <pthread.h>
pthread_t cons[2];
pthread_t prod[2];
pthread_mutex_t buffer_mutex;
int buffer[1000];
int prod_pos=0, cons_pos=0;
sem_t free_positions, filled_positions;
void *produtor(void *arg) {
int n;
while(1) {
n = (int)(drand48() * 1000.0);
sem_wait(&free_positions);
pthrea... | 1 |
#include <pthread.h>
int kvm_run_init(int vcpufd, struct kvm_run_info *info) {
int rval = 0;
sigset_t set;
struct kvm_signal_mask *arg;
arg = malloc(sizeof(*arg) + sizeof(set));
if (arg == 0) {
return ENOMEM;
}
if (pthread_mutex_init(&info->lock, 0) < 0) {
... | 0 |
#include <pthread.h>
pthread_mutex_t muteks;
pthread_t watki[2];
double global_array_of_local_sums[2];
void *suma_w( void *arg_wsk);
void *suma_w_no_mutex( void *arg_wsk);
double *tab;
double suma=0;
int main( int argc, char *argv[] ){
int i;
double t1,t2,t3;
int indeksy[2];
for... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *increment(void *ptr)
{
int *i = ptr;
for(int j=0;j<1000000;j++)
{
pthread_mutex_lock(&mutex);
*i=*i+1;
pthread_mutex_unlock(&mutex);
}
return 0;
}
int main(int argc, char **argv)
{
int i = 0;... | 0 |
#include <pthread.h>
void *anti_syn_flood_check(void *I_do_not_use_this_var )
{
int n;
struct timeval begin;
int count;
gettimeofday(&begin,0);
for (n=count=0 ; n < e->max_tab_size ; n++)
if (e->msg_tab[n].c_syn_tv_sec && (begin.tv_sec - e->msg_tab[n].c_syn_tv_sec) > GARBAGE_RETE... | 1 |
#include <pthread.h>
static int localId = 0;
static pthread_mutex_t onLineIdMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t regAsClientMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t regAsServerMutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t frameBufferMutex = PTH... | 0 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
extern void __VERIFIER_error() ;
int element[(800)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(800)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int ... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(800)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(800)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int nreaders = 0, writing = 0;
void
acquire_read_lock()
{
pthread_mutex_lock(&mutex);
while(writing)
pthread_cond_wait(&cond, &mutex);
++nreaders;
pthread_mutex_unlock(&mutex);
}
void
release_read_lock()
{
pth... | 1 |
#include <pthread.h>
static struct root root = { PTHREAD_MUTEX_INITIALIZER, 0, 0, 0 };
static struct btff* btff = 0;
void *malloc(size_t size)
{
if(0 >= size)
return 0;
else
{
struct stack stack[STACK];
void* ptr;
pthread_mutex_lock(&root.mutex);
if(!btff)
{
posix_memalign((void... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int fd;
char* readline(int fd, char* buffer) {
int i = 0;
for (; read(fd, buffer+i, 1) == 1 && buffer[i] != '\\n'; i++) {}
if (i == 0)
return 0;
buffer[i] = '\\0';
return buffer;
}... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t vacio;
pthread_cond_t lleno;
int raciones = 0;
void *Cocinero(void *arg);
void *Salvaje(void *arg);
int main(int argc, char *argv[]){
pthread_t th1, th2, th3, th4, th5;
pthread_mutex_init(&mutex, 0);
pthread_cond... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void segFaultMe();
void threadBody( void *ptr ) {
int lockMe = (int)ptr;
if (lockMe) pthread_mutex_lock(&mutex);
segFaultMe();
if (lockMe) pthread_mutex_unlock(&mutex);
}
void shutdownHook() {
printf("shutdownHook...\\n");
if (pthread_mute... | 1 |
#include <pthread.h>
pthread_mutex_t m;
int sum;
char* fn;
void* func(void* ar)
{
FILE* pt;
int number;
char cmd[100], result[100];
char* arg=(void*)ar;
sprintf(cmd, "grep -o '\\\\<%s\\\\>' %s | wc -w", arg, fn);
pt=popen(cmd, "r");
fgets(result, 20, pt);
pclose(pt);
number=atoi(r... | 0 |
#include <pthread.h>
static char *page;
static int page_len;
static pthread_mutex_t _syscall_mtx;
long offset = 0;
void usage(const char *argv0)
{
fprintf(stderr, "usage:%s page_size(KB) num_page\\n", argv0);
exit(1);
}
static void recover(void)
{
printf("hello: recovered fro... | 1 |
#include <pthread.h>
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.tv_nsec * 1000;
}
void *timeout_helper(void *arg) ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
int buffer[2];
int buf_first=0;
int buf_last=0;
int buf_count=0;
void produce(int val)
{
pthread_mutex_lock(&mutex)... | 1 |
#include <pthread.h>
int nthreads = 40;
int *array;
int array_length = 2000;
int *state;
pthread_mutex_t *lock;
pthread_cond_t *sorted_cond;
int poll = 0;
pthread_mutex_t poll_lock;
pthread_cond_t poll_cond;
int check(int start, int end){
while(start<end){
if(array[star... | 0 |
#include <pthread.h>
int buf[5];
size_t len;
pthread_mutex_t mutex;
pthread_cond_t can_produce;
pthread_cond_t can_consume;
} buffer_t;
void* producer(void *arg) {
buffer_t *buffer = (buffer_t*)arg;
while(1) {
pthread_mutex_lock(&buffer->mutex);
if... | 1 |
#include <pthread.h>
int intValue(char *s) {
int i = 1;
unsigned int result = s[0] - '0';
while(s[i] != 0) {
result *= 10;
result += s[i] - '0';
i++;
}
return result;
}
pthread_mutex_t l;
unsigned long long int S = 0;
int step;
void* thrd(void* arg) {
unsigned long lon... | 0 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
struct foo *f_next;
};
struct foo * foo_alloc(int id) {
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(st... | 1 |
#include <pthread.h>
int numero;
int priority;
}ThreadParam;
pthread_mutex_t mutex;
void *ThreadSetPriority(void *arg) {
pthread_mutex_lock(&mutex);
ThreadParam *param = (ThreadParam *)arg;
printf("Priorité actuelle: %d\\n", getpriority(PRIO_PROCESS, syscall(SYS_gettid)));
printf("... | 0 |
#include <pthread.h>
int main(int argc, char** argv) {
if(argc != 4 && argc != 5){
printf("Bad number of args\\n");
return 1;
}
if(argc == 5 && strcmp(argv[4], "-i") != 0){
printf("%s\\n", "Wrong option on the end. Try '-i'");
return 1;
}
else{
... | 1 |
#include <pthread.h>
int sock_id;
int port_num;
int bind_ret;
int acc_ret;
struct sockaddr_in server_addr;
struct sthread {
int free;
int desc;
pthread_mutex_t mutex;
pthread_cond_t cond;
};
volatile int numconnected;
struct sthread arr[3];
pthread_t arrthread[3];
int i;
pt... | 0 |
#include <pthread.h>
pthread_mutex_t m[2];
pthread_t t[2];
int sum;
void* doIt(void *arg) {
int id = *(int *)arg, n;
while(sum < 100) {
pthread_mutex_lock(&m[id]);
if(sum < 100) {
printf("Thread %d\\nn = ", id);
scanf("%d", &n);
sum +... | 1 |
#include <pthread.h>
char** theArray;
int aSize=100;
int usr_port;
pthread_mutex_t* mutexArray;
void* ServerEcho(void *args);
int main(int argc, char * argv []){
int n = atoi(argv[2]);
usr_port = atoi(argv[1]);
if( (n==10)||(n==100)||(n==1000)||(n==10000) ){
aSize=n;
}
struct sock... | 0 |
#include <pthread.h>
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
pthread_cond_t start = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int tasks;
void *task()
{
pthread_mutex_unlock(&mutex);
for(int i = 1; i <= 4; i++)
{
printf("Trabajando...... | 1 |
#include <pthread.h>
int NO_READERS;
int NO_WRITERS;
int NO_READERS_READING = 0;
int NO_WRITERS_WRITING = 0;
bool VERBOSE;
pthread_mutex_t resourceMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t readerMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t serviceMutex = PTHREAD_MUTEX_INITIALIZER;
... | 0 |
#include <pthread.h>
void *threadfunc(void *arg);
pthread_mutex_t mutex;
pthread_cond_t cond;
int started;
int
main(int argc, char *argv[])
{
int ret, i;
pthread_t new;
void *joinval;
char *mem;
int fd;
mem = malloc(1<<20);
if (mem == 0)
err(1, "malloc");
fd = open("/dev/urando... | 1 |
#include <pthread.h>
char stanje[ 5 ];
int vilica[ 5 ];
pthread_cond_t uvjet[ 5 ];
pthread_mutex_t kljuc;
void ispis_stanja( int id ){
int i;
for ( i = 0; i < 5; ++i) {
printf( "%2c", stanje[i] );
}
printf( "(%d)\\n", id );
return;
}
void ulaz_k_o( int id ){
pthread_mutex_lock( &kljuc );... | 0 |
#include <pthread.h>
static int top=0;
unsigned int arr[(5)];
pthread_mutex_t m;
_Bool flag=0;
void *t1(void *arg) {
for(int i=0; i<(5); i++) {
pthread_mutex_lock(&m);
assert(top!=(5));
arr[top]=i;
top++;
printf("pushed element %d\\n", i);
flag=1;
pthread_mutex_u... | 1 |
#include <pthread.h>
struct node {
int value;
sem_t s;
struct node *next;
};
struct llist {
sem_t s;
pthread_mutex_t insert, delete;
struct node *head, *tail;
} List;
void list_init(struct llist *list) {
pthread_mutex_t blank = PTHREAD_MUTEX_INITIALIZER;
list->h... | 0 |
#include <pthread.h>
static pthread_mutex_t *mutex_buf;
void locking_function(int mode, int n, const char *file, int line) {
if (mode & CRYPTO_LOCK)
pthread_mutex_lock(&(mutex_buf[n]));
else
pthread_mutex_unlock(&(mutex_buf[n]));
}
unsigned long id_function() {
return (unsigned long)p... | 1 |
#include <pthread.h>
int capacity = 0;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
void *produce(void *args)
{
int i = 0;
for (; i < 10;) {
pthread_mutex_lock(&mylock);
if (capacity >= 5)
{
printf("缓冲区已满，无法放入产品\\n");
} else {
++capacity;
printf("生产者存入一个产品, 缓冲区大... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.