text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
char task_id;
int call_num;
int ci;
int ti;
int ci_left;
int ti_left;
int flag;
int arg;
pthread_t th;
}task;
void proc(int* args);
void * idle();
int select_proc();
int task_num=0;
int idle_num=0;
int alg;
int curr_proc=-1;
int demo_time=100;
task* tasks;
pthread... | 1 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void* thr_func1(void* arg) {
printf("1: In thread function 1\\n1: Getting lock1...\\n");
pthread_mutex_lock(&lock1);
printf("1: Get lock1\\n1: Getting lock2...\\n... | 0 |
#include <pthread.h>
char *files[5] = { "./Files/1", "./Files/2", "./Files/3", "./Files/4", "./Files/5"};
void *threadReader(void *arg)
{
struct Info *info = (struct Info *)arg;
void (*lib_function)(int, char *);
*(void **) (&lib_function) = dlsym(info->library, "readFromFile");
for(int ... | 1 |
#include <pthread.h>
int map_minerals = 5000;
int minerals = 0;
int n = 0;
int m = 0;
int k = -1;
int command_centers_minerals[12] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
pthread_mutex_t mutex_workers;
pthread_mutex_t mutex_map_minerals;
pthread_mutex_t mutex_minerals;
void* ... | 0 |
#include <pthread.h>
int fumando[3];
int recursos[3];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* administrar(void*);
void* fumador(void*);
int main() {
int i;
for (i = 0; i < 3; ++i) {
fumando[i] = 0;
recursos[i] = 0;
}
srand((int) time(0));
pthread_t agente;
pthread_... | 1 |
#include <pthread.h>
int thread_count;
double a, b, h;
int n, local_n;
double total;
pthread_mutex_t mutex;
double timeval_diff(struct timeval *a, struct timeval *b)
{
return (double)(a->tv_sec + (double)a->tv_usec/1000000) - (double)(b->tv_sec + (double)b->tv_usec/1000000);
}
double Trap(doub... | 0 |
#include <pthread.h>
int val;
struct cell *next;
pthread_mutex_t mutex;
} cell;
cell sentinel = {100, 0, PTHREAD_MUTEX_INITIALIZER};
cell dummy = {-1, &sentinel, PTHREAD_MUTEX_INITIALIZER};
cell *global = &dummy;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void toggle(cell *ls... | 1 |
#include <pthread.h>
static char buffer[2048];
static unsigned int buffer_count=0;
static int debug_nmea;
static int sock;
static struct addrinfo* addr=0;
static pthread_mutex_t message_mutex;
static int initSocket(const char *host, const char *portname);
struct ais_message {
cha... | 0 |
#include <pthread.h>
pthread_mutex_t mutex[4];
int sum = 0;
void* thread(void* arg) {
int thread_id = (int)arg;
int local_num;
pthread_mutex_lock(&mutex[thread_id]);
printf("Zdravo, ja sam nit broj: %d\\nUnesite jedan ceo broj:\\n", thread_id);
scanf("%d", &local_num);
sum += local_nu... | 1 |
#include <pthread.h>
char *src;
char *dst;
} arg;
int count = 0;
pthread_mutex_t lock;
pthread_cond_t done;
void release()
{
pthread_mutex_destroy(&lock);
pthread_cond_destroy(&done);
}
int chkdst(int argc, char **argv) {
int isdir(char *path);
if (argc < 2) {
fprintf(st... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t consumer_started = PTHREAD_COND_INITIALIZER;
char s[10000];
int flag;
void *producer (void *a)
{
int i, j;
flag = 0;
pthread_mutex_lock (&mutex);
printf... | 1 |
#include <pthread.h>
int i;
int acount=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condVar = PTHREAD_COND_INITIALIZER;
int accessible = 1;
void waitMySemaphor();
void signalMySemphor();
void *threadClient(void* args);
void *threadAccount();
void *threadClient(void* ar... | 0 |
#include <pthread.h>
pthread_mutex_t a;
pthread_mutex_t b;
pthread_mutex_t c;
pthread_mutex_t* array[5] = {&a,&b,&c,&a,&c};
void* fn1(void * args){
int x,k,j;
pthread_mutex_lock(array[j]);;
if( x < 0 ){
pthread_mutex_unlock(array[k]);;
j++;
} else {
pthread_mutex_lock(array[x]);;
... | 1 |
#include <pthread.h>
pthread_barrier_t sum_barrier;
pthread_mutex_t sum_mutex1;
int a[1000], sum;
void initialize_array(int *a, int n) {
int i;
for (i = 1; i <= n; i++) {
a[i-1] = i;
}
}
void i_got_serial(int arg) {
printf("I'm such lucky thread, I got serial : %d\\n",... | 0 |
#include <pthread.h>
static char buffer[10];
static unsigned int first;
static unsigned int next;
static int buffer_size;
_Bool send, receive;
pthread_mutex_t m;
void initLog(int max)
{
buffer_size = max;
first = next = 0;
}
int removeLogElement(void)
{
assert(first>=0);
if (ne... | 1 |
#include <pthread.h>
int fifo_fd;
void* free_child_processes(void* parameters)
{
int status;
char buf[MAXBUFLEN];
int port;
int* port_iter;
struct server_pop* sp = (struct server_pop*)parameters;
for(;;)
{
sleep(10);
while ((waitpid(-1, 0, WNOHANG)) > 0)
{
memset(buf, 0, MAXBU... | 0 |
#include <pthread.h>
int main(void){
int *x;
int rt;
int shm_id;
char *addnum="myadd";
char *ptr;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_SHARED);
rt=fork();
if (rt==0){
... | 1 |
#include <pthread.h>
extern struct mosaic mosaic;
static int get_tile_name(long int ntile, char * name) {
const char b32[] = "0123456789abcdefghijklmnopqrstuv";
int i, n;
strcpy(name, "....");
for (i = 0; i < 4; i++) {
n = ntile & 0b011111;
ntile = ntile >> 5;
... | 0 |
#include <pthread.h>
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void * process(void * arg)
{
int i;
fprintf(stderr, "Starting process %s\\n", (char *) arg);
pthread_mutex_lock(&mymutex);
for (i = 0; i < 100; i++) {
write(1, (char *) arg, 1);
}
pthread_mutex_unlock(&mymu... | 1 |
#include <pthread.h>
struct producers{
int buffer[4];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t not_empty;
pthread_cond_t not_full;
};
static void init(struct producers *b){
pthread_mutex_init(&b->lock, 0);
pthread_cond_init (&b->not_empty,... | 0 |
#include <pthread.h>
int myglobal;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_function_datarace(void *arg)
{
int i,j;
for ( i=0; i<20; i++ )
{
j=myglobal;
j=j+1;
printf("\\nIn thread_function_datarace..\\t");
sleep(1);
myglobal=j;
}
... | 1 |
#include <pthread.h>
pthread_mutex_t numLock;
int arr[10];
int odd[10/2];
int even[10/2];
void *findOdd(void*);
void *findEven(void*);
void *findOdd(void *tArgs)
{
int j=0;
for(int i=0;i<10;i++)
{
if((arr[i]&1)>0)
odd[j++]=arr[i];
}
return 0;
}
void *... | 0 |
#include <pthread.h>
{
int data;
struct node *next;
}node_t;
static pthread_key_t thread_log_key;
{
node_t *top;
}stack_t;
stack_t S;
void write_to_thread_log (const char* message)
{
FILE* thread_log = (FILE*) pthread_getspecific (thread_log_key);
fprintf (thread_log, "%s\\t",message);
... | 1 |
#include <pthread.h>
void *Producer();
void *Consumer();
int BufferIndex=0;
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_INITIALIZER;
int main()
{
pthread_t ptid,ctid;
... | 0 |
#include <pthread.h>
int count=1;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *counter(void *t)
{
long my_id=(long)t;
int slp;
pthread_mutex_lock(&count_mutex);
count++;
slp=count;
while (slp=sleep(slp));
if (count == 1+3)
{
pthread_cond_broadcast(&count_... | 1 |
#include <pthread.h>
int buff[10];
int buff_index;
pthread_mutex_t buff_mutex;
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_index];
else
return -1;
}
void* prod... | 0 |
#include <pthread.h>
pthread_t threads[2];
pthread_mutex_t lock[2];
pthread_cond_t cond;
void signal_handler(int signal) {
switch (signal) {
case SIGINT: {
for (int i = 0; i < 2; i++)
pthread_cancel(threads[i]);
} break;
default: break;
... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void
bit_test (void)
{
MY_TYPE v;
v = ~0;
printf ("v (all 1's): %llx\\n", v);
((v) = (v) & ~(((MY_TYPE) 1) << (4)));
printf ("v (one 0) : %llx\\n", v);
if ((((v) & (((MY_TYPE) 1) <... | 0 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
char *s1;
char *s2;
int c;
} SWAP;
SWAP *S = 0;
void initialize(){
printf("init\\n");
S = (SWAP*) malloc(sizeof(SWAP));
S->c = 0;
}
char *swap (char *s){
printf("s:%s\\n"... | 1 |
#include <pthread.h>
int nitems;
struct {
pthread_mutex_t mutex;
int buffer[1000000];
int nputs;
int nval;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
void *producer(void*), *consumer(void*);
int main(int argc, const char** argv)
{
int nthreads, count[100];
pthread_t tid_producer[100], t... | 0 |
#include <pthread.h>
struct json_mode_each_iteration {
pthread_mutex_t mutex;
int cur_iteration;
};
static struct json_mode_each_iteration global_ei;
static int
jc_mode_each_iteration_init(
struct jc_comm *jcc
)
{
global_ei.cur_iteration = jcc->iteration;
if (jcc->mode_type)
free(jcc-... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_mutex_t lock2;
int value;
int value2;
sem_t sem;
void *functionWithCriticalSection(int* v2) {
pthread_mutex_lock(&(lock));
pthread_mutex_lock(&(lock2));
value = value2 + *v2;
value2 = value;
pthread_mutex_unlock(&(lock2));
... | 0 |
#include <pthread.h>
int count;
pthread_mutex_t m;
pthread_cond_t cv;
} barrier_t;
int * input;
int * output;
size_t size = 0;
pthread_t * allThreads;
int threads;
barrier_t ba;
void barrier_init(barrier_t *b, int inThreads){
b->count = inThreads;
pthread_mutex_init(&b->... | 1 |
#include <pthread.h>
struct sunxi_timer_reg {
u32 dummy1[0xc90 / 4];
volatile u32 wdog_ctrl_reg;
volatile u32 wdog_mode_reg;
};
int mem_fd = -1;
volatile unsigned *map_physical_memory(uint32_t addr, size_t len)
{
volatile unsigned *mem;
if (mem_fd == -1 && (mem_fd = ope... | 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) {
err_exit... | 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;
... | 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>
unsigned int counter = 1;
unsigned int result = 0;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t result_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t print_mutex = PTHREAD_MUTEX_INITIALIZER;
void* worker( void* );
void main(void)
{
... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
pthread_cond_t a = PTHREAD_COND_INITIALIZER;
pthread_mutex_t b = PTHREAD_MUTEX_INITIALIZER;
int count = 1;
void *eventhread(){
for(;;){
pthread_mutex_lock(&cou... | 1 |
#include <pthread.h>
pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;
int mean, samples, total;
void *report_stats(void *p)
{
int caught, i;
sigset_t sigs_to_catch;
printf("\\nreport_stats() started.\\n");
sigemptyset(&sigs_to_catch);
sigaddset(&sigs_to_catch, SIGUSR1);
f... | 0 |
#include <pthread.h>
extern FILE *diag;
void *KeyboardThread(void *arg) {
char c=0;
extern pthread_cond_t CommandRecvCond;
extern pthread_mutex_t CommandRecvMutex,CommandGetMutex;
extern int Command;
pthread_setasynccancel(CANCEL_ON);
pthread_setcancel(CANCEL_ON);
while(1) ... | 1 |
#include <pthread.h>
struct matriz_e_tamanho {
double** m;
long n;
double sum;
pthread_mutex_t mutex;
pthread_t thread[2];
pthread_cond_t cond;
};
struct timeval tv1, tv2;
long tID = 0;
int controle_linhas=0;
void *ProcessaMatriz(void *m_n) {
struct matriz_e_tamanho *mat_n = (st... | 0 |
#include <pthread.h>
void *func(void *parm);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int t1_start=0;
int t1_pause=1;
int main()
{
int i, rc;
pthread_t t1;
pthread_create(&t1, 0, func, 0);
while(!t1_start)
sleep(1);
rc = pthread_mutex_trylock(&mutex);
i... | 1 |
#include <pthread.h>
struct tdata {
int tid;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t unLock = PTHREAD_COND_INITIALIZER;
unsigned locked = 0;
void lock() {
pthread_mutex_lock(&mutex);
while (locked) {
pthread_cond_wait(&unLock, &mutex);
}
... | 0 |
#include <pthread.h>
long long int now()
{
struct timeval tv;
gettimeofday(&tv, 0);
return tv.tv_sec*1000LL+tv.tv_usec/1000LL;
}
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_spinlock_t spinlock;
static void test_spinlock(int n)
{
while (n>0)
{
pthread... | 1 |
#include <pthread.h>
int itemCount = 0;
int totalProduced = 0;
int itemsConsumed = 0;
int queue[10*100000];
pthread_mutex_t lock;
pthread_cond_t cond;
int locked;
struct timeval tv1, tv2;
static void * consumerThread(void *arg)
{
char *s = (char *) arg;
printf("%s\\n", s);
while(itemsCons... | 0 |
#include <pthread.h>
double sum;
long thread_count;
long long n;
pthread_mutex_t mutex;
sem_t semaphore;
void * Thread_mutex_sum(void * rank) {
long my_rank = (long) rank;
double factor;
double my_sum = 0.0;
long long i;
long long my_n = n / thread_count;
long long my_firs... | 1 |
#include <pthread.h>void *graficar()
{ int i,j;
start_color();
init_pair(5,COLOR_RED,COLOR_RED);
init_pair(2,COLOR_GREEN,COLOR_GREEN);
init_pair(6,COLOR_BLUE,COLOR_BLUE);
init_pair(4,COLOR_MAGENTA,COLOR_MAGENTA);
init_pair(1,COLOR_YELLOW,COLOR_YELLOW);
init_pair(3,COLOR... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int max=3;
int nbthreads=0;
void* thread_func(void* arg) {
pthread_mutex_lock(&mutex);
nbthreads++;
printf ("Nombre de threads : %d\\n",nbthreads);
pthread_mutex_un... | 1 |
#include <pthread.h>
int cubbyhole[ 3 ] = {0};
int load = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER ;
pthread_cond_t notFull = PTHREAD_COND_INITIALIZER ;
pthread_cond_t notEmpty = PTHREAD_COND_INITIALIZER ;
inline void produce() { usleep( rand() % 500000 ); }
inline void consume... | 0 |
#include <pthread.h>
static pthread_mutex_t mutexsum;
static pthread_barrier_t barrier;
static int iteration = 1000;
static int max_thr = 1;
static int comp_A = 15;
static int comp_B = 15;
volatile int sum = 0;
volatile int finished = 0;
void stack_prefault(void)
{
unsigned char d... | 1 |
#include <pthread.h>
int wyniki[100];
int liczbaLiczbPierwszych;
int tablicaLiczbPierwszych[100];
pthread_mutex_t m_p;
void zapisDoTablicy(int argLiczba){
pthread_mutex_lock(&m_p);
tablicaLiczbPierwszych[liczbaLiczbPierwszych] = argLiczba;
liczbaLiczbPierwszych++;
pthread_mutex_unlock(&m... | 0 |
#include <pthread.h>
extern void thread_join_int(pthread_t tid, int *rval_pptr);
extern int My_pthread_create(pthread_t *tidp, const pthread_attr_t *attr, void *(*start_rtn)(void *), void *arg);
int My_pthread_cancel(pthread_t tid)
{
int result=pthread_cancel(tid);
if(0!=result)
{
... | 1 |
#include <pthread.h>
pthread_t tCentral;
pthread_t * tUads;
pthread_mutex_t mutexes[5 * 2] = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m_archivo = PTHREAD_MUTEX_INITIALIZER;
void * centralCtrl(void *);
void * threadCtrl(void *);
void cambio(int);
void cambioCritico(int);
FILE * datos;
int medi... | 0 |
#include <pthread.h>
int
srvInitNetTCPPort (unsigned short portnumber)
{
int retval = 0;
struct sockaddr_in myaddr;
int sockfd = 0;
sockfd = socket (AF_INET, SOCK_STREAM, 0 );
if (sockfd < 0)
{
perror ("Unable to create stream socket ");
return -1;
}
bzero ((char *)&myadd... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
sem_t sem;
SharedInt* sip;
void *functionWithCriticalSection(int* v2) {
pthread_mutex_lock(&(sip->lock));
sip->value = sip->value + *v2;
if(sip->value = 1) {
pthread_mutex_unlock(&(sip->lock));
... | 0 |
#include <pthread.h>
int somme_val=0;
int nbre_thread=0;
int signal_envoye=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
void *print_thread(){
pthread_mutex_lock(&mutex);
if(signal_envoye==0){
pthread_cond_wait(&cond, &mutex);
}
print... | 1 |
#include <pthread.h>
int *count;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
struct timeval tv1, tv2;
struct timezone tz1, tz2;
int *duration;
void *inc_count(void *idp)
{
int j,i;
double result=0.0;
for (i=0; i<150; i++) {
pthread_mutex_lock(&count_mutex);
(*co... | 0 |
#include <pthread.h>
int numThreads=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * writeFile(void * fname)
{
pthread_mutex_lock(&mutex);
int threadNum = numThreads++;
pthread_mutex_unlock(&mutex);
int writeCnt=0;
FILE *f = fopen( (char*)fname, "wt" );
if ( !f )
{
fprintf(... | 1 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[2];
pthread_mutex_t mutexsum;
double wallTime()
{
struct timeval tv;
gettimeofday(&tv, 0);
return tv.tv_sec * 1000.0 + tv.tv_usec / 100... | 0 |
#include <pthread.h>
volatile long double pi = 0.0;
pthread_mutex_t piLock;
long double intervals;
int numThreads;
void *computePI(void *id)
{
long double x,
width,
localSum = 0;
int i,
threadID = *((int*)id);
width = 1.0 / intervals;
for(i = threadID ; i < intervals; i ... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condp,condc;
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;
... | 0 |
#include <pthread.h>
unsigned int TEST_VALUE_RA[2 * 8][3];
int VT_mc13783_RA_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783_RA_cleanup(void) {
int rv = TFAIL;
rv = ... | 1 |
#include <pthread.h>
double *_vector;
double _final_sum;
int *_ranges;
pthread_mutex_t _mutex;
double sum(double* vector, int a, int b) {
double sum = 0.0;
int i = 0;
for (i=a; i<b; i++)
sum += vector[i];
return sum;
}
void* sum_and_add(void* arg) {
int *range_a = (int*) ar... | 0 |
#include <pthread.h>
extern pthread_mutex_t userslock;
void *free_userperm(struct proxy_user *pu) {
struct proxy_user *next_pu;
while( pu ) {
next_pu = pu->next;
free( pu );
pu = next_pu;
}
return 0;
}
void *add_userperm(char* username, char *userspec, struct proxy_user **pu) {
int ... | 1 |
#include <pthread.h>
static pthread_t main_id;
static pthread_t first_id;
static pthread_t second_id;
static pthread_mutex_t mymutex;
static int sum;
static void *body1(void)
{
int adder=2;
while(sum<300)
{
usleep(100);
pthread_mutex_lock(&mymutex);
sum+=adder;
printf("thread 1 a... | 0 |
#include <pthread.h>
struct list {
int data;
pthread_mutex_t lock;
struct list *next;
};
pthread_mutex_t global_lock;
struct list *shared = 0;
void *run(void *arg) {
struct list *cur;
pthread_mutex_lock(&global_lock);
for (cur = shared; cur; cur = cur->next) {
int *data = &c... | 1 |
#include <pthread.h>
double *arrayA;
double *arrayB;
double sumResult = 0;
pthread_mutex_t sb;
void *dot_product(void *tid)
{
long int thid;
int i;
double sumloc = 0;
thid = (long int) tid;
for(i=thid; i<10000000; i+=1)
{
sumloc += arrayA[i]*arrayB[i];
... | 0 |
#include <pthread.h>
pthread_mutex_t chopsticks[5];
void printhelpertabs(int n)
{
int i;
for(i=0; i<n ;i++)
{
printf("\\t");
}
}
void * eat(void *arg)
{
int id = (int)arg;
int eatcount = 0;
int chopsticknum1,chopsticknum2;
while(eatcount < 2)
{
if(id ==0)
... | 1 |
#include <pthread.h>
int running = 1;
void signal_handler(int sig)
{
printf( "Signal caught - cleaning up and exiting..\\n" );
running = 0;
}
void *ledControl(void *ptr)
{
struct pollfd fdset[1];
int button_fd, rc;
char buf[64];
unsigned int green_led, red_led, button;
int len, *led_colo... | 0 |
#include <pthread.h>
int G_CHUNK_SIZE = 1000;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
large_uint G_current_start;
large_uint G_subset_count;
int G_terminated_flag = 0;
large_uint G_steps = 0;
void increment_step() {
pthread_mutex_lock(&mutex);
G_steps++;
pthread_mutex_unlock(&mute... | 1 |
#include <pthread.h>
void shuffle(int* intArray, int arrayLen) {
int i=0;
for (i=0; i<arrayLen; i++) {
int r = rand()%arrayLen;
int temp = intArray[i];
intArray[i] = intArray[r];
intArray[r] = temp;
}
}
int main(int argc, char *argv[]) {
if (argc<3) {
printf... | 0 |
#include <pthread.h>
struct thread_arg {
int id;
int seats_a;
int* tickets;
pthread_mutex_t* tickets_mut;
};
void* work( void* t_arg);
int rand_20();
int rand_1_4();
int main( int argc, char *argv[]){
if( argc != 4){
printf( "error: not exactly 3 args\\n");
exit( -1);}
size_t... | 1 |
#include <pthread.h>
const int cells_to_fill = 20000000 / 4;
volatile int running_threads = 0;
pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;
int array[20000000];
void *startThread(void *vargp)
{
int myid = (int)vargp;
if (0) {
printf("Thread %d starting...\\n",... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_set_state = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_full_dishes = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
int capacity;
void dishes_init(int size) {
capacity = size;
dishes = malloc(sizeof(s... | 1 |
#include <pthread.h>
pthread_mutex_t pelock = PTHREAD_MUTEX_INITIALIZER;
int threadready = 0;
pthread_cond_t peready = PTHREAD_COND_INITIALIZER;
int threadexit = 0;
pthread_cond_t peexit = PTHREAD_COND_INITIALIZER;
void* pe_thread(void* param)
{
int pe;
if ( (pe = pe_init()) < 0 )
{... | 0 |
#include <pthread.h>
void usage(char *prog) {
fprintf(stderr, "usage: %s [-v] [-n num]\\n", prog);
exit(-1);
}
int verbose;
int nthread=2;
char *dir="/tmp";
char *file;
struct work_t *next;
} work_t;
work_t *head,*tail;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t con... | 1 |
#include <pthread.h>
double *x;
double *y;
double *z;
int n;
int sub_n;
}mat_mult_t;
double *z;
int n;
int sub_n;
double *global_norm;
pthread_mutex_t *mutex;
}mat_norm_t;
void *matrix_mult(void *arg){
mat_mult_t *thread_mat_mult_data = arg;
int n =... | 0 |
#include <pthread.h>
int sum_diff;
pthread_mutex_t mutex_sum_diff;
int *data;
int element_num;
int element_size;
} qsort_struct;
int *data;
int start;
int end;
} all_sub_struct;
void disp_arr(int *data, int number);
int compare_func(const void *a, const void*b);
voi... | 1 |
#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_stat;
double sum;
double sum_square;
int count;
void *compute_sum (void *s) {
int j;
int thread_id = (int) s;
int chunk_size = list_s... | 0 |
#include <pthread.h>
struct msg {
struct msg *m_next;
};
struct msg *workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
void
process_msg(void)
{
struct msg *mp;
for (;;) {
pthread_mutex_lock(&qlock);
while (w... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *forfood(void* arg);
int main(void)
{
const int ppl_n = 1000;
pthread_t ppl[ppl_n];
int i;
int count = 0;
for(i=0; i<ppl_n; i++) {
Pthread_create(&ppl[i], 0... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
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 |
#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)
err_exit(err,"sigwait... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
void* p_func(void* p)
{
pthread_mutex_lock(&mutex);
int ret;
printf("I am child,I am here\\n");
ret=pthread_cond_wait(&cond,&mutex);
if(0!=ret)
{
printf("pthread_cond_wait ret=%d\\n",ret);
}
printf("I am child thread,I am... | 1 |
#include <pthread.h>
float x;
float y;
float z;
} Point;
struct dist_args {
int start;
int end;
};
static Point cities[20];
static float distances[20];
static int cities_cnt = 0;
static float averageDist = 0;
pthread_mutex_t lock;
pthread_t * threads;
static void *calc_distance(void *... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void* thread_worker(void*);
void critical_section(int thread_num, int i);
int main(void)
{
int rtn, i;
pthread_t pthread_id = 0;
rtn = pthread_create(... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int data;
int turn=0;
long int sum=0;
long num=0;
int count=0;
long double sd=0;
long double avg=0;
main()
{
pthread_t thread1;
pthread_t thread2;
pthread_t final_thread;
void *thread1Function();
void *thread2Funct... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg... | 1 |
#include <pthread.h>
sem_t items;
sem_t spaces;
pthread_mutex_t mutex;
int item_id = 0;
unsigned long rdnumber()
{
unsigned long number;
number = genrand_int32();
return number;
}
{
int id;
unsigned long waitTime;
int buffer_index;
}Item;
struct Buffer{
Item m_it... | 0 |
#include <pthread.h>
int Resource = 0;
pthread_mutex_t Mutex;
void *producer(void *arg)
{
while (1)
{
pthread_mutex_lock(&Mutex);
if (Resource == 0)
{
Resource += 5;
printf("producer\\n");
}
pthread_mutex_unlock(&Mutex);
sleep... | 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_to... | 0 |
#include <pthread.h>
char** theArray;
int num_str;
double total;
int readers;
int writer;
pthread_cond_t readers_proceed;
pthread_cond_t writer_proceed;
int pending_writers;
pthread_mutex_t read_write_lock;
} mylib_rwlock_t;
void mylib_rwlock_init (mylib_rwlock_t *l) {... | 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>
pthread_mutex_t art_at_ctrMutex = PTHREAD_MUTEX_INITIALIZER;
const char *str_at_res_code[ ] =
{
"OK\\r\\n",
"ERROR",
"NO CARRIER\\r\\n",
"NO DIALTONE\\r\\n",
"BUSY\\r\\n",
"NO ANSWER\\r\\n",
"DELAYED\\r\\n",
"CONNECT\\r\\n",
"RING\\r\\n"... | 1 |
#include <pthread.h>
int open_socket(char * hostname, int port);
char *generate_get_command(const char * url, char *buf, size_t size);
int s;
int lines=0;
int maxlines=25;
char buf[4096];
int lowmark=0, highmark=0;
int empty=1, full=0, eof=0;
pthread_mutex_t bufmx=PTHREAD_MUTEX_IN... | 0 |
#include <pthread.h>
{
double *matrix;
double *vector;
double *result;
int n;
int thread_num;
int total_threads;
} ARGS;
static long int threads_total_time = 0;
static pthread_mutex_t threads_total_time_mutex
= PTHREAD_MUTEX_INITIALIZER;
static void * matrix_mult_vector_thr... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void
thread_init(void)
{
pthread_mutexattr_t mutexattr;
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECUR... | 0 |
#include <pthread.h>
struct tdata {
int tid;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int padding[64];
int counter[ARRAY_SIZE];
void *count(void *ptr) {
long i, max = MAX_COUNT/NUM_THREADS;
int tid = ((struct tdata *) ptr)->tid;
for (i=0; i < max; i++) {
... | 1 |
#include <pthread.h>
uint64_t TimeNowInSec (void) {
return get_currenttime_in_ms() / 1000;
}
int32_t MsgDup(uint8_t *pMsgIn, uint8_t **ppMsgOut, int32_t iLen )
{
uint8_t *pMsg;
pMsg = malloc(iLen);
if( pMsg == 0 )
return 0;
memcpy(pMsg, pMsgIn, iLen );
*ppMsgO... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.