text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static unsigned int freqScanStartFreq;
static unsigned int freqScanEndFreq;
unsigned char freqScanDriAmp;
unsigned short freqScanRes;
unsigned short freqScanDelay;
static short freqScanAmpBuf[518];
static short freqScanPhaseBuf[518];
void setFreqRange(unsigned int sta... | 1 |
#include <pthread.h>
const int NN = 10;
const long TOP = 1000000000;
long sum;
pthread_mutex_t mutex;
long r0;
long r1;
} sum_job;
void*
sum_range_thread(void* arg)
{
sum_job job = *((sum_job*) arg);
free(arg);
for (long ii = job.r0; ii < job.r1; ++ii) {
if (ii %... | 0 |
#include <pthread.h>
volatile int s = 0;
pthread_mutex_t mutex;
void *ExecutaTarefa (void *threadid) {
int i, tid = *(int*) threadid;
printf("Thread : %d esta executando...\\n", tid);
for (i=0; i<10000000; i++) {
pthread_mutex_lock(&mutex);
s++;
pthread_mutex_unloc... | 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>
const int NUM_THREADS = 64;
const int ITERATIONS = 100;
int x;
int y;
} point;
float best_cost = FLT_MAX;
point* points;
int* best_path;
float** distances;
int num_coords;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void readFile(char* filename) {
FILE... | 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 failed");
swi... | 0 |
#include <pthread.h>
int read_cnt=0;
int write_flag=1;
pthread_mutex_t read_cnt_mutex,access_mutex,write_flag_mutex;
int cnt=3;
void* write_handler(void* arg);
void* read_handler(void* arg);
int main(){
int type;
srand(getpid());
pthread_mutex_init(&read_cnt_mutex,0);
pthread_mutex_in... | 1 |
#include <pthread.h>
struct __rbst_node {
char *key;
void *value;
struct __rbst_node *left;
struct __rbst_node *right;
};
static rbst_node* rbst_search(rbst_node* tree, char* key);
static rbst_node* rbst_insert(rbst_node* tree, rbst_node* new_node);
static rbst_node* rbst_deletetree(rbs... | 0 |
#include <pthread.h>
static pthread_mutex_t __atomic_mutex = PTHREAD_MUTEX_INITIALIZER;
int32_t atomic_increment(int32_t *ptr)
{
int32_t r;
pthread_mutex_lock(&__atomic_mutex);
r = ++(*ptr);
pthread_mutex_unlock(&__atomic_mutex);
return(r);
}
int32_t atomic_decrement(int32_t... | 1 |
#include <pthread.h>
static pthread_cond_t main_cond;
static pthread_mutex_t main_lock;
int main(int argc, char** argv)
{
int ret;
int exit = 0;
struct timeval now;
struct timespec outtime;
pthread_mutex_init(&main_lock, 0);
pthread_cond_init(&main_cond, 0);
scorpion_socket_star... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* formarCtrl(void *);
void* pasarCtrl(void *);
int sig = -1;
int dir = -1;
int numM = 0;
int numH = 0;
int flagS = 0;
int ... | 1 |
#include <pthread.h>
int dest[8] = { 0 };
int flag[8] = { 0 };
int me, npes;
int errors = 0;
pthread_barrier_t fencebar;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void * thread_main(void *arg) {
int tid = * (int *) arg;
int i, val, expected;
val = me;
for (i ... | 0 |
#include <pthread.h>
pthread_mutex_t randMutex = PTHREAD_MUTEX_INITIALIZER;
void *work(void *t) {
double *result = malloc(sizeof(double));
int tid = (int)t;
pthread_mutex_lock(&randMutex);
srand(time(0) + (unsigned int)result - (unsigned int)&tid * 5 * (tid+1));
*resul... | 1 |
#include <pthread.h>
int get_rand_int(int range_min, int range_max) {
if (range_min > range_max) {
fprintf(stderr, "gen_random(): invalid arguments\\n" );
exit(1);
}
return range_min+rand()%(range_max-range_min+1);
}
void* cst_func(void* args) {
int i = 0, cid = 0, st_id = 0, stf_num =... | 0 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
unsigned long head;
unsigned long tail;
} sem_fifo_t;
void wait(sem_fifo_t *queue)
{
unsigned long position;
pthread_mutex_lock(&queue->mutex);
position = queue->tail++;
while (position != queue->head) {
pthread_cond_wa... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
void sender() {
printf("Sender starts ...\\n");
sleep(1);
pthread_mutex_lock(&lock);
pthread_cond_signal(&cond);
pthread_mutex_unlock(&lock);
}
void receiver() {
printf("Receiver starts ...\\n");
pthread_mutex_... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long niter;
int nthread;
double pi;
int count;
void* MonteCarlo(void* arg){
int i,t=0;
double z;
t=niter/nthread;
count=0;
for ( i=0; i<t; i++) {
int random_state = rand();
double x = rand_r(&random_... | 1 |
#include <pthread.h>
int *carpark;
int capacity;
int occupied;
int nextin;
int nextout;
int cars_in;
int cars_out;
pthread_mutex_t lock;
pthread_cond_t space;
pthread_cond_t car;
pthread_barrier_t bar;
} cp_t;
static void * car_in_handler(void *cp... | 0 |
#include <pthread.h>
pthread_mutex_t queue, libraryAccess, readcountMutex;
int readersInLibrary = 0;
sem_t maxThreads;
int N, M, T;
int readersMaxWait = 0, writersMaxWait = 0;
void* writer()
{
sem_wait(&maxThreads);
struct timeval tv;
gettimeofday(&tv, 0);
int waitTime = tv.tv_usec;
pt... | 1 |
#include <pthread.h>
int arr[10 * 5];
int aindex;
pthread_mutex_t mutex;
void *hello(void *thread_id)
{
int i;
int *id = (int *) thread_id;
for (i=1; i<=10 ; i++) {
pthread_mutex_lock(&mutex);
arr[aindex] = (*id)*100+ i;
sleep(1);
aindex = aindex + 1;
pthread_mutex_unlock(&mutex);
... | 0 |
#include <pthread.h>
int apprS = 0;
int depS = 0;
int apprN = 0;
int depN = 0;
int waiting = NO_DIRECTION;
void stop_other_direction() {
if (waiting != NO_DIRECTION) {
if (waiting == NORTH) {
pthread_mutex_lock(&depN_lock);
while (depN > 0) {
... | 1 |
#include <pthread.h>
struct LeaderInfo * leader_genLeaderInfo(){
struct LeaderInfo * li = malloc(sizeof( struct LeaderInfo ));
int i;
for( i = 0; i < MAX_SERVERS; i++ ){
li->serverList[i].inUse = 0;
pthread_mutex_init( &(li->serverLocks[i]), 0 );
}
pthread_mutex_init( &(li->serverList... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int banheiro_cheio = 0;
int mulher_no_banheiro = 0;
int homem_no_banheiro = 0;
int mulheres_na_fila = 0;
int contador = 0;
void homemQuerEntrar()
{
int aguenta = 0;
do{
pthread_mutex_lock(&mutex);
aguenta = banheiro_cheio || mulher_no_... | 1 |
#include <pthread.h>
int Matrix_Size;
int procs;
const int MAX_THREADS = 100;
int NumThreads;
int min(int a, int b)
{
if (a < b)
return a;
else if ( a == b)
return -1;
else
return b;
}
float A[2000][2000];
float B[2000];
float X[2000];
pthread_t Threads[_POSIX_THREAD_THREADS_MAX];
pt... | 0 |
#include <pthread.h>
int buffer[10];
int first = 0;
int num = 0;
pthread_mutex_t mon = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t itemCond = PTHREAD_COND_INITIALIZER;
pthread_cond_t slotCond = PTHREAD_COND_INITIALIZER;
static void fail( char const *msg );
void *producer(void *param) {
f... | 1 |
#include <pthread.h>
static pthread_mutex_t m_trace = PTHREAD_MUTEX_INITIALIZER;
void output_init()
{
return;
}
void output( char * string, ... )
{
va_list ap;
pthread_mutex_lock(&m_trace);
__builtin_va_start((ap));
vprintf(string, ap);
;
pthread_mutex_unlock(&m_trace)... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer=0;
void *producer(void *ptr) {
int i;
for(i=1;i<=100;i++) {
pthread_mutex_lock(&the_mutex);
while (buffer!=0) pthread_cond_wait(&condp, &the_mutex);
buffer = i;
pthread_... | 1 |
#include <pthread.h>
int numThreads = 1;
int available_resources = 100;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t resc_thresh;
void waitForResources(int resc){
while(resc > available_resources){
sleep(.5);
}
}
int decrease_count(int count,long t){
if(available_reso... | 0 |
#include <pthread.h>
extern char myIP[16];
struct FileNameMap *map = 0;
pthread_mutex_t file_map_lock = PTHREAD_MUTEX_INITIALIZER;
struct FileNameMap* add_entry(char fileName[FILE_PATH_LENGTH]) {
struct FileNameMap* newEntry;
LOG(DEBUG, "Adding entry for %s, %0x", newEntry->fileName, newEntry);
... | 1 |
#include <pthread.h>
unsigned char r,g,b;
} pixel;
int start_idx;
int count;
int colmax;
int image_size;
unsigned tot_threads;
pixel *image;
} th_data;
pthread_mutex_t avg_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_barrier_t barr;
unsigned avg = 0;
unsigned avg_threads_done = 0;
pi... | 0 |
#include <pthread.h>
float f(float x)
{
return x;
}
pthread_mutex_t mutex;
long int num_threads;
float a, b, I, h;
long long int n;
void *trapezoidal(void *param){
long int id = (long int) param;
long long int i, chunk = (n - 2) / (long long int) num_threads;
... | 1 |
#include <pthread.h>
pthread_mutex_t theMutex;
pthread_cond_t condc, condp;
int buffer=0;
void* producer(void* ptr)
{
int x;
for(x=0; x<=4; x++)
{
pthread_mutex_lock(&theMutex);
printf("Producer Locked\\n");
while(buffer!=0)
{
printf("Producer waiting\\n");
pthread_cond_wait(&con... | 0 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
int nr_pare, nr_impare;
void* f(){
int r;
while(1){
pthread_mutex_lock(&m);
if( (nr_pare * nr_impare)%3 == 0 && nr_pare*nr_impare > 50)
break... | 1 |
#include <pthread.h>
int source[15];
int minBound[4];
int maxBound[4];
int channel[4];
int th_id = 0;
pthread_mutex_t mid;
pthread_mutex_t ms[4];
void sort (int x, int y)
{
int aux = 0;
for (int i = x; i < y; i++)
{
for (int j = i; j < y; j++)
{
if (source[i] > source[j])
... | 0 |
#include <pthread.h>
pthread_mutex_t g_lock_tnum = PTHREAD_MUTEX_INITIALIZER;
int g_tnum;
struct thread_info {
pthread_t tid;
int tnum;
char *cmd;
uint32_t timeout;
FILE *fp;
char *out;
pthread_mutex_t out_lock;
};
static void * thread_start(void *arg) {
struct th... | 1 |
#include <pthread.h>
int max;
int balance = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void * mythread(void *arg) {
char *letter = arg;
int i;
printf("%s: begin [addr of i: %p]\\n", letter, &i);
for (i = 0; i < max; i++) {
pthread_mutex_lock(&lock);
... | 0 |
#include <pthread.h>
{
int n;
double sum;
} SQRTSUM;
SQRTSUM sqrtsum;
pthread_mutex_t mutex_sqrtsum;
struct timeval tp1, tp2;
struct timezone tpz1, tpz2;
void *runner(void *param);
int main(int argc, char *argv[])
{
gettimeofday(&tp1, &tpz1);
if (atoi(argv[1]) < 0)
{
fprintf(stde... | 1 |
#include <pthread.h>
int vlogf(const char *fmt, va_list args);
void append_msg(const char *msg);
void print_info();
void trunc_info();
char *copy_info(char outbuff[], size_t n);
char *copy_info_trunc(char outbuff[], size_t n);
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
stat... | 0 |
#include <pthread.h>
void *thread_func(void *arg);
char buffer[1024];
pthread_mutex_t mutex;
int thread04_main(void)
{
int ret;
pthread_t thread_a;
void *thread_result;
if(0 != (ret = pthread_mutex_init(&mutex, 0))){
perror("mutex init failed");
exit(1);
}... | 1 |
#include <pthread.h>
int nr = 0;
pthread_mutex_t mutex;
void* thread_func(void* arg) {
char* cuvant = (char*)malloc(40);
cuvant = (char*)arg;
int i;
for (i = 0; i < strlen(cuvant); i++) {
if (cuvant[i] == 'a' || cuvant[i] == 'e' || cuvant[i] == 'i' ||
cuvant[i] ==... | 0 |
#include <pthread.h>
int socket_fd;
pthread_mutex_t socket_lock = PTHREAD_MUTEX_INITIALIZER;
int init(int portNum) {
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
int enable = 1;
setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, (char*) &enable,
sizeof(int));
struct sockaddr_in server;
... | 1 |
#include <pthread.h>
int count=0;
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++){
if(int_pt[i]==3){
pthread_mutex_lock(&lock);
... | 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>
long int cislo, je_nove_cislo=0, precitalo=0;
pthread_mutex_t MUTEX;
pthread_cond_t nove_cislo, vsetci_precitali;
void * generuj(void * param) {
int i;
for(i=0; i < 20; i++) {
pthread_mutex_lock(&MUTEX);
cislo = random() % 100;
printf("Server vygeneroval nove cisl... | 0 |
#include <pthread.h>
static pthread_mutex_t mx_timersync = PTHREAD_MUTEX_INITIALIZER;
static struct timeval offset_unix_concent = {0, 0};
extern bool exit_sig;
extern bool quit_sig;
extern pthread_mutex_t mx_concent;
int get_concentrator_time(struct timeval *concent_time, struct timeval uni... | 1 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
bool stop = 0;
void *killBySiginal()
{
char c;
printf("Digite o Sinal:\\n");
scanf(" %c",&c);
if(c == "T"){
printf("Parou com o Sinal %s", &c);
stop = 1;
}
stop = 0;
sleep(1);
}
void *produc... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
double a, b, h;
int n, local_n;
double total_integral;
pthread_mutex_t mutex;
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
void* Trap(void* rank);
double f(double x);
int main(int argc, char* argv[]) {
... | 1 |
#include <pthread.h>
sem_t pieno;
sem_t vuoto;
pthread_mutex_t mutexS, mutexC;
int porzioni, ngiri;
void* Cuoco(void* arg){
int maxP = *((int*)arg);
while(1){
printf("Il CUOCO si addormenta\\n");
sem_wait(&vuoto);
if(porzioni == 0){
pthread_mutex_lock(&mutexC);
print... | 0 |
#include <pthread.h>
void and_or(void *not_used){
pthread_barrier_wait(&threads_creation);
int and_result;
int or_result_temp;
while(1){
pthread_mutex_lock(&control_sign);
if(!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait, &control_sign) != 0);
}... | 1 |
#include <pthread.h>
pthread_t philosophers[5];
pthread_mutex_t mutex_forks = PTHREAD_MUTEX_INITIALIZER;;
int forks[5];
void init()
{
int i;
for(i=0; i<5; i++)
forks[i] = 0;
}
void philosopher(int i)
{
int right = i;
int left = (i - 1 == -1) ? 5 - 1 : (i - 1);
i... | 0 |
#include <pthread.h>
{
char info;
int n;
int num;
pthread_mutex_t mutex;
}ThreadInfo;
void *func(void *arg)
{
int cnt = 3;
ThreadInfo *info = (ThreadInfo *)arg;
int result = info->n;
char show = info->info;
while (cnt > 0) {
if (info->num % 3 == result) {
printf("---%c\\n", sho... | 1 |
#include <pthread.h>
size_t k;
int file;
char* word;
int N;
pthread_t* threads;
sigset_t mask;
pthread_mutex_t mutex;
pthread_t main_thread_id;
struct thread_args {
int id;
} **args;
void exit_program(int status, char* message) {
if(status == 0) {
printf("%s\\n",message);
} ... | 0 |
#include <pthread.h>
void* computeRandomPoints (void* input);
int pointsInCircle = 0;
pthread_mutex_t lock;
int main(int argc, const char * argv[])
{
pthread_t thread[1000];
pthread_mutex_init(&lock, 0);
int count;
for (count = 0; count < 1000; count++)
{
pt... | 1 |
#include <pthread.h>
int isUsed;
pthread_mutex_t forkLock;
pthread_cond_t forkCond;
int forkId;
}forks;
int numPhilosophers;
int numEats;
forks* forkArray;
int getLeftForkId(int philosopherId){
return philosopherId;
}
int getRightForkId(int philosopherId, int numPhilosophers){
in... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t gateaux_prets = PTHREAD_COND_INITIALIZER;
int gateaux = 0;
int stop = 0;
void* enfant(void *arg) {
int id = *((int*) arg);
int mange = 0;
while(1) {
pthread_mutex_lock(&mutex);
if(gateaux ==... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
void fhilo1(void *x){
int letra='A';
while(letra<='Z') {
pthread_mutex_lock(&mutex1);
usleep(100000);
write(1,&letra,1);
letra+=2;
pthread_mutex_unlock(&mutex2);
}
pthread_exit(0);
}
void fhilo2(void *x){
int... | 0 |
#include <pthread.h>
void *(*process) (void *arg);
void *arg;
struct worker *next;
} CThread_worker;
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
CThread_worker *queue_head;
int shutdown;
pthread_t *threadid;
int max_thread_num;
int cur_queue_size;
} CThread_po... | 1 |
#include <pthread.h>
int chopstick[5] = {0,0,0,0,0};
int state[5];
pthread_cond_t chopstic_cond[5] = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
void pick_chopstick(int id)
{
pthread_mutex_lock(&mutex_lock);
sleep(1);
if(state[id] == 1 && chopstic... | 0 |
#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;
}
theArray=ma... | 1 |
#include <pthread.h>
struct thrd_data{
int id;
int start;
int end;
};
int count = 0;
pthread_mutex_t count_mtx;
void *do_work(void *thrd_arg)
{
struct thrd_data *t_data;
int i,j,min, max;
int myid;
int mycount = 0;
t_data = (struct thrd_data *) thrd_arg;
myid = t_data->id;
m... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void * producer(void *ptr)
{
int i;
for(i = 0; i < 20; i++)
{
printf("producer locking critical region\\n");
pthread_mutex_lock(&the_mutex);
printf("producer producing %d\\n", i);
while(b... | 1 |
#include <pthread.h>
int mediafirefs_getxattr(const char *path, const char *name, char *value,
size_t size)
{
printf("FUNCTION: getxattr. path: %s\\n", path);
(void)path;
(void)name;
(void)value;
(void)size;
struct mediafirefs_context_private *c... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int num = 0;
FILE *fp[4];
int file = 1;
void *write_func(void *arg)
{
int i;
int tmp = (int)arg;
int count = tmp;
for(i = 0; i < 12; i++)
{
pthread_mutex_lock(&mutex);
while(tmp != num)
... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condvar = PTHREAD_COND_INITIALIZER;
void * function1();
void * function2();
int count = 0;
int main (int argc, const char ** argv)
{
pthread_t thread1, thread2;
pthread_create(&thread1, 0, ... | 0 |
#include <pthread.h>
int
ports_count_class (struct port_class *class)
{
int ret;
pthread_mutex_lock (&_ports_lock);
ret = class->count;
class->flags |= PORT_CLASS_NO_ALLOC;
pthread_mutex_unlock (&_ports_lock);
return ret;
}
| 1 |
#include <pthread.h>
int MemoryLookupTable[M];
int PhysicalMemory[M];
int MetaTable[M];
int Disk[10000];
pthread_mutex_t memoryLock;
int seq;
int mode;
int Fetch(int i);
int PageIn(int i);
int obtainMemoryLock();
int releaseMemoryLock();
void removeLeastRecentlyUsed(int val, int i);
void... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int var1 =0, var2=0, running = 1;
void *threadFunc1(void *arg)
{
char *str;
str=(char*)arg;
printf("%s\\n", str);
while(running){
pthread_mutex_lock(&lock);
var1++;
var2 = var1;
pthread_mutex_unlock(&lock);
}
return 0;
}
void *threadFun... | 1 |
#include <pthread.h>
int state[5];
pthread_mutex_t mutex;
sem_t forks[5];
int id[5];
void think(int i) {
state[i] = 0;
}
void test(int i) {
if (state[i] == 1 && state[(i-1) % 5] != 2 && state[(i+1) % 5] != 2) {
state[i] = 2;
sem_post(&forks[i]);
}
}
void pick_sticks(int i) {
pthread_mute... | 0 |
#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 attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthrea... | 1 |
#include <pthread.h>
int count = 0;
pthread_mutex_t lock;
void *ThreadFunction(void* arg)
{
int* id = (int*)arg;
int it = 0;
printf("\\nCalling Function Started: %d\\n", *id);
if (pthread_mutex_trylock(&lock)==0)
{
for ( it = 0; it<100000; it++);
count += 1;
printf("I... | 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 = lo... | 1 |
#include <pthread.h>
{
int nCount;
int nData;
}FOO,*PFOO;
int main(int argc,char *argv[])
{
FOO *ptr;
pid_t pid;
pthread_mutexattr_t mutexattr;
pthread_mutex_t mutex;
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setpshared(&mutexattr,PTHREAD_PROCESS_SHAR... | 0 |
#include <pthread.h>
extern char **environ;
static pthread_key_t key;
pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void thread_init(void)
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_R... | 1 |
#include <pthread.h>
int plasicur(void)
{
char c;
int test_enc1_cnt = 0;
pthread_mutex_lock(&mutex_ser);
motc.ascRettaOffset = lround((double)motc1.encY / MAXARCNT - AR_OFFSET / 24.0) * MAXARCNT;
pthread_mutex_unlock(&mutex_ser);
if (!SerCmdGotoEncSync(CNT_LATD, (long)(-MAXLATDCNT*(LAT... | 0 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
... | 1 |
#include <pthread.h>
uint64_t nb;
FILE * file;
char str[60];
pthread_t thread0;
pthread_t thread1;
pthread_mutex_t lock;
pthread_mutex_t lockScreen;
const int MAX_FACTORS=64;
void print_prime_factors(uint64_t n);
int get_prime_factors(uint64_t n,uint64_t* dest);
void* thread_prime_facto... | 0 |
#include <pthread.h>
static struct ubus_context *ctx = 0;
static const char *ubus_path;
static pthread_t tid[1];
static pthread_mutex_t lock;
static long sleep_time = INTERVAL;
void recalc_sleep_time(bool calc, int toms)
{
long dec = toms * 1000;
if (!calc)
sleep_time = INTERVAL;
else if(... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mtx = PTHREAD_MUTEX_INITIALIZER;
extern char ** environ;
static void thread_init(void)
{
pthread_key_create(&key, free);
}
char* _getenv(const char *name)
{
int i, len;
cha... | 0 |
#include <pthread.h>
int recurso = 20;
void *consumador() {
int i;
for(i=0;i<10;i++) {
printf("Actualmente recurso es %i\\n", recurso);
recurso--;
usleep(rand() % 5);
}
}
void ejemplo_hilos() {
pthread_t hilo1, hilo2;
pthread_create(&hilo1, 0, consumador, 0);
pthread_create(&hil... | 1 |
#include <pthread.h>
int threadCount;
int loopCount;
} clargs_t;
clargs_t clargs;
pthread_mutex_t ticketGeneratorMutex;
int ticketsAssignedCount = 0;
pthread_cond_t cond;
pthread_mutex_t mutex;
int currentTicket;
} ticket_lock_t;
ticket_lock_t csLock;
void printHelp(){
print... | 0 |
#include <pthread.h>
pthread_mutex_t kran;
pthread_mutex_t kufle;
int l_kl, l_kf, l_kr;
void * watek_klient (void * arg);
int kufle_pobrane = 0;;
int main(){
pthread_t *tab_klient;
int *tab_klient_id;
int i;
printf("\\nLiczba klientow: "); scanf("%d", &l_kl);
printf("%d\\n",l_kl);
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full, empty;
buffer_item buffer[5];
int counter;
pthread_t prod[10];
pthread_t cons[10];
pthread_t tid;
pthread_attr_t attr;
void *producer(void *param);
void *consumer(void *param);
void initializeData() {
pthread_mutex_init(... | 0 |
#include <pthread.h>
pthread_mutex_t exec_mutex;
void *thread_for() {
int i=0;
while(1)
{
pthread_mutex_lock(&exec_mutex);
i++;
pthread_mutex_unlock(&exec_mutex);
}
pthread_exit("Thank you for the CPU time");
}
int main(int argc ,char *argv[]) {
float load = atoi(argv[1])*0.01... | 1 |
#include <pthread.h>
double widthbase;
int rectxworker;
double private_resultado[NUMWORKERS];
pthread_mutex_t mutex;
double total;
void* suma(void* idt) {
int id = (int)idt;
double base = (double)(rectxworker*id*widthbase);
for (int i = 0; i < rectxworker; i++)
private_resultado[id] +... | 0 |
#include <pthread.h>
int *array;
int length, count;
pthread_t *ids;
int length_per_thread;
pthread_mutex_t ex = PTHREAD_MUTEX_INITIALIZER;
void * count3s_thread(void *id){
int i,c = 0;
int start = length_per_thread*(int)id;
int end = start + length_per_thread;
for(i=start; i < end; i++){
... | 1 |
#include <pthread.h>
_dataType blank[20];
sem_t sem_product;
sem_t sem_consumer;
pthread_mutex_t mutex_product = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_consumer = PTHREAD_MUTEX_INITIALIZER;
void *product(void *arg)
{
int index = 0;
int count = 0;
while(1)
{
sleep(rand()%5);
... | 0 |
#include <pthread.h>
uint32_t COUNTER;
pthread_mutex_t LOCK;
pthread_mutex_t START;
pthread_cond_t CONDITION;
void * threads (
void * unused
) {
pthread_mutex_lock(&START);
pthread_mutex_unlock(&START);
pthread_mutex_lock(&LOCK);
if (COUNTER > 0) {
pthread_cond_signa... | 1 |
#include <pthread.h>
int state = 0;
int isFullShop = 0;
int noCustomer = 0;
int isChair = 0;
int num_chair = 0;
int noMoreCustomer = 10;
pthread_cond_t free_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t wake_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cut_cond = PTHREAD_COND_INITIALIZE... | 0 |
#include <pthread.h>
int buffer=0;
sem_t empty_sem;
sem_t full_sem;
pthread_mutex_t mutex;
void *product(){
while (1) {
sem_wait(&empty_sem);
pthread_mutex_lock(&mutex);
printf("生产了一个东西\\n" );
buffer=1;
pthread_mutex_unlock(&mutex);
sem_post(&full_sem);
}
}
void ... | 1 |
#include <pthread.h>
int Number;
pthread_mutex_t *pfork;
int *state;
void *EatMeal();
void GetArg(
char* argv[] ,
int* number
);
void main(int argc, char* argv[])
{
int k =0;
while(k<1)
{
int option_index = 0;
int rvalue = 0;
struct... | 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_reader = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_writer = PTHREAD_COND_INITIALIZER;
void *writer (void *param);
void *reader (void *param);
int main(in... | 1 |
#include <pthread.h>
const static char east[] = "east";
const static char west[] = "west";
const static char car[] = "car";
const static char truck[] = "truck";
int static unsigned number_of_cars;
const static char* bridge_direction;
pthread_mutex_t static bridge_lock;
pthread_mutex_t static ... | 0 |
#include <pthread.h>
void err_quit(const char *api);
void thread_fun(void *arg);
void cnt_plus_one();
int global = 0;
pthread_mutex_t mutex;
int main()
{
if(pthread_mutex_init(&mutex, 0) < 0)
err_quit("pthread_mutex_init");
int i = 0;
for(i = 0; i < 3; i++)
{
... | 1 |
#include <pthread.h>
const int MAX_THREADS = 64;
int thread_count, message_avaliable;
pthread_mutex_t mutex;
void Usage(char* prog_name);
void *Hello(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
if (argc != 2) Usage(argv[0]);
thread_cou... | 0 |
#include <pthread.h>
struct Node {
char buf[(1024)];
struct Node *next;
};
struct Queue {
pthread_mutex_t mutex;
pthread_cond_t not_empty, not_full;
int count;
struct Node *head, *tail;
};
void queue_init(struct Queue *q) {
pthread_mutex_init(&q->mutex, 0);
pthread_cond_init(&q->not_e... | 1 |
#include <pthread.h>
static void delay_ms(const int ms)
{
struct timespec ts;
assert(ms >= 0);
ts.tv_sec = ms / 1000;
ts.tv_nsec = (ms % 1000) * 1000 * 1000;
nanosleep(&ts, 0);
}
int main(int argc, char** argv)
{
int interval = 0;
int optchar;
pthread_mutex_t mutex;
pthre... | 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>
int q[4];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 4)
... | 0 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing(void *arg)
{
pthread_mutex_lock(&lock);
unsigned long i = 0;
counter += 1;
printf("\\n Job %d started\\n", counter);
for(i=0; i<(0xFFFFFFFF);i++);
printf("\\n Job %d finished\\n"... | 1 |
#include <pthread.h>
pthread_cond_t onOahu;
pthread_cond_t onBoat;
pthread_cond_t onMolo;
int boatLoc;
int kidsOnBoard;
int adultsOnBoard;
int lastCrossed;
void init() {
pthread_mutex_init(&lock, 0);
pthread_cond_init(&allReady, 0);
pthread_cond_init(&mayStart, 0);
pthread_cond_init... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.