text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
int value;
void* collatz_even(void* nothing) {
for(;;) {
pthread_mutex_lock( &mutex );
printf("[EVEN THREAD] LOCK\\n");
if (value % 2 == 0) ... | 1 |
#include <pthread.h>
pthread_mutex_t dataMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t dataPresentCondition = PTHREAD_COND_INITIALIZER;
int dataPresent=0;
int sharedData=0;
void *theThread(void *parm)
{
int rc;
int retries=2;
rc = pthread_mutex_lock(&dataMutex);
{ if (rc) { print... | 0 |
#include <pthread.h>
pthread_t philosophers[5];
pthread_mutex_t chopsticks[5];
int chopstick_status[5];
void *a_philosopher_s_life(void *arg)
{
int index = *((int *) arg);
int index_next = index == 5 - 1 ? 0 : index + 1;
pthread_mutex_t *chopstick_l = chopsticks + index;
pthread_mutex... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t blanks;
sem_t datas;
int ringBuf[30];
void *productRun(void *arg)
{
int i = 0;
while(1)
{
sem_wait(&blanks);
int data = rand()%1234;
ringBuf[i++] = data;
i %= 30;
printf("product is done... data... | 0 |
#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;
pthread... | 1 |
#include <pthread.h>
pthread_mutex_t barrier;
pthread_cond_t go;
int numArrivedThreads = 0;
void mai_barrier() {
pthread_mutex_lock(&barrier);
numArrivedThreads++;
if (numArrivedThreads == sinfo.nthreads) {
numArrivedThreads = 0;
pthread_cond_broadcast(&go);
} else
pthread_co... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex4 = PTHREAD_MUTEX_INITIALIZER;
static int sequence1 = 0;
static int sequence2 = 0;
int fun1()
{
... | 1 |
#include <pthread.h>
pthread_mutex_t print_mutex;
pthread_mutex_t wait_chairs_mutex;
int wait_chairs_open = 5;
pthread_cond_t wait_chairs_cv;
sem_t customer;
sem_t barber;
void getHairCut (void *t) {
long my_id = *(long *)t;
pthread_mutex_lock (&print_mutex);
printf ("Customer: ... | 0 |
#include <pthread.h>
int multi_mutex_unlock(pthread_mutex_t **mutexv, int mutexc)
{
if ((mutexv == 0) || (mutexc < 0)) {
return -1;
}
for (int i = 0; i < mutexc; i++) {
if (mutexv[i]) {
pthread_mutex_unlock(mutexv[i]);
}
}
return 0;
}
in... | 1 |
#include <pthread.h>
pthread_mutex_t print_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t PATTERN_mutex = PTHREAD_MUTEX_INITIALIZER;
int TotalLines = 0;
char *PATTERN;
void * searchfile(void *);
int main(int argc, char *argv[]){
pthread_t thread_id[10];
int Lines;
if ((argc < 2) |... | 0 |
#include <pthread.h>
char letter;
int freq;
} tuple;
tuple tup[52];
} alphabet;
alphabet alph;
pthread_mutex_t mutexes[52];
void initialize_alphabet(alphabet* alph){
int i,pos=0;
for(i='A';i<='Z';i++,pos++){
alph->tup[pos].letter=i;
alph->tup[pos].freq=0;
... | 1 |
#include <pthread.h>
struct ring_buffer* ring_buffer_init(void *buffer, uint32_t size, pthread_mutex_t *f_lock)
{
assert(buffer);
struct ring_buffer *ring_buf = 0;
if (!IS_POWER_OF_2(size))
{
printf("size must be power of 2.\\n");
return ring_buf;
}
ring... | 0 |
#include <pthread.h>
static time_t time_orig;
static time_t time_interval;
static int bool_black = 0;
static pthread_mutex_t mutex_screen = PTHREAD_MUTEX_INITIALIZER;
static char screen_light_buf[4];
static int screen_set_time(time_t time)
{
return_val_if_fail(time > 0, -1);
dd_debug("s... | 1 |
#include <pthread.h>
static pthread_t g_thread[(2)];
static pthread_mutex_t g_mtx;
static pthread_cond_t g_cond;
void * threadx_yell (void *param)
{
int t_id = *(int*)param;
while(1)
{
pthread_mutex_lock(&g_mtx);
printf("mutex demo: thread %d entered mutex!\\n", t_id);
usleep(500*10... | 0 |
#include <pthread.h>
struct JobData {
int data;
int job_id;
};
struct Node {
struct JobData Job_Data;
struct Node * next;
};
struct Node * rear = 0;
struct Node * front = 0;
int size_actual = 0;
int queue_size;
pthread_mutex_t mutex;
sem_t empty;
sem_t full;
int produce_sleep_max;
int co... | 1 |
#include <pthread.h>
int c;
int PC, DC, CC, DDC, QS;
char *PM;
struct ring_buffer *donut_type;
pthread_mutex_t p_lock;
pthread_mutex_t c_lock;
pthread_cond_t p_cond;
pthread_cond_t c_cond;
struct ring_buffer {
int *donut_queue;
int in;
int out;
int counter;
int space;
int donuts;
};
void* ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void foo()
{
pthread_mutex_lock(&mutex);
printf("thread = %d\\n", (int)pthread_self());
pthread_mutex_unlock(&mutex);
}
void * func(void* ptr)
{
pthread_mutex_lock(&mutex);
foo();
pthread_mutex_unlock(&mutex);
}
int ... | 1 |
#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 *idp)
{
int j,i;
double result=0;
int *my_id=idp;
for(i=0;i<10;i++)
{
pthread_mutex_lock(&count_mutex);
count++;
if(count==12)
... | 0 |
#include <pthread.h>
int thread_id;
int num_elements;
float *vector_a;
float *vector_b;
int offset;
int chunk_size;
double *sum;
pthread_mutex_t *mutex_for_sum;
} ARGS_FOR_THREAD;
float compute_gold(float *, float *, int);
float compute_using_pthreads(fl... | 1 |
#include <pthread.h>
int w, h;
v2df zero = { 0.0, 0.0 };
v2df four = { 4.0, 4.0 };
v2df nzero;
double inverse_w;
double inverse_h;
char *whole_data;
int y_pick;
pthread_mutex_t y_mutex = PTHREAD_MUTEX_INITIALIZER;
static void * worker(void *_args) {
char *data;
double x, y;
int ... | 0 |
#include <pthread.h>
struct critical_data {
int len;
char buf[100];
}data[2];
{
pthread_mutex_t mutex;
pthread_cond_t cond;
unsigned short conditionMet;
unsigned short broadcast;
} my_lock_t;
my_lock_t lock = {PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER,0,0};
... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
struct food {
struct food *next;
int num;
};
struct food *head=0;
void *producer(void*arg)
{
struct food *fp;
for(;;) {
fp = (struct food*)malloc(sizeof(struct f... | 0 |
#include <pthread.h>
int key;
struct _list_node_t *next;
pthread_mutex_t lock;
} list_node_t;
void list_init(list_node_t **head)
{
*head = (list_node_t *)malloc(sizeof(list_node_t));
(*head)->key = INT_MIN;
pthread_mutex_init(&(*head)->lock, 0);
(*head)->next = (list_node_... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *another(void *arg)
{
printf("in child thread, lock the mutex\\n");
pthread_mutex_lock(&mutex);
sleep(5);
pthread_mutex_unlock(&mutex);
return 0;
}
int main(int argc, const char *argv[])
{
pthread_mutex_init(&mutex, 0);
... | 0 |
#include <pthread.h>
void *find_min(void *list_ptr);
pthread_mutex_t minimum_value_lock;
int minimum_value, partial_list_size;
int main()
{
static long list[100000000],i,n;
minimum_value = 0;
printf("enter the number of threads for which you want to run this program \\n");
scanf("%d",&n... | 1 |
#include <pthread.h>
int thread_count;
int n;
double sum = 0;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
thread_count = strtol(argv[1], 0, 10);
n = strtol(argv[2], 0, 10);
thread_handles = malloc(thread_c... | 0 |
#include <pthread.h>
extern pthread_mutex_t global_data_mutex;
void create_rrd_file(void);
void start_rrd_logging(void *) {
char *rrd_args[2];
struct stat info;
app_debug("RRD: Starting RRD logging thread\\n");
if (stat(global_config.rrd_file, &info) == -1) {
create_rrd_file();
... | 1 |
#include <pthread.h>
int buffer[100];
sem_t s1;
pthread_mutex_t semaphore_mutex;
void *producer_task(void *data);
void *consumer_task();
void print_array();
int main(void){
pthread_t t1,t2,t3,c1,c2;
sem_init(&s1,0,100);
print_array();
int d1=1,d2=2,d3=3;
if (pthread_create(&t1, 0,p... | 0 |
#include <pthread.h>
long long array[256];
int cnt, in, out;
pthread_mutex_t lock;
} buffer;
buffer * newBuffer(void) {
buffer * new = calloc(1, sizeof(buffer));
pthread_mutex_init(&new->lock, 0);
return new;
}
int addToBuffer(long long val, buffer * b) {
int rv = -1;
pth... | 1 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static int num_workers;
static int box_next;
static int non_box;
static unsigned int *boxcnt = 0;
struct nameround *next;
char *boxname;
int round;
} nameround_t;
static nameround_t *head = 0;
static int... | 0 |
#include <pthread.h>
int material;
int mm1;
int mm2;
int coloca;
pthread_mutex_t zain = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t tutzke = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t yaharadin = PTHREAD_MUTEX_INITIALIZER;
void agente (void* arg)
{
int r1=0;
int r2=0;
while(1){
... | 1 |
#include <pthread.h>
static pthread_t pthid, cthid;
static pthread_cond_t cond;
static pthread_mutex_t mux;
static int release;
static void *thread_for_consume(void *args);
static void *thread_for_produce(void *args);
static void init(void);
static void
init(void) {
release = 0;
pthread_mute... | 0 |
#include <pthread.h>
struct _args{
int n;
pthread_mutex_t mutex;
float lat;
} args;
float latency(void (*request)()) {
struct timeval begin, end;
float time_spent;
gettimeofday(&begin, 0);
request();
gettimeofday(&end, 0);
time_spent = (end.tv_sec - begin.t... | 1 |
#include <pthread.h>
int asc_code;
int ocorrencias;
}Caracter;
long posicao_global = 0;
long buffleng;
char *buffer;
Caracter *lista_asc;
pthread_mutex_t mutex;
int hashCode(int key) {
return ( key + 61) % 94;
}
int search(int key) {
int hashIndex = hashCode(key);
if(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static size_t i_gloabl_n = 0;
void *thr_demo(void *args)
{
printf("this is thr_demo thread, pid: %d, tid: %lu\\n", getpid(), pthread_self());
int i;
size_t t;
size_t tid = pthread_self();
setbuf(stdout, 0);
for (i =... | 1 |
#include <pthread.h>
int num_primos = 0;
int *arrayPrimos = 0;
int incremento = (int)(50/9);
pthread_mutex_t bufferPrimosLock = PTHREAD_MUTEX_INITIALIZER;
void *encontrarPrimos(void *param) {
int low = (int)param * incremento;
int high = low + incremento;
while (low < high) {
... | 0 |
#include <pthread.h>
static pthread_t guiplayerthread={0};
static pthread_cond_t cond={{0}};
static pthread_mutex_t mutex={{0}};
static pthread_mutex_t guimutex={{0}};
static bool goingtoend=0;
extern struct Root *root;
extern void P2MUpdateSongPosCallBack(void);
static void *Playe... | 1 |
#include <pthread.h>
char name[256];
static int name_i = 0;
static int ppi = 0;
pthread_mutex_t number_mutex;
pthread_mutex_t number2_mutex;
void recv_user_info(int con_fd, char *info)
{
if(recv(con_fd, info, sizeof(info), 0) < 0)
{
perror("recv");
exit(1);
}
}
void exe_in(int *con... | 0 |
#include <pthread.h>
char inputFile[100];
int wordCount = 1;
char* wordList[1024];
void* countWordFrequency(void *);
void countWord(char * filename);
void loadWordstoArray(char * filename);
void threadTask();
void consolidateResult();
void cleanupTask();
pthread_mutex_t lock;
pthread_t thr... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(5)];
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>
int main()
{
pthread_t thread1;
pthread_create( &thread1, 0, remote, 0);
pthread_join( thread1, 0);
return 0;
}
void remoteControllerCallback(uint16_t code, uint16_t type, uint32_t value)
{
switch(code)
{
case KEYCODE_INFO:
printf("\\nInfo pre... | 1 |
#include <pthread.h>
const int SIZE = 1024;
const int THREADS = 4;
const int CHUNK_SIZE = 64;
pthread_mutex_t count_lock;
int count;
int* all_nums;
void *dothing(void* data) {
while (1) {
pthread_mutex_lock(&count_lock);
int off = count * CHUNK_SIZE;
printf("%d\\n", c... | 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);
pthread_mute... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int avail=0;
int consumed=0;
int pause_thread(int pause_count){
int total=0;
for(int i=0;i<pause_count;++i){
total++;
}
return total;
}
void * produce(void * arg){
int id = *((int *)arg);
for... | 0 |
#include <pthread.h>
unsigned int gSharedResource = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t gWritePhase = PTHREAD_COND_INITIALIZER;
pthread_cond_t gReadPhase = PTHREAD_COND_INITIALIZER;
int gWaitingReaders = 0, gWriters = 0, gReaders = 0;
void *readerMain(void *threa... | 1 |
#include <pthread.h>
struct buffer
{
int array[10];
unsigned int front;
unsigned int rear;
pthread_mutex_t m;
}queue;
pthread_cond_t queue_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t queue_empty = PTHREAD_COND_INITIALIZER;
void *puta(void*arg)
{
srand(1092);
int value =0;
while (1)... | 0 |
#include <pthread.h>
void *funcionHilo1(void *p);
void *funcionHilo2(void *p);
volatile int variableGlobal = 10;
pthread_mutex_t m1;
int main(int argc, char **argv){
pthread_mutex_init(&m1, 0);
pthread_mutex_init(&m1, 0);
pthread_t h1;
pthread_t h2;
pthread_create(&h1, 0, funcionHilo1, 0);... | 1 |
#include <pthread.h>
pthread_mutex_t buffer_mutex;
int fill = 0;
char buffer[100][50];
char *fetch(char *link) {
int fd = open(link, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "failed to open file: %s", link);
return 0;
}
int size = lseek(fd, 0, 2);
assert(size >= 0);
ch... | 0 |
#include <pthread.h>
static void * routine_threads (void * argument);
static int aleatoire (int maximum);
pthread_mutex_t mutex_stdout = PTHREAD_MUTEX_INITIALIZER;
int main (void)
{
int i;
pthread_t thread;
for (i = 0; i < 5; i ++)
pthread_create(& thread, 0, routine_threads, (vo... | 1 |
#include <pthread.h>
long int chunk;
pthread_mutex_t lock_x;
void swapM(long int* a, long int* b)
{
long int aux;
aux = *a;
*a = *b;
*b = aux;
}
long int divideM(long int *vec, int left, int right)
{
int i, j;
i = left;
for (j = left + 1; j <= right; ++j)
{
... | 0 |
#include <pthread.h>
char domain_suffix[][32] = {
"AC",
"AD",
"AE",
"AERO",
"AF",
"AG",
"AI",
"AL",
"AM",
"AN",
"AO",
"AQ",
"AR",
"ARPA",
"AS",
"ASIA",
"AT",
"AU",
"AW",
"AX",
"AZ",
"BA",
"BB",
"BD",
... | 1 |
#include <pthread.h>
void main_constructor( void )
;
void main_destructor( void )
;
void __cyg_profile_func_enter( void *, void * )
;
void __cyg_profile_func_exit( void *, void * )
;
char* join3(char *s1, char *s2);
pthread_mutex_t mut;
void (*callback)() = 0;
double register_functi... | 0 |
#include <pthread.h>
char data = 'A';
int nb_lecteurs = 0;
pthread_mutex_t reading;
pthread_mutex_t writing;
pthread_mutex_t fifo;
void* lecteur(void *arg) {
int id = *((int*) arg);
int i;
for (i = 0; i < 5; i++) {
printf("Lecteur %d veut consulter la ressource\\n", id);
pthread_m... | 1 |
#include <pthread.h>
{
unsigned char* srcfileaddres;
unsigned char* destfileaddres;
unsigned int startfilepos;
unsigned int blocksize;
}fileblock;
unsigned char * g_srcfilestartp=0;
unsigned char * g_destfilestartp=0;
pthread_mutex_t g_mutex=PTHREAD_MUTEX_INITIALIZER;
void ou... | 0 |
#include <pthread.h>
int
pthread_barrier_init(pthread_barrier_t *barrier, pthread_barrierattr_t *attr,
unsigned int count) {
int rc = 0;
pthread_barrier_t b = 0;
if (barrier == 0)
return (EINVAL);
if (attr != 0) {
if (*attr == 0)
return (EINVAL);
if ((*attr)->pshared != PTHRE... | 1 |
#include <pthread.h>
int ncount;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* do_loop(void *data)
{
int i;
pthread_mutex_lock(&mutex);
for (i = 0; i < 10; i++)
{
printf("loop1 : %d", ncount);
ncount ++;
sleep(1);
}
pthread_mutex_unlock... | 0 |
#include <pthread.h>
static int s_num_threads = 10;
static int s_num_iterations = 1000;
static pthread_mutex_t s_mutex;
static long long s_grand_sum;
static pthread_rwlock_t s_rwlock;
static int s_counter;
static void* thread_func(void* arg)
{
int i, r;
int sum1 = 0, sum2 = 0;
for (i = s_n... | 1 |
#include <pthread.h>
sem_t footman;
void *philosopher (void*);
double delta, pi = 0.0;
int intervals = 100000;
static pthread_mutex_t forks[5];
int main() {
int i, id[5];
pthread_t tid[5];
for (i=0; i<5; i++)
pthread_mutex_init(&(forks[i]), 0);
sem_init(&foot... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t riders_waiting;
sem_t bus_arrival;
sem_t bus_depart;
int waiting = 0;
void * rider(){
while(1){
sem_wait(&riders_waiting);
pthread_mutex_lock(&mutex);
waiting = waiting + 1;
printf("RIDERS: riders waiting = %d \\n",waiting);
sle... | 1 |
#include <pthread.h>
static uint64_t global_int;
static pthread_mutex_t lock;
void bounds_error()
{
printf("Argument out of bounds:\\n"
"t must be between %lu and %lu,\\n"
"n must be between %lu and %lu.\\n",
1l, 16l, 1l, 1000000000l);
exit(1);
}
void *add_to_global(void *arg... | 0 |
#include <pthread.h>
struct sublist {
int start;
int end;
};
int N;
int P;
int args[64];
int A[0x500000];
struct sublist sublist_info[(0x500000 / 1024)];
volatile int head, tail;
volatile int sort_complete, sleepcount;
pthread_mutex_t mut;
pthread_cond_t cond_empty, cond_full;
pthread_b... | 1 |
#include <pthread.h>
ZERO = 0,
BLUE = 1,
RED = 2,
YELLOW = 3,
INVALID = 4,
} color;
char *colors[] = { "zero",
"blue",
"red",
"yellow",
"invalid"
};
char *digits[] = { "zero", "one", "two", "three", "four", "five",
"six", "seven", "eight", "nine"
};
... | 0 |
#include <pthread.h>
struct data
{
double *a;
double *b;
int len;
int offset;
};
pthread_t threads[8];
pthread_mutex_t mutex_sum;
double sum;
void *dot(void *arg)
{
int start;
int end;
int length;
double *x;
double *y;
double sub_sum;
struct data *d = (struct data*) arg;
l... | 1 |
#include <pthread.h>
int sum;
pthread_mutex_t mutex;
}Ticket,*Ticketpoint;
void* pthfunc1(void *p)
{
Ticketpoint ptic=(Ticketpoint)p;
while(1)
{
pthread_mutex_lock(&ptic->mutex);
if(ptic->sum>0)
{
printf("I am salewindow1,sum=%d\\n",ptic->sum);
sleep(2);
ptic->sum--;
printf("... | 0 |
#include <pthread.h>
int nitems;
struct
{
pthread_mutex_t mutex;
int buff[1000000];
int nput;
int nval;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
void *produce(void*);
void *consume(void*);
void consume_wait(int);
int main(int argc,char *argv[])
{
int i,nthreads,count[... | 1 |
#include <pthread.h>
char ipaddr[]="192.168.250.0";
int ipactual=1;
pthread_mutex_t p;
int ping(void) {
char *command = 0;
char buffer[1024];
FILE *fp;
int stat = 0;
asprintf (&command, "%s %s -c 1", "ping", ipaddr);
printf("%s\\n", command);
fp = popen(command, "r");
if (fp =... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void)
{
printf("parent locks...\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void)
{
printf("parent unlocking loc... | 1 |
#include <pthread.h>
int inn,inn_size;
int rl,fl,ry,fy,type;
pthread_mutex_t mutex;
pthread_cond_t lc[20];
pthread_cond_t yc[20];
int lqueue[20];
int yqueue[20];
pthread_t tid[20];
pthread_attr_t attr;
void initializeData() {
pthread_mutex_init(&mutex, 0);
pthread_attr_init(&attr);
int ... | 0 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 1;
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>
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t creating_theads_mutex = PTHREAD_MUTEX_INITIALIZER;
int creating_theads = 0;
static int **matris;
static int **matris2;
static int **matrisc;... | 0 |
#include <pthread.h>
char buf[30];
pthread_mutex_t lock;
pthread_t threads[2];
struct data
{
int threadId;
int filedesc;
};
struct data data1,data2;
void *write_func(void *arg)
{
struct data *i = (struct data*)arg;
int id = i->threadId;
int fd0 = i->filedesc;
char buffer[30];
prin... | 1 |
#include <pthread.h>
pthread_mutex_t mx;
pthread_mutex_t my;
pthread_mutex_t mz;
int x = 0;
void *ta(void *arg)
{
pthread_mutex_lock(&mx);
x = 1;
pthread_mutex_unlock(&mx);
pthread_mutex_lock(&mz);
pthread_mutex_unlock(&mz);
return 0;
}
void *tb(void *arg)
{
pthread_mutex_lock (&mx)... | 0 |
#include <pthread.h>
int counter = 0;
int thread_ids[3] = {0, 1, 2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_counter(void *data_in);
void *watch_counter(void *data_in);
int main(int argc, char *argv[])
{
int i;
long t1 = 1, t2 = 2, t3 = 3;
pthread_t threa... | 1 |
#include <pthread.h>
struct person
{
int num;
double sum;
}Person;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void creat_ret()
{
int num ;
double sum ;
printf("请输入红包的个数和金额：");
scanf("%d %lf",&num,&sum);
pthread_mutex_lock(&mutex);
Person.num ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void* salewin2(void *p){
int *t=(int*) p;
while(1){
pthread_mutex_lock(&mutex);
if(*t>0){
printf(" salewin2 starts %d\\n",*t);
sleep(2);
(*t)--;
pthread_mutex_unlock(&mutex);
printf(" salewin2 ... | 1 |
#include <pthread.h>
static void
dbgprintf (const char *fmt, ...)
{
struct timespec tp;
va_list ap;
if (clock_gettime (CLOCK_MONOTONIC, &tp) == 0)
printf ("%lu.%lu ", tp.tv_sec, tp.tv_nsec);
__builtin_va_start((ap));
vprintf (fmt, ap);
;
}
static int ready[10];
static pthread... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int a = 0;
void *thread_a(void *arg) {
while(1) {
pthread_mutex_lock(&mutex);
a = 1;
if(1) {
printf("a %d\\n", a);
}
usleep(10000);
}
return 0;
}
void *thread_b(void *arg) {
while(1) {
pthread_mutex... | 1 |
#include <pthread.h>
int sockfd;
int cameraFd;
char unsigned *devconfp;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void sig_handler(int signo)
{
if(SIGINT == signo){
printf("SIGINT will be exist!\\n");
close(sockfd);
... | 0 |
#include <pthread.h>
pthread_mutex_t mymutex;
float * px = 0;
static void * affiche_max_fois_valeur_px (void * p_data)
{
int max = (int) p_data;
int i;
for (i = 0; i < max; i++) {
pthread_mutex_lock(&mymutex);
printf("[thread] %f\\n", *px);
pthread_mutex_unlock(&mymutex);
}
ch... | 1 |
#include <pthread.h>
pthread_cond_t buffer_cheio = PTHREAD_COND_INITIALIZER;
pthread_cond_t buffer_vazio = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int posicoes_ocupadas=0;
int valor=0;
int buffer[50];
void *produtor(void *argumentos){
while (1){
p... | 0 |
#include <pthread.h>
pthread_mutex_t cerrojo;
pthread_mutex_t lectores;
int dato = 5;
int n_lect = 0;
void *Lector(void *arg);
void *Escritor(void *arg);
int main(int argc, char *argv[]) {
pthread_t th1, th2, th3, th4;
pthread_mutex_init(&cerrojo, 0);
pthread_create(&th1, 0, Le... | 1 |
#include <pthread.h>
int buf[64];
sem_t space_nums;
sem_t data_nums;
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void *product(void *arg)
{
int index = 0;
while(1){
sem_wait(&space_nums);
pthread_mutex_lock(&lock1);
buf[index... | 0 |
#include <pthread.h>
enum Protocol {
UPLOAD_PROTO = 0, INFO_PROTO = 1, AUDIO_PROTO = 2, VIDEO_PROTO = 3, INTERN_PROTO = 4
};
static struct libwebsocket_protocols protocols[] = { { "upload", callback_upload, sizeof(struct upload_user), RX_BUFFER_SIZE }, { "info",
callback_info, sizeof(struct to... | 1 |
#include <pthread.h>
int valoresA[16], valoresB[16];
int separacao;
int sum = 0;
pthread_mutex_t mutex;
int calcularFinal(int threadAtual, int inicio){
if(threadAtual == 4 - 1){
int maiorFinalPossivel = 4 * separacao;
if(maiorFinalPossivel < 16){
return 16;
}
}
return inicio + separ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_attr_t attr;
pthread_t thread_id, thread_id2, thread_id3, thread_id4, thread_id5;
sem_t items, spaces;
int x = 1;
struct buffer_item {
int value;
int wait_time;
};
struct args{
long tid;
long sleep_time;
};
struct buffer_item buf... | 1 |
#include <pthread.h>
void *avoid(long droneid, int *homeRow, int *homeCol, int *targetRow, int *targetCol){
printf("Drone %d Avoiding Drone Near (%d, %d)!!!\\n", droneid, *homeRow, *homeCol);
pthread_mutex_lock(&mutex3);
if(d.grid[*homeRow+1][*homeCol]==0)
increaseRow(droneid, homeRow, home... | 0 |
#include <pthread.h>
pthread_mutex_t a;
pthread_mutex_t c;
pthread_mutex_t f;
pthread_mutex_t g;
int k;
int j;
void* fn1(void * args){
pthread_mutex_lock(&a);;
if( k == 25 ){
pthread_mutex_unlock(&f);;
pthread_mutex_lock(&g);;
if( j )
printf("hola\\n");
else
printf("ad... | 1 |
#include <pthread.h>
int fd_list_open(struct shfs *fs, const char *name, size_t length)
{
char tmp_fname[1024];
char main_fname[1024];
size_t i;
fprintf(stderr, "FD_LIST opening %d bytes '%s'\\n", (int)length, name);
pthread_mutex_lock(&fs->fdlock);
if (fs->fdsize <= fs->fdlen) {
fpri... | 0 |
#include <pthread.h>
int w, h;
v2df zero = { 0.0, 0.0 };
v2df four = { 4.0, 4.0 };
v2df nzero;
double inverse_w;
double inverse_h;
char *whole_data;
int y_pick;
pthread_mutex_t y_mutex = PTHREAD_MUTEX_INITIALIZER;
static void * worker(void *_args) {
char *data;
double x, y;
int ... | 1 |
#include <pthread.h>
struct handler_list {
void (*handler)(void);
struct handler_list * next;
};
static pthread_mutex_t pthread_atfork_lock = PTHREAD_MUTEX_INITIALIZER;
static struct handler_list * pthread_atfork_prepare = 0;
static struct handler_list * pthread_atfork_parent = 0;
static stru... | 0 |
#include <pthread.h>
int q[5];
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 < 5)
... | 1 |
#include <pthread.h>
pthread_mutex_t *mutex;
int canHebras;
void *listarHebras (void *args){
int *i = (int *) args;
pthread_mutex_lock(&mutex[*i]);
printf("Soy una hebra y mi tid es: %d\\n",*i);
pthread_mutex_unlock(&mutex[*i+1]);
pthread_exit(0);
}
int main(int argc, char *argv... | 0 |
#include <pthread.h>
void sighandler(int signum);
void* countdown_thread(void *unused);
void* keyevents_thread(void *unused);
void thread_create_error(char* threadname);
void init_param(void);
int main();
int countdown;
int timeout;
int threads_active = 1;
int fd;
char* kbd_events_device;
pthread... | 1 |
#include <pthread.h>
int mulFactor;
pthread_mutex_t lock;
pthread_cond_t lockCond;
void *PrintMulTable()
{
pthread_mutex_lock(&lock);
while(mulFactor==0)
pthread_cond_wait(&lockCond,&lock);
int i;
for(i=0; i<11;i++){
printf("%d",i*mulFactor);
}
printf("\\n");
pthread_mutex_un... | 0 |
#include <pthread.h>
void tdb_init
(FILE* logger, int* argc, char** argv)
{
td = malloc(sizeof(*td));
if (td == 0) {
(void)fputs("\\n[EE] Not enough memory to start\\n", stderr);
pthread_exit(0);
}
pthread_mutex_init(&td->logger_lock, 0);
td->logger = logger;
if (td->logger == 0) {
t... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condizione = PTHREAD_COND_INITIALIZER;
int n=0;
int glob=0;
int i=0;
int j=0;
int **matrice=0;
int numT=0;
int flag=0;
void *funzione(void *param){
int indice =*(int*)param;
for (int j = 0; j < 5; j++)
{... | 0 |
#include <pthread.h>
void* pthTextCode_run(void *arg){
int sock_fd;
int flag;
int ret;
int option;
int *retval;
int low = 1e5;
int high = 1e6;
int rand_number;
char *buff;
struct sockaddr_in udpaddr;
struct sockaddr_in client;
retval = 0;
buff = 0;
sock_fd = socket(AF_INE... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t fill = PTHREAD_COND_INITIALIZER;
int pos = 0;
int black_list[4];
int buffer[120];
int qtd_hackers=4, blocked=0;
int hackwin = 0;
void *producer(void *id){
... | 0 |
#include <pthread.h>
pthread_mutex_t mymutex_px;
pthread_mutex_t mymutex_py;
float * px = 0;
float * py = 0;
static void * affiche_max_fois_valeur_px (void * p_data)
{
int max = (int) p_data;
int i;
for (i = 0; i < max; i++) {
pthread_mutex_lock(&mymutex_px);
printf("[thread1] %f\\n... | 1 |
#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(&pthre... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.