text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
void validaParametrosInput(int argc, char *argv[], int *cantVias);
void createThreads( pthread_t **thread_id, int count);
void waitThreads(pthread_t *thread_id, int count);
void *thread_function(void *dummyPtr);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int semID... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int totalPorts;
int numThreads;
FILE * outputFile;
{
char *portString;
char *ipAddress;
}portArgs;
void * downloadChunk(void *arguments)
{
portArgs *args = (portArgs*)(arguments);
int port = atoi(args->portString);
char receivedBuffer[1024];
... | 0 |
#include <pthread.h>
struct to_info {
void (*to_fn)(void *);
void * to_arg;
struct timespec to_wait;
};
int
makethread(void * (*fn)(void *), void * arg, int detach)
{
int err;
int detachstate;
pthread_t tid;
pthread_attr_t attr;
if ((err = pthread_attr_init(&attr)... | 1 |
#include <pthread.h>
struct pios_semaphore {
uint32_t magic;
pthread_mutex_t mutex;
pthread_cond_t cond;
bool given;
};
struct pios_semaphore *PIOS_Semaphore_Create(void)
{
struct pios_semaphore *s = PIOS_malloc(sizeof(*s));
if (!s) {
return 0;
}
pthread_mutexattr_t attr;
if (pt... | 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 number;
pthread_mutex_t mu= PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t sig_consumer= PTHREAD_COND_INITIALIZER;
pthread_cond_t sig_producer= PTHREAD_COND_INITIALIZER;
void *consumer(void *dummy)
{
int printed= 0;
" now\\"\\n", pthread_s... | 0 |
#include <pthread.h>
int stoj = 0;
char rodic1, rodic2;
int pocet = 0;
int organizmySuma[3] = {0};
pthread_t organizmy[1000];
int ROZMNOZOVAT = 1;
int PARIT = 0;
int rodicia = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condRozmnozovanie = PTHREAD_COND_INITIALIZER;
pth... | 1 |
#include <pthread.h>
int shared = 0;
pthread_mutex_t lock;
pthread_cond_t cond;
int thread_num;
char buf[80];
} tinfo_t;
void*
thread1_func(void *arg)
{
tinfo_t *tmp = (tinfo_t*)arg;
printf("Thread %u - going to wait for shared data to be >= %u\\n",
tmp-... | 0 |
#include <pthread.h>
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void error(char *msg)
{
fprintf(stderr, "%s, %s\\n", msg, strerror(errno));
exit(1);
}
int beers = 2000000;
void* drink_lots(void *a)
{
pthread_mutex_lock(&beers_lock);
int i;
for ... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
int sum = 0;
void *countgold(void *param) {
int i;
int local = 0;
for (i = 0; i < 10000000; i++)
local++;
pthread_mutex_lock(&m);
sum += local;
pthread_mutex_unlock(&m);
return 0;
}
in... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void cleanup(void *p)
{
printf("\\n %s: \\n",__func__);
pthread_mutex_unlock(&mutex);
printf("Cleanup: mutex released\\n" );
}
void *thread_func1(void *ignored_argument)
{
int s;
printf("\\n %s: \\n",__func__);
pthrea... | 1 |
#include <pthread.h>
void process__(struct tcp_stream *a_tcp, int type);
void process_request(struct tcp_stream *a_tcp) {
struct half_stream *hlf = &a_tcp->server;
struct threads *p = 0;
if(hlf->offset==0) {
if(hlf->count <= 4) {
a_tcp->client.collect--;
a_tcp->server.collect--;
f... | 0 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
int global = 0;
void clock_gettime(struct timespec *tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp -> tv_sec =... | 1 |
#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);
w... | 0 |
#include <pthread.h>
static int gpio_ext_write(struct gpio_ext *gpioExt, uint16_t values) {
static pthread_mutex_t funcMutex = PTHREAD_MUTEX_INITIALIZER;
int ret;
char bytes[2] = { values & 0xFF , values >> 8 };
ret = pthread_mutex_lock(&funcMutex);
if (ret != 0) {
PRINTE("pthread_mutex_... | 1 |
#include <pthread.h>
void* doSomeThing(void *);
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing(void *arg)
{
unsigned long i;
pthread_mutex_lock(&lock);
i = 0;
counter += 1;
printf("\\n Job %d started\\n", counter);
for (i=0; i<(0xFFFFFFFF)... | 0 |
#include <pthread.h>
int p_count=10;
int queue[5];
int q_front=0;
int q_end=0;
int q_size=0;
pthread_mutex_t mutex_var,mutex_p;
pthread_cond_t cond_producer;
pthread_cond_t cond_consumer;
void *producerFunction();
void *consumerFunction();
int producer_lock();
pthread_t thread_id;
pt... | 1 |
#include <pthread.h>
int SocketLevel[5] = {0, 1, 2, 3, 4};
char ICLevelName[5][10] = {"NOLOG", "DEBUG", "INFO", "WARNING", "ERROR"};
pthread_mutex_t mutex_log = PTHREAD_MUTEX_INITIALIZER;
static int ITCAST_Error_GetCurTime(char* strTime)
{
struct tm* tmTime = 0;
size_t timeLen = 0;
time_t t... | 0 |
#include <pthread.h>
struct Foo* gs_foo = 0;
int gs_sum = 0;
static pthread_mutex_t gs_sum_guard = PTHREAD_MUTEX_INITIALIZER;
volatile int gs_is_end;
void ReadThreadFunc()
{
struct Foo* foo = 0;
int sum = 0;
unsigned int i;
int j;
rcu_register_thread();
for (i = 0; i < ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_test = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_test = PTHREAD_COND_INITIALIZER;
void *One_Thread(void * tparam)
{
printf("One_Thread Start!\\r\\n");
pthread_mutex_lock(&mutex_test);
pthread_cond_wait(&cond_test, &mutex_test);
... | 0 |
#include <pthread.h>
void * spravca(void *);
void * kobyla(void *);
pthread_t tid[2];
sem_t semA, semB;
int kapacita = 20;
int pocet_kobyl = 10;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
main(int argc, char *argv[])
{
sem_init(&semA, 0, 0);
sem_init(&semB, 0, 20);
pthread_mutex_init(&mut,... | 1 |
#include <pthread.h>
pthread_t fid[1],cid[20];
pthread_mutex_t cpu=PTHREAD_MUTEX_INITIALIZER,s[20];
int num;
int time1;
int remain;
int state;
}pcb;
pcb thread[20];
int total=0;
int slice=3;
int flag=1;
int waitTime=0;
void* child(void* vargp){
int i = *(int*)vargp;
while(thread[i].rem... | 0 |
#include <pthread.h>
int mbox_init(struct mbox *mb, size_t size)
{
int ret;
mb->read_idx = 0;
mb->write_idx = 0;
mb->size = size;
ret = sem_init(&mb->sem_read, 0, 0);
if (ret)
goto out_err;
ret = sem_init(&mb->sem_write, 0, size);
if (ret)
goto out_err;
ret = pthread_mutex_ini... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_sum = PTHREAD_MUTEX_INITIALIZER;
int *VecA, *VecB, sum = 0, dist;
void * doMyWork(int myId)
{
int counter, mySum = 0;
printf("\\n %d: I am taking the interval: %d - %d.", myId, ((myId - 1) * dist), ((myId * dist) - 1));
for (counter = ((myId -... | 0 |
#include <pthread.h>
sem_t SEntrada;
pthread_mutex_t C1;
char est[24];
pthread_t th_auto[8];
int lugar;
void automovil( void *id );
int entrada( void *id ,int puerta);
void salida( void *id ,int salida,int lug);
void tiempo(int time);
void interfaz();
int main()
{
int i;
for(i=0;i<24;i++... | 1 |
#include <pthread.h>
struct rssi_table table[MAX_ENTRY];
struct timeval present;
pthread_mutex_t table_mutex=PTHREAD_MUTEX_INITIALIZER;
int initialize(){
pthread_mutex_lock(&table_mutex);
memset(&present,0,sizeof(struct timeval));
memset(table,0,sizeof(struct rssi_table)*MAX_ENTRY);
pthrea... | 0 |
#include <pthread.h>
pthread_mutex_t ma[6];
int a[6];
pthread_mutex_t mi;
int i = 0;
int d = 0;
void *choice()
{
int x;
for (x = 1; x < 6; x++)
{
pthread_mutex_lock(&mi);
i = x;
pthread_mutex_unlock(&mi);
}
return 0;
}
void *wa(void *arg)
{
unsigned id = (unsigned long) arg;
... | 1 |
#include <pthread.h>
const int READER_NUM = 10;
pthread_rwlock_t rwlock;
pthread_mutex_t mutex;
void readerFunc(void) {
int id = ((int)pthread_self()) % 10000;
printf("Reader %4d is waiting\\n", id);
pthread_rwlock_rdlock(&rwlock);
pthread_mutex_lock(&mutex);
printf(" Reader... | 0 |
#include <pthread.h>
pthread_mutex_t sum_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
void *functionAdd1();
void *functionAdd2();
int sum = 0;
int count=0;
int main()
{
... | 1 |
#include <pthread.h>
pthread_t Thread_set;
pthread_t Thread_get;
pthread_attr_t schedAttr_set;
pthread_attr_t schedAttr_get;
struct sched_param set_param;
struct sched_param get_param;
pthread_mutex_t mutexLock;
int test;
{
double Acc_x,Acc_y,Acc_z;
double roll;
double pitc... | 0 |
#include <pthread.h>
FILE *fp;
pthread_t threads[2];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * read_file(void* tmp)
{
int i, ret;
for (i = 0; i < 3000; i++) {
if (pthread_self() == threads[1]) {
pthread_mutex_lock(&mutex);
ret = fp... | 1 |
#include <pthread.h>
int TEAMS1=0,TEAMS2=0,N;
pthread_cond_t y[100000],l[100000];
pthread_mutex_t mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
int counter1=0,counter2=0;
int lan_que[100000],york_que[100000];
int lan_tail=-1,lan_head=0,york_head=0,york_tail=-1;
void * func1(void * arg){
i... | 0 |
#include <pthread.h>
int amount_of_elements_in_run = 0;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void print_v(int v[], int n)
{
int i = 0;
while(i<n)
{
printf("%d\\t",v[i]);
i++;
}
printf("\\n");
}
void *calculate_two_elements(void *vectorptr)
{
pthread_mutex_lo... | 1 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
};
struct foo *foo_alloc(int id) {
struct foo *fp;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
fp->f_id = id;
if (pthread_mutex_init(&fp->f_lock, 0) !=0)... | 0 |
#include <pthread.h>
int buffer[BUFFER_SIZE];
int buffer_pointer;
int buffer_length;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void produce() {
while (1) {
int value = get_random_number();
put(value);
printf("Produced: %d\\n", value);
fflush(stdout);
usleep(1... | 1 |
#include <pthread.h>
void *myTh(void *arg);
char dirname[256];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char *argv[]){
pthread_t *th;
int n,i,fd;
char fname[256];
if(argc != 3){
return -1;
}
n = atoi(argv[1]);
chdir(argv[2]);
sprintf(dirname, "%s", ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int final_result = 0;
void *swap (void *threadarg) {
int y;
int checksum=0;
int accel_num = *((int *)threadarg);
int output[1024];
for (y=0; y<1024; y++) {
output [y] = input_array[y][accel_num];
}
for (y=0; y<1024... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condc, condp;
int element[20];
uint8_t head;
uint8_t tail;
uint8_t remaining_elements;
int waiting;
} prod_cons_queue;
prod_cons_queue *q;
int pid;
} vars;
int main(){
return 0;
}
void queue_initialize (prod_cons_queue *q... | 0 |
#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(int amountToWithdraw);
void signalMySemphor();
void *threadClientWithdrawer(void* args);
void *threadClientDep... | 1 |
#include <pthread.h>
sem_t semph[5];
pthread_mutex_t mutex;
void* philosopher(void* param);
int main(int argc, char* argv[])
{
int i;
srand(getpid());
pthread_t PhilosopherThread[5];
int phId[5];
pthread_mutex_init(&mutex, 0);
for (i=0; i<5; i++)
{
... | 0 |
#include <pthread.h>
int *buffer;
int count;
pthread_mutex_t mutex;
pthread_cond_t condp, condc;
int produzItem (int base) {
usleep(100);
return base;
}
int consomeItem (int item) {
usleep(100);
return item;
}
void *produtor(void *param) {
int k=1, in=0;
while ( k<=1000 ) {
... | 1 |
#include <pthread.h>
int
main(int argc, char **argv)
{
int i, tnum, ramp, allcox, connum, k, cfd;
uint64_t allrps, allbps;
char *p, hbuf[256], prt[8], erbuf[256];
pthread_t tid;
struct timespec tick, tock;
struct addrinfo hints, *res, *r;
struct epoll_event ev = {.events = EPOLLIN};
if (argc ... | 0 |
#include <pthread.h>
static pthread_mutex_t exit_code_lock = PTHREAD_MUTEX_INITIALIZER;
static uint8_t exit_code = 0;
void set_exit_code(uint8_t value)
{
pthread_mutex_lock(&exit_code_lock);
exit_code = value;
pthread_mutex_unlock(&exit_code_lock);
}
bool is_exiting()
{
bool is_exit_code_se... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t sem_nfree;
int available[20] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
void *runStation(void *ptr);
void *runMachine(void *ptr);
void setup(int stations, int machines)
{
pthread_t kstation_thread[5];
s... | 0 |
#include <pthread.h>
unsigned int REG_TEST[2] = {
REG_MEMORY_A,
REG_MEMORY_B,
};
unsigned int TEST_VALUE_RW[4] = { 0x000000,
0xFFFFFF,
0x555555,
0xAAAAAA
};
int VT_mc13783_RW_setup(void) {
int rv = TFAIL;
rv = TPASS;
return rv;
}
int VT_mc13783_RW_cleanup(void) {
in... | 1 |
#include <pthread.h>
int* row;
int stability;
pthread_mutex_t mutex;
}grid_t;
int counter;
int stability;
pthread_mutex_t mutex;
pthread_cond_t condition;
}barrier_t;
pthread_t thread;
barrier_t* barrier;
grid_t* grid;
int thread_id;
int numthreads;
int gridsize;
in... | 0 |
#include <pthread.h>
static void ctx_assertf2(const char *file, const char *func, int line,
const char *asserttxt, const char *fmt, va_list argptr)
{
pthread_mutex_lock(&ctx_biglock);
fflush(stdout);
fprintf(stderr, "[%s:%i] Assert Failed %s(): %s", file, line, f... | 1 |
#include <pthread.h>
int cliente;
sem_t pedido;
}TVENDEDOR;
TVENDEDOR vendedores[5] = {0};
int senha = 1;
int proximo = 1;
pthread_mutex_t mutex_senha = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_proximo = PTHREAD_MUTEX_INITIALIZER;
void atende_cliente(int vendedor, int cliente)... | 0 |
#include <pthread.h>
struct Message
{
pthread_t tid;
double value;
}thr[100];
double Money ;
int number ;
int k = 0;
double Rands_number(double LeftMoney)
{
srand((unsigned)time(0));
double value= rand()/(double)(32767/LeftMoney);
int temp = value*100;
value = ((double)te... | 1 |
#include <pthread.h>
buffer_t buffer[10];
int buffer_index;
pthread_mutex_t buffer_lock;
pthread_cond_t full_cond, empty_cond;
void insertbuffer(buffer_t value) {
if (buffer_index < 10) {
buffer[buffer_index++] = value;
} else {
printf("Buffer overflow\\n");
}
}
buffe... | 0 |
#include <pthread.h>
struct foo {
int f_count;
int f_id;
pthread_mutex_t f_lock;
};
struct foo *foo_alloc(int id)
{
struct foo *fp;
if((fp = malloc(sizeof(struct foo))) != 0){
fp->f_count = 1;
fp->f_id = id;
if(pthread_mutex_init(fp->f_lock, 0) != 0){
free(fp);
return 0;
}
}
... | 1 |
#include <pthread.h>
pthread_mutex_t countLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t countCV = PTHREAD_COND_INITIALIZER;
int counter = 0;
void* worker(void* arg){
int threadID = *((int*)arg);
printf("hello im worker thread %i\\n",threadID);
for(int i=0;i<10;i++){
... | 0 |
#include <pthread.h>
int
timer_delete (timerid)
timer_t timerid;
{
struct timer *kt = (struct timer *) timerid;
int res = INLINE_SYSCALL (timer_delete, 1, kt->ktimerid);
if (res == 0)
{
if (kt->sigev_notify == SIGEV_THREAD)
{
pthread_mutex_lock (&__active_timer_... | 1 |
#include <pthread.h>
uid_t procrealuid = 0;
uid_t proceffuid = 0;
int str_to_u(const char* s, unsigned* u){
char* p;
unsigned o;
errno = 0;
o = strtoul(s, &p, 0);
if(errno || *p){
return -1;
}
*u = o;
return 0;
}
int read_complete(int fd, void* buf, size_t count){
char* bufp =... | 0 |
#include <pthread.h>
const int SIGMA = 5;
int *array;
int array_index = -1;
pthread_mutex_t lock;
void *thread(void * arg)
{
pthread_mutex_lock(&lock);
int curidx = array_index;
array[array_index] = 1;
int cur = array[array_index];
pthread_mutex_unlock(... | 1 |
#include <pthread.h>
void lock_range(int begin, int end) {
for (int i = begin; i < end; ++i) {
pthread_mutex_lock(&Locks[i]);
}
}
void unlock_range(int begin, int end) {
for (int i = begin; i < end; ++i) {
pthread_mutex_unlock(&Locks[i]);
}
}
bool is_locked(int l... | 0 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c1 = PTHREAD_COND_INITIALIZER;
int t1_is_ready = 0;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c2 = PTHREAD_COND_INITIALIZER;
int t2_is_ready = 0;
void* t1_work(void* arg)
{
pthread_mu... | 1 |
#include <pthread.h>
const char plugin_name[] = "SLURM Backfill Scheduler plugin";
const char plugin_type[] = "sched/backfill";
const uint32_t plugin_version = SLURM_VERSION_NUMBER;
static int plugin_errno = SLURM_SUCCESS;
static pthread_t backfill_thread = 0;
static pthread_mutex_t thread_fl... | 0 |
#include <pthread.h>
pthread_mutex_t l[5], mutex;
char name[][10] = {"XYQ", "PROF. CXQ", "TA. YPF", "TA. LHR", "TA. WCK"};
void mythread(void * arg) {
int k, o = 0;
int id = ((int)arg);
int id2 = (id + 1) % 5;
char *_name = name[id];
pthread_mutex_lock(&l[id]);
for (k = 0; k != 100000... | 1 |
#include <pthread.h>
int grid[9][9];
int err_counter;
pthread_mutex_t counter_mutex;
int load_grid(char *filename) {
FILE *input_file = fopen(filename, "r");
if (input_file != 0) {
for(int i = 0; i < 9; i++)
for(int j = 0; j < 9; j++)
fscanf(input_file, "%d", &grid[i][j]);
fclo... | 0 |
#include <pthread.h>
void *producer(void *b);
void *consumer(void *b);
void *bufferPrinter(void *b);
pthread_t *producerThreads;
pthread_t *consumerThreads;
pthread_t bufferPrinterThread;
int PRODUCERCOUNT;
int CONSUMERCOUNT;
int BUFFERCOUNT;
int ITEM_MAX;
int item_count = 0;
int *full;
pt... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t condVar1;
pthread_cond_t condVar2;
int shared_integer = 0;
pthread_t tid[2];
_Bool first_time_in = 1;
double timespec_to_ms(struct timespec *ts)
{
return ts-> tv_sec *1000.0 + ts-> tv_nsec/1000000.0;
}
void* doSomeThing(void *arg);
void*... | 0 |
#include <pthread.h>
static void expandHashtable(
struct UFDBhashtable * ht )
{
unsigned int newTableSize;
unsigned int i, j;
struct UFDBhte * hte;
struct UFDBhte ** newtable;
newTableSize = ht->tableSize * 2 - 1;
newtable = ufdbCalloc( sizeof(struct UFDBhte*), newTable... | 1 |
#include <pthread.h>
volatile long numero = 0;
char primos[1000000];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int ehPrimo(long n) {
int i;
if(n<=1) return 0;
if(n==2) return 1;
if(n%2==0) return 0;
for(i=3; i< sqrt(n)+1; i+=2) {
if(n%i==0) ... | 0 |
#include <pthread.h>
pthread_cond_t stable,
workshop,
santaSleeping,
elfWaiting,
santaWaitElf;
pthread_mutex_t elfAndReindeerCount,
elfwWaitingLock;
int minWait, maxWait;
int elfCount;
int reindeerCount;
int elfDoor;
void *elfThread(void *args)
{
while(1)
{
elvesHelper();
}... | 1 |
#include <pthread.h>
extern unsigned int num_threads;
int volatile unsigned active_threads;
pthread_mutex_t actmut;
unsigned long int *morton_codes;
unsigned long int *sorted_morton_codes;
unsigned int *permutation_vector;
unsigned int *index;
unsigned int *level_record;
int N;
int pop... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_1;
int counter;
void *child1(void *arg)
{
while(1){
pthread_mutex_lock(&mutex_1);
sleep(1);
if(counter > 25)
{
pthread_mutex_unlock(&mutex_1);
pthread_exit(0);
}
else
... | 1 |
#include <pthread.h>
{
int balance;
pthread_mutex_t mutex;
} Account;
void deposit(Account* account, int amount)
{
pthread_mutex_lock(&(account->mutex));
account->balance += amount;
pthread_mutex_unlock(&(account->mutex));
}
void transfer(Account* accountA, Account* accountB, int amou... | 0 |
#include <pthread.h>
int count = 0;
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) {
printf("inc_count():... | 1 |
#include <pthread.h>
const long NUM_PHILOSOPHERS = 5;
pthread_mutex_t chopstick_mutex[5];
void* grab_chopsticks(void* rank);
int main(void)
{
long i, j;
pthread_t* threads = (pthread_t*)malloc(NUM_PHILOSOPHERS * sizeof(pthread_t));
;
for(i = 0; i < NUM_PHILOSOPHERS; ++i)
{
... | 0 |
#include <pthread.h>
pthread_t t_s;
struct sim_time_t bc_time;
int fd;
void* bcsock () {
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,0);
int fd = TCP_Server_init(9010,"127.0.0.1");
while (sim_stat != 0) {
int... | 1 |
#include <pthread.h>
pthread_mutex_t no_wait, no_acc, counter;
int no_of_readers=0;
void writer(void* arg);
void read(int id);
void check_and_wait_if_busy(int id);
void write(int id);
void check_and_wait(int id);
void reader(void *arg)
{
int id=*((int*)arg);
printf("reader %d started\\n", id)... | 0 |
#include <pthread.h>
struct data {
int tid;
char buffer[100];
} tdata1, tdata2;
pthread_mutex_t lock1;
pthread_mutex_t lock2;
pthread_cond_t cond1;
pthread_cond_t cond2;
int mySharedCounter = 0;
int go1 = 0;
int go2 = 0;
void helper(void *tdata, pthread_mutex_t *l1, pthread_cond_t *c1, in... | 1 |
#include <pthread.h>
int globalvar = 0;
int anotherglobal = 0;
pthread_mutex_t gmutex;
void * commonfunction(int local) {
int i = 0;
globalvar=local;
while (i++ < 0x2fff)
{
globalvar++;
printf("thread id : %d : globalvar : %d\\n", pthread_self(), globalvar);
}
return ((void *) 0);
}
... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void *
thr_fn(void *arg)
{
int err, signo;
for (;;) {
err = sigwait(&mask, &signo);
if (err != 0)
err_exi... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void hander(void *arg)
{
free(arg);
(void)pthread_mutex_unlock(&mutex);
}
void *thread1(void *arg)
{
pthread_cleanup_push(hander, &mutex);
while(1) {
printf("thread1 is running\\n");
pthread_mutex_lock(&mutex);
pthread_c... | 0 |
#include <pthread.h>
void fregister(FILE* fp)
{
pthread_mutex_lock(&__first_file_lock);
fp->flags |= _FILE_REGISTERED;
if ( (fp->next = __first_file) )
__first_file->prev = fp;
__first_file = fp;
pthread_mutex_unlock(&__first_file_lock);
}
| 1 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* producer(void *arg)
{
long unsigned i;
while(1){
while(counter < 5){
counter += 1;
pthread_mutex_lock(&lock);
printf("\\n (Prodcuer) Buffer Value :%d", counter);
for(i=0; i<(0x10011111);i++);
pth... | 0 |
#include <pthread.h>
void warn(char *msg) {
if (msg) {
fprintf(stderr, "%s\\n", msg);
}
}
void panic(char *msg) {
endwin();
warn(msg);
exit(1);
}
int strtoi(const char *nptr, char **endptr, int base) {
long lval = strtol(nptr, endptr, base);
if (lval < INT_... | 1 |
#include <pthread.h>
sem_t sem_stu;
sem_t sem_ta;
pthread_mutex_t mutex;
int chair[3];
int count = 0;
int next_seat = 0;
int next_teach = 0;
void rand_sleep(void);
void* stu_programming(void* stu_id);
void* ta_teaching();
int main(int argc, char **argv){
pthread_t *students;
pthread_... | 0 |
#include <pthread.h>
int cpt = 0;
pthread_mutex_t mut;
pthread_cond_t cond;
int var = 1;
struct timeval tv;
struct timespec ts;
void* increm1(void* arg){
int i = 0;
for ( i = 0; i < 4; i++){
sleep(1);
pthread_mutex_lock(&mut);
cpt++;
printf("compteur : %d\\n", cpt);
if (c... | 1 |
#include <pthread.h>
void*rightCounter();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int rightcounter = 0;
void*leftCounter();
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
int leftcounter = 0 ;
int right[]={1,2,2,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0};
int left[]={1,2,2,4,5,6,7... | 0 |
#include <pthread.h>
static size_t used_memory = 0;
static bool tf_malloc_thread_safe = 0;
pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER;
static void tf_malloc_default_oom(size_t size) {
emerg(errno, "tf_malloc: Out of memory trying to allocate %zu bytes", size);
abort();
... | 1 |
#include <pthread.h>
void make_water();
void reaction_init(struct reaction *reaction)
{
pthread_mutex_init(&reaction->lock_mutex,0);
pthread_cond_init(&reaction->getting_new_H,0);
pthread_cond_init(&reaction->ready_to_react,0);
reaction->number_of_H = 0;
}
void reaction_... | 0 |
#include <pthread.h>
extern int dmeventd_debug;
static pthread_mutex_t _register_mutex = PTHREAD_MUTEX_INITIALIZER;
static int _register_count = 0;
static struct dm_pool *_mem_pool = 0;
static void *_lvm_handle = 0;
static pthread_mutex_t _event_mutex = PTHREAD_MUTEX_INITIALIZER;
... | 1 |
#include <pthread.h>
void* producersFunction(void*);
void* consumersFunction(void*);
{
int head;
int tail;
int isFull;
int isEmpty;
char buffer[5];
pthread_mutex_t mtx;
pthread_cond_t condNotFull;
pthread_cond_t condNotEmpty;
}FIFO,*PFIFO;
FIFO fifo={0,0,0,1};
int main()
{
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int index;
} syn_obj_t;
syn_obj_t syn_obj = {PTHREAD_MUTEX_INITIALIZER,
PTHREAD_COND_INITIALIZER, 0};
int flag;
} elem_t;
void* thread_routine(void* arg);
int main(int argc, char** argv)
{
elem_t elems[... | 1 |
#include <pthread.h>
int commonCounter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *increment_counter(void *ptr);
int main(void) {
int error = -1;
int i = 0;
pthread_t thread_ids[10];
int mainCounter[10];
for (i = 0; i < 10; i++)
mainCounter[i] = 0;
for (i = 0; i... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER ;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER ;
pthread_t tid1,tid2;
int uuid=0;
void *lock_add(void *arg);
void *lock_move(void *arg);
int main(int argc,char **argv)
{
void * err;
uuid = 0 ;
pthread_mutex_lock... | 1 |
#include <pthread.h>
double pi = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *work(void *arg)
{
int start;
int end;
int i;
double local_pi = 0;
start = (200000000/2) * ((int )arg) ;
end = start + 200000000/2;
for (i = start; i < end; i++) {
local_pi ... | 0 |
#include <pthread.h>
int taken;
pthread_mutex_t lock;
pthread_cond_t ready;
} Chopstick;
static Chopstick chop_new() {
Chopstick chop;
chop.taken = 0;
pthread_mutex_init( &chop.lock, 0 );
pthread_cond_init( &chop.ready, 0 );
return chop;
}
static void chop_take( Chopstick chop ) ... | 1 |
#include <pthread.h>
struct propset {
char *str;
int row;
int delay;
int dir;
};
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
int get_msgnum(int num_items);
int setup(int nstrings, char *strings[], struct propset props[]);
int main(int ac, char *av[])
{
int c;
pthread_t thrds[1... | 0 |
#include <pthread.h>
int total_words;
pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char** argv)
{
pthread_t t1, t2;
void *count_words(void *);
if(argc != 3){
printf("usage: %s file1 fil2\\n", argv[0]);
exit(1);
}
total_wor... | 1 |
#include <pthread.h>
pthread_t thread;
pthread_cond_t cond;
pthread_mutex_t mutex;
unsigned char flag = 1;
void * thr_fn(void * arg)
{
struct timeval now;
struct timespec outtime;
pthread_mutex_lock(&mutex);
while (flag)
{
printf("thread sleep now\\n");
gettime... | 0 |
#include <pthread.h>
sem_t *semaphore;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int finished_threads = 0;
int n;
} data;
void *mytask(void *p_data) {
data *info = p_data;
srand(time(0));
int random = rand() % 10 + 1;
printf("Thread %d, sleeping for %d\\n", inf... | 1 |
#include <pthread.h>
static char * buffers[10] = {0};
static int consume_index = 0;
static pthread_mutex_t buffer_mutex;
static pthread_mutex_t total_chars_mutex;
static pthread_mutex_t total_words_mutex;
static pthread_cond_t cond_empty;
static pthread_cond_t cond_full;
static int stored... | 0 |
#include <pthread.h>
static size_t ls_usedMemoryRecord = 0;
static int ls_threadSafenessFlag = 0;
pthread_mutex_t ls_usedMemoryRecordMutex = PTHREAD_MUTEX_INITIALIZER;
static void defaultOomHandler(size_t size);
static void (* ls_oomHandler)(size_t) = defaultOomHandler;
static inline void in... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *runner(void *arg)
{
char *str;
str=(char*)arg;
usleep(10);
printf("%s about to lock\\n",str);
pthread_mutex_lock (&mutex);
printf("%s says in critical section\\n",str);
pthread_mutex_unlock (&mutex);
printf... | 0 |
#include <pthread.h>
pthread_t thread_id;
} params_t;
int cancel = 0;
pthread_mutex_t mutex;
int wrs, rds, max;
int *vector;
void my_signal_handler(int sig)
{
printf("sig = %d", sig);
switch(sig) {
case SIGINT:
puts("Exiting...");
cancel = 1;
default:
break;
}
}
void* thread_... | 1 |
#include <pthread.h>
pthread_t thread1;
pthread_mutex_t mutex;
pthread_mutexattr_t mta;
int ret;
void *a_thread_func(void *)
{
ret=pthread_mutex_unlock(&mutex);
pthread_exit((void*)0);
return 0;
}
int main()
{
if(pthread_mutexattr_init(&mta) != 0)
{
perror("Error at pthread_mutexattr... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.