text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
volatile long work_counter;
int req_count;
pthread_mutex_t q_lock;
void grab_lock() {
pthread_mutex_lock(&q_lock);
}
void ungrab_lock() {
pthread_mutex_unlock(&q_lock);
}
void do_work() {
for (int i = 0; i < 50000; ++i)
++work_counter;
}
void * request_... | 1 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t lock1;
pthread_mutex_t lock2;
void* thr_main1(void* arg) {
puts("thread 1 start\\n");
pthread_mutex_lock(&lock1);
sleep(1);
pthread_mutex_lock(&lock2);
counter++;
sleep(1);
pthread_mutex_unlock(&lock2);
pthread_... | 0 |
#include <pthread.h>
int npos;
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
int buf[10000000], pos=0, val=0;
void *fill(void *nr)
{
while (1) {
pthread_mutex_lock(&mut);
if (pos >= npos) {
pthread_mutex_unlock(&mut);
return 0;
}
buf[pos] = val;
pos++; va... | 1 |
#include <pthread.h>
int r1 = 0, r2 = 0, counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void do_one_thing() {
pthread_mutex_lock(&mutex);
counter++;
printf("job %d started\\n", counter);
for (int i = 0; i < 4; i++) {
printf(" doing one thing\\n");
... | 0 |
#include <pthread.h>
pthread_mutex_t mtx;
pthread_cond_t espera;
int tenedores[5];
pthread_mutex_t mtxIndice;
pthread_cond_t esperaIndice;
int hiloespera=1;
void *filosofo(void *indice) {
int i,j,tenedor1,tenedor2;
srandom ((unsigned)pthread_self());
pthread_mutex_lock(&mt... | 1 |
#include <pthread.h>
int MaxLoop = 50000;
int NumProcs;
pthread_barrier_t barrier;
unsigned sig[33] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32 };
union {
char b[6... | 0 |
#include <pthread.h>
void *producter_f(void *arg);
void *consumer_f(void *arg);
int buffer_has_item = 0;
pthread_mutex_t mutex;
int running = 1;
int main(int argc,char* argv[])
{
pthread_t consumer_t;
pthread_t producter_t;
pthread_mutex_init(&mutex,0);
pthread_create(&producter_t,0,(void*... | 1 |
#include <pthread.h>
int total=0;
pthread_mutex_t zain = PTHREAD_MUTEX_INITIALIZER;
void hilo(void* arg)
{
FILE * fp;
char * line = 0;
size_t len = 0;
ssize_t read;
int num=0;
int suma=0;
int kuz= 100000/1000;
kuz=8;
int start =0;
int e... | 0 |
#include <pthread.h>
void *sending();
char achData[1000];
char *achEXE[1];
int iConnectionDis;
pthread_t serverThread;
pthread_mutex_t mutexLock;
int main()
{
int iIndex;
int iSocketDis;
int iLenght;
struct sockaddr_in serv_addr;
int i;
iSocketDis=socket(AF_INET,SOCK_STREAM,0);
serv_ad... | 1 |
#include <pthread.h>
char* buffer[BUFFER_SIZE][NAME_SIZE];
int bufferpropos=0;
int bufferconspos=0;
pthread_mutex_t esctrin;
pthread_mutex_t lertrin;
sem_t escsem;
sem_t lesem;
bool pipeclosed=1;
long int reader() {
char* file_to_open=malloc(sizeof(char)*NAME_SIZE);
while(pipeclosed) {... | 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 = ... | 1 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void clock_gettime(int id, struct timespec *tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
... | 0 |
#include <pthread.h>extern void __VERIFIER_error();
static int iTThreads = 2;
static int iRThreads = 1;
static int data1Value = 0;
static int data2Value = 0;
pthread_mutex_t *data1Lock;
pthread_mutex_t *data2Lock;
void lock(pthread_mutex_t *);
void unlock(pthread_mutex_t *);
void *funcA(void *param)
{
pthread_mutex_l... | 1 |
#include <pthread.h>
int flag = 0;
int counter =0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t threshold = PTHREAD_COND_INITIALIZER;
void *tf(void *param){
int i;
while (1) {
pthread_mutex_lock(&mutex);
if(counter == 5000000){
do { } while (0);
... | 0 |
#include <pthread.h>
pthread_mutex_t sync_mutex;
int count = 0;
int totals[10];
void* increment_count() {
FILE* fout = 0;
fout = fopen("inc_out.txt", "w");
if(0 == fout) {
printf("Error opening inc file\\n");
exit(1);
}
for(int i = 0; i < 10; ++i) {
++count;
if(i > 0) {
totals[i... | 1 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
void func(void *arg) {
struct timespec tm = {
.tv_sec = 100000,
.tv_nsec = 0,
};
int msg = pthread_mutex_timedlock(&mtx, &tm);
if (msg != 0) {
printf("msg = %d\\n", msg);
... | 0 |
#include <pthread.h>
int qtde = 0;
pthread_mutex_t mut;
sem_t msg, prupru;
void *pombo(void)
{
while(1)
{
sem_wait(&prupru);
pthread_mutex_lock(&mut);
puts("^(0.0)^ Levando mensagens ^(0.0)^");
int i;
for(i = 0; i < 20; i++) s... | 1 |
#include <pthread.h>
pthread_mutex_t gm;
struct bar{
int a;
char c[15000];
};
struct foo{
int id;
struct bar b;
};
struct thread_data {
int tid;
struct foo *local_data;
};
void *t(void *args){
struct thread_data *data = (struct thread_data*)args;
int tid = d... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condVar;
void Start()
{
printf("new thread here: %u\\n", (unsigned)pthread_self());
while(1)
{
pthread_mutex_lock(&mutex);
printf("\\tthread signal %u\\n", (unsigned)pthread_self());
pthread_cond_signal(&condVar);
pthread_mut... | 1 |
#include <pthread.h>
struct s {
int datum;
struct s *next;
};
struct s *new(int x) {
struct s *p = malloc(sizeof(struct s));
p->datum = x;
p->next = 0;
return p;
}
void list_add(struct s *node, struct s *list) {
struct s *temp = list->next;
list->next = node;
node->next = temp... | 0 |
#include <pthread.h>
void* wheelTimer(void *data) {
printf("Poll thread is running...\\n");
struct hallThreadData* threadData;
threadData = (struct hallThreadData*)data;
int pollReturn, readReturn;
char* buffer[64];
struct timeval systemTime;
struct pollfd gpioDesc... | 1 |
#include <pthread.h>
static struct Directory directory[ENTRIES];
static pthread_mutex_t directoryMutex;
void DirectoryInit()
{
int i;
pthread_mutex_init(&directoryMutex, 0);
for (i = 0; i < ENTRIES; i++) {
directory[i].used = 0;
}
}
void DirectoryAdd(char *file, struct socka... | 0 |
#include <pthread.h>
struct object
{
pthread_mutex_t mutex;
int data;
};
void object_init(struct object *object)
{
object->data = 0;
}
void object_method_0(struct object *object)
{
pthread_mutex_lock(&object->mutex);
object->data++;
pthread_mut... | 1 |
#include <pthread.h>
inline int obd_data(int obd_flag ,unsigned char* buf)
{
pthread_mutex_lock(&g_mtx);
char* buf_rcv[256];
unsigned char buf_tmp[256]={0};
int wread=0;
int i;
memset(buf_rcv,0,256);
buf_rcv[0] = "BT+MIL\\r\\n";
buf_rcv[1] = "BT+SPWR\\r\\n";
buf_rcv... | 0 |
#include <pthread.h>
void *consumeTen();
void *consumeFifteen();
struct data
{
char name;
int pearlsTaken;
int *pearls;
};
int pearls = 1000;
pthread_mutex_t mutex;
pthread_cond_t full_cond;
pthread_cond_t empty_cond;
struct data threadData[4];
int main()
{
int i, j;
pthread_t... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex;
static pthread_cond_t cond;
void printBuf(unsigned char *buf, int len) {
int i = 0;
printf("address:%d\\n", buf);
for (i=0; i<len; i++) {
printf("%x ", buf[i]);
}
printf("\\n");
}
void *test_thread(void *arg) {
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_device;
int found = -1;
char *found_path_file;
char *get_event_file_path(int id_file){
char id_file_c[4];
snprintf(id_file_c, sizeof(id_file_c), "%d", id_file);
char *partial_path = "/dev/input/event";
char *complete_path = (char *) malloc(st... | 1 |
#include <pthread.h>
int in = 0;
int out = 0;
int buff[10] = {0};
sem_t empty_sem;
sem_t full_sem;
pthread_mutex_t mutex;
int product_id = 0;
int prochase_id = 0;
void print()
{
int i;
for(i = 0; i < 10; i++)
printf("%d ", buff[i]);
printf("\\n");
}
void *product()
{
int id = ++product_id;
... | 0 |
#include <pthread.h>
long ninc_per_thread;
long a;
long b;
long r;
long * p;
pthread_mutex_t * m;
} arg_t;
void * f(void * arg_) {
arg_t * arg = (arg_t *)arg_;
long a = arg->a, b = arg->b;
long ninc_per_thread = arg->ninc_per_thread;
if (b - a == 1) {
int i;
for (i =... | 1 |
#include <pthread.h>
void *thread_function(void *arg);
pthread_mutex_t work_mutex;
char work_area[1024];
int time_to_exit = 0;
int main() {
int res;
pthread_t a_thread;
void *thread_result;
res = thread_mutex_init(&work_mutex, 0);
if (res != 0) {
perror("Mutex initialization failed");
... | 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>
pthread_mutex_t mutex;
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_rwlock_t rwlock;
pthread_cond_t cond;
static int do_output;
static void output(char *string)
{
if (!do_output)
return;
printf("%s", string);
}
void *thread_func(void *p)
{
output(... | 0 |
#include <pthread.h>
double *a, *b, sum;
int length;
} DOTDATA;
DOTDATA dotstr;
pthread_mutex_t mutexsum;
void *dotprod (void *rank){
int i, start, end, len;
double my_sum, *x, *y;
int my_rank = (int) rank;
len = dotstr.length;
start = my_rank*len;
end = start + len;
... | 1 |
#include <pthread.h>
static void* (*malloc0)(size_t size);
static void (*free0)(void* ptr);
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int fd;
static void
init()
{
* (void**)&malloc0 = dlsym(RTLD_NEXT, "malloc");
* (void**)&free0 = dlsym(RTLD_NEXT, "free");
... | 0 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cnd = PTHREAD_COND_INITIALIZER;
struct global_data{
char task;
const int count;
};
void * task_a(void * ctx)
{
struct global_data *d = ctx;
int i;
printf("started task_a\\n");
printf... | 1 |
#include <pthread.h>
pthread_mutex_t w_lock;
pthread_mutex_t r_lock;
int readcnt=0;
FILE *fp;
void *writer(void *args){
int pos=*(int*)args;
char ch;
pthread_mutex_lock(&w_lock);
fp=fopen("test.txt","a");
if(fp==0)
printf("\\nUnable to open file\\n");
else{
printf("\\nThe thread no. %d is... | 0 |
#include <pthread.h>
const char* const short_options = "hlsc";
const struct option long_options[] = {
{"help", 0, 0, 'h'},
{"lock", 0, 0, 'l'},
{"semaphore", 0, 0, 's'},
{"condition", 0, 0, 'c'},
{0, 0, 0 , 0}
};
void semaphore_case(void);
void* sem_thread_fun(void* arg);
void lock... | 1 |
#include <pthread.h>
int N, C, D, tmin, tmax;
pthread_mutex_t hashi[20];
pthread_t filosofo[20];
int id[20], refeicoes[20];
enum _status { PENSANDO, FAMINTO, COMENDO } status[20];
void pegaHashi(int f){
pthread_mutex_lock(&hashi[f]);
printf("Filosofo %d esta com fome e pegou o 1o ... | 0 |
#include <pthread.h>
struct producers {
int buffer[4];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct producers *b) {
pthread_mutex_init(&b->lock, 0);
pthread_cond_init(&b->notempty, 0);
pthread_cond_init(&b->notf... | 1 |
#include <pthread.h>
count_t total_ccount = 0;
count_t total_wcount = 0;
count_t total_lcount = 0;
char **file_list = 0;
int file_count;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct file_data {
count_t *ccount;
count_t *wcount;
count_t *lcount;
};
static void
erro... | 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>
pthread_mutex_t tabaco;
pthread_mutex_t papel;
pthread_mutex_t lanzaLLamas;
pthread_mutex_t ocupado0;
pthread_mutex_t ocupado1;
pthread_mutex_t ocupado2;
int hay_tabaco;
int hay_papel;
int hay_lanzaLLamas;
int esta_ocupado0;
int esta_ocupado1;
int esta_ocupado2;
void *agen... | 0 |
#include <pthread.h>
int post_signal(pthread_t pth, int sig)
{
int res;
if( pth <= 0 ) {
return FAIL;
}
res = pthread_kill(pth, sig);
if(res != 0) {
LOG(m_res, ERROR, "send signal to thread failed\\n");
return FAIL;
}
LOG(m_res, DEBUG, "send si... | 1 |
#include <pthread.h>
sem_t even_lock, odd_lock;
pthread_mutex_t even_mutex, odd_mutex;
void * even_thread(void *args) {
int i = 0;
while (i < 10) {
sem_wait(&even_lock);
sleep(random()%3);
printf("%d\\n", i);
i+=2;
sem_post(&odd_lock);
}
pthread_exit(0)... | 0 |
#include <pthread.h>
static inline bool irq_masked(intr) {
return intr >= __NR_INTR_MASK_MIN
&& intr <= __NR_INTR_MASK_MAX
&& intr_line.intr_masked;
}
static void reset_all_intrs(void) {
pthread_mutex_lock(&intr_line.intr_mutex);
intr_line.intr[0] = 0;
intr_line.intr[1] = 0;
intr_l... | 1 |
#include <pthread.h>
const char* SPLITTER = "\\n--------------------------------------------------\\n";
const int ARRAYS_NUMBER = 4;
char* DEFAULT_SORTING_MODE = "ASC";
int workersCompleted = 0;
pthread_mutex_t lock;
struct bubbleSortArgs {
int* array;
int arraySize;
char* mode;
};
int* ... | 0 |
#include <pthread.h>
struct arg_set{
char *fname;
int count;
};
struct arg_set *mailbox;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag=PTHREAD_COND_INITIALIZER;
int main(int ac,char *av[]){
pthread_t t1,t2;
struct arg_set args1,args2;
void *count_words(void *);
int report... | 1 |
#include <pthread.h>
int *arr;
int num;
} Arr_Num;
int n, v[50000000], step;
Arr_Num *an_list[50000000];
pthread_t tid[50000000], tid2[50000000];
pthread_mutex_t mutex;
int cmp(const void *a, const void *b) {
return *(int*)a - *(int*)b;
}
int min(int a, int b) {
return a < b ? a : b;
}
i... | 0 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
char var[20];
void* child1(void *p)
{
int k=0;
pthread_mutex_lock(&m1);
printf("\\nENTER U MESSAGE:");
gets(var);
k=strlen(var);
printf("\\nUR MESSAGE HAS BEEN SENT BY CHILD... | 1 |
#include <pthread.h>
char* shm;
pthread_mutex_t* mutex;
int bNeedInit = 0;
char* attach_shm()
{
int fd = shm_open("/share_m", O_RDWR|O_CREAT|O_EXCL, 0777);
if(fd > 0)
{
ftruncate(fd, 4096);
bNeedInit = 1;
}
else
{
fd = shm_open("/share_m", O_RDW... | 0 |
#include <pthread.h>
pthread_mutex_t cond_mutex;
pthread_cond_t cond;
int count = 0;
void* function_cond1(void*);
void* function_cond2(void*);
void practice_cond();
void practice_cond() {
pthread_t thread1,thread2;
pthread_mutex_init(&cond_mutex, 0);
pthread_cond_init(&cond,0... | 1 |
#include <pthread.h>
void *mathProfArrive();
void *mathProfLeave();
void *csProfArrive();
void *csProfLeave();
void delay(int);
int sign_value = -1;
int numCsProfsInRoom = 0;
int numMathProfsInRoom = 0;
pthread_mutex_t sign_mutex;
pthread_cond_t csProfsCv;
pthread_cond_t mathProfsCv;
int mai... | 0 |
#include <pthread.h>
static inline void ws2801_auto_commit(struct ws2801_driver *ws_driver)
{
if (ws_driver->auto_commit)
ws_driver->commit(ws_driver);
}
int ws2801_init(struct ws2801_driver *ws_driver, unsigned int num_leds)
{
int err;
ws_driver->leds = calloc(num_leds, sizeof(struct led)... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void dieWithError(char *msg)
{
printf("[-]ERROR:%s\\n", msg);
exit(0);
}
void* writer(void *arg)
{
int fd, string_num = 1;
char buffer[128];
time_t rawtime;
struct tm *timeinfo;
while(1)
{
pthread_mutex_lock(&m... | 0 |
#include <pthread.h>
void gw_dm_pending ( void *_job_id )
{
gw_job_t * job;
int job_id;
if ( _job_id != 0 )
{
job_id = *( (int *) _job_id );
job = gw_job_pool_get(job_id, GW_TRUE);
if ( job == 0 )
{
gw_log_print("DM",'E',"Job %i does not exist (JOB_STATE_PENDING).\\n",... | 1 |
#include <pthread.h>
struct jfs *jfopen(const char *path, const char *mode)
{
int flags;
int pos_at_the_beginning;
struct jfs *fs;
if (strlen(mode) < 1)
return 0;
if (mode[0] == 'r') {
pos_at_the_beginning = 1;
if (strlen(mode) > 1 && strchr(mode, '+'))
flags = O_RDWR;
else
... | 0 |
#include <pthread.h>
static char * previousToken;
static char * currentToken;
static time_t tokenGeneratedTime;
static pthread_mutex_t tokenMutex;
void initTokenGenerator()
{
srand((unsigned)time(0));
pthread_mutex_init(&tokenMutex, 0);
}
static
int isTokenExpired()
{
time_t now... | 1 |
#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;
l... | 0 |
#include <pthread.h>
int begin;
int end;
int k;
} msg_t;
pthread_t * threads;
int * results;
int can_read = 0;
pthread_cond_t read_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t read_mutex = PTHREAD_MUTEX_INITIALIZER;
int count(int n){
int i,j=0;
for(i=2; i*i <= n; i+... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1, mutex2;
int a = 1, b = 1;
void *tfc(void *arg)
{
int err;
srand(time(0));
while(1) {
pthread_mutex_lock(&mutex1);
sleep(rand()%3);
pthread_mutex_trylock(&mutex2);
if(err) {
pthread_mutex_unlock(&mutex1);
}
printf("sub thread get a = %... | 0 |
#include <pthread.h>
int l, r;
} Info;
int l1, r1, l2, r2;
} pmInfo;
int* A;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t v = PTHREAD_MUTEX_INITIALIZER;
int cmp(const void* a, const void* b)
{
int pa = *(int*) a;
int pb = *(int*) b;
if(pa > pb) return 1;
else if(pa < pb... | 1 |
#include <pthread.h>
int quit,sum;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc =PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int i = *(int *)arg;
printf("thr_fn\\n");
if (i==0){
printf("the transfer the param success\\n");
pthread_mutex_lo... | 0 |
#include <pthread.h>
int arr[100 ];
pthread_mutex_t lock;
sem_t c;
struct t
{
int low , high;
} l3;
void * sort(void *b)
{ pthread_t th0,th1;
int low,high;
struct t *y1= (struct t *) b;
low = y1->low;
high = y1->high;
struct t l2,l1;
if(low<high)
{
pthread_t th0,th1;
... | 1 |
#include <pthread.h>
int in = 0;
int out = 0;
int buff[10] = {0};
sem_t empty_sem;
sem_t full_sem;
pthread_mutex_t mutex;
int product_id = 0;
int prochase_id = 0;
void print()
{
int i;
for(i = 0; i < 10; i++)
printf("%d ", buff[i]);
printf("\\n");
}
void *product()
{
int id = ++produ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
void fun(void);
void *thread_func(void *args)
{
printf("%lu locking mutex\\n",pthread_self());
pthread_mutex_lock(&mutex);
printf("%lu locked mutex\\n",pthread_self());
fun();
sleep(2);
pthread_mutex_unlo... | 1 |
#include <pthread.h>
struct person_info {
int sex;
char name[32 +1];
int age;
};
pthread_mutex_t mutex;
void *write_thread_routine(void * arg)
{
int i;
char buf[1024];
struct person_info *pInfo = (struct person_info *)arg;
printf("I'm sub thread,my thread ID is:0x%x\\n", (int)pthr... | 0 |
#include <pthread.h>
volatile int nShared = 0;
pthread_mutex_t verrou;
void* decr(void* ptr)
{
char* msg = (char*) ptr;
int count = 10000;
while(count>0)
{
pthread_mutex_lock(&verrou);
while(nShared<=0)
{
pthread_mutex_unlock(&verrou);
sched_yield();
pthread_mutex_lock(&verrou)... | 1 |
#include <pthread.h>
int n;
sockaddr_in from = { 0 };
int fromsize = sizeof from;
char buffer[1025];
int threadsit = 0;
pthread_t threads[10] = {0};
pthread_mutex_t buffer_lock, socket_lock;
void *sendroutine() {
sockaddr_in sin = { 0 };
sin.sin_addr.s_addr = htonl(INADDR_ANY);
sin.si... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex;
static sem_t empty;
static sem_t full;
void init(void)
{
pthread_mutex_init(&mutex, 0);
sem_init(&empty, 0, 40);
sem_init(&full, 0, 0);
}
void producer(int max)
{
int i;
int item;
for(i = 0; i < max... | 1 |
#include <pthread.h>
int i;
pthread_cond_t rc;
pthread_mutex_t rm;
int r_counter;
pthread_cond_t wc;
pthread_mutex_t wm;
int w_counter;
}Storage;
void set_data(Storage *s,int i)
{
s->i = i;
}
int get_data(Storage *s)
{
return s->i;
}
void *set_th(void *arg)
{... | 0 |
#include <pthread.h>
int tab [100];
int finish = 0;
pthread_mutex_t verrou;
void swap(int *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void* bubbleSort()
{
pthread_mutex_lock(&verrou);
int i, j;
for (i = 0; i < 100 -1; ++i){
for (j = 0; j < 100 -i-1; ++j... | 1 |
#include <pthread.h>
int thread_flag;
pthread_mutex_t thread_flag_mutex;
void initialize_flag() {
pthread_mutex_init(&thread_flag_mutex, 0);
thread_flag = 0;
}
void do_work()
{
printf("Doing work\\n");
sleep(1);
}
void* thread_function(void* thread_arg) {
while (1) {
int flag_is_set;
... | 0 |
#include <pthread.h>
pensar,
fome,
comer,
} Filosofos;
int Filosofos_esquerda(int filo_n);
int Filosofos_direita(int filo_n);
void *Filosofos_checkin(void *filo);
pthread_mutex_t forks;
Filosofos *FilosofosN;
int main(int filo, char **time){
pthread_t *thread;
int CADEIR... | 1 |
#include <pthread.h>
static pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
int lksmith_get_ignored_frame_patterns(char *** ignored, int *num_ignored);
static int check_ignored_frame_patterns(void)
{
char **ignored = 0;
int num_igno... | 0 |
#include <pthread.h>
extern struct free_pool_data* free_pool_table;
extern struct file_cache* file_cache_head;
void file_cache_unpin_files(struct file_cache *cache, const char **files, int num_files){
int i;
struct file_data header_ptr;
struct file_data* temp_ptr;... | 1 |
#include <pthread.h>
int NB_FICHIER_TODO = 0;
pthread_mutex_t mutex_nb_fichier = PTHREAD_MUTEX_INITIALIZER;
void* upperDeleg(void* arg) {
char** paths = (char **) arg;
int *ret = malloc(sizeof(int));
pthread_mutex_lock(&mutex_nb_fichier);
while(NB_FICHIER_TODO > 0) {
int filenumber = NB_FIC... | 0 |
#include <pthread.h>
int arr[1000][1000];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void initArray()
{
int i = 0;
int j = 0;
for (i = 0; i < 1000; i++)
{
for (j = 0; j < 1000; j++)
{
srand(time(0));
arr[i][j] = rand() % 1 + 1;
... | 1 |
#include <pthread.h>
pthread_t tid[10];
pthread_mutex_t critical;
int total;
struct PROCESSOR
{
int clk,incr,id;
};
struct PROCESSOR p[10],sender;
void* increment(void *proc)
{
struct PROCESSOR*current=(struct PROCESSOR*)proc;
while(1)
{
sleep(2);
printf("Incrementing Processor %d's c... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t semph;
int risultatiSondaggi[3][5];
int n;
float avg[3];
} gestoreSondaggi;
gestoreSondaggi G;
void printResults()
{
int i, j, sum;
for(i=0; i<3; i++)
{
for(j=0, sum=0; j<5; j++)
{
if(G.risultatiSondaggi[i][j]!=0)
... | 1 |
#include <pthread.h>
void *producer(void *param);
void *consumer(void *param);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t buf_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t buf_empty = PTHREAD_COND_INITIALIZER;
int times;
int con_count;
int num_consumed = 0;
int buf... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
pthread_t chCliente;
pthread_t caixas [5];
int filas_vazia = 5;
int clientes=20;
sem_t filas [5];
int cliente_fila = 0... | 1 |
#include <pthread.h>
void tq_init(struct tqFormat *tqh, int qlen) {
pthread_mutex_init(&tqh->count_mutex, 0);
pthread_cond_init (&tqh->count_empty_cv, 0);
pthread_cond_init (&tqh->count_full_cv, 0);
tqh->count = 0;
tqh->have_data = 1;
tqh->qlen = qlen;
printf("qlen %i\\n",tqh... | 0 |
#include <pthread.h>
struct product_cons
{
int buffer[5];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
pthread_mutex_t lock2;
int cnt_p;
pthread_mutex_t lock3;
int cnt_c;
}buffer;
void init(struct product... | 1 |
#include <pthread.h>
struct testdata
{
pthread_mutex_t mutex;
pthread_cond_t cond;
} td;
int t1_start = 0;
int signaled = 0;
void *t1_func(void *arg)
{
int rc;
struct timespec timeout;
struct timeval curtime;
if (pthread_mutex_lock(&td.mutex) != 0) {
fprintf(stderr,"Thread1: Fail to a... | 0 |
#include <pthread.h>
int conPos = 0, proPos = 0;
int *buffer;
sem_t full, empty;
static int INDEX = 85;
pthread_cond_t consumer_cond;
pthread_mutex_t count_mutex;
FILE* logFile;
int main(void){
pthread_t threads[TTL_THREADS];
pthread_attr_t attr;
logFile = fopen("./logLinux.txt", "wt");
... | 1 |
#include <pthread.h>
int propertyIndex, numThreads, segmentLength, numSegments;
char *S;
int Stail = 0;
int segmentsThatSatisfy = 0;
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
char c0, c1, c2;
void *threadFunc(void* threadIndexArg)
{
long threadIndex = (long)threadIndexArg;
char ... | 0 |
#include <pthread.h>
struct Madt *apics = 0;
struct Srat *srat = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static void *core_proxy(void *arg)
{
int coreid = (int)(long)arg;
pin_to_core(coreid);
struct Apicst *new_st = calloc(1, sizeof(struct Apicst));
new_st->type = ASlapi... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* thread_write(void*);
void* thread_read(void*);
int
main(int argc, char **argv)
{
pthread_t t_write;
pthread_t t_read;
evthread_use_pthreads();
struct e... | 0 |
#include <pthread.h>
pthread_mutex_t refr;
int visit[10][2];
bool ownerdo = 0;
int nbotle_refr = 10;
void *guestFunc(void* i)
{
int arg = * (int*) i;
while(1)
{
visit[arg][1]=1;
pthread_mutex_lock(&refr);
visit[arg][1]=2;
napms(5000);
if(ownerdo==0)
pthread_mutex_unlock(&r... | 1 |
#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 <= 10; i++) {
pthread_mutex_lock(&the_mutex);
while (buffer != 0)
pthread_cond_wait(&condp, &the_mutex);
buffer = i;
pri... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
};
struct foo* foo_alloc(void)
{
struct foo *fp;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
if (pthread_mutex_init(&fp->f_lock, 0) != 0) {
free(fp);
... | 1 |
#include <pthread.h>
static inline void init_send_buffer(struct send_buffer *s, char *ptr)
{
memset(s, 0, sizeof(struct send_buffer));
s->start_ptr = ptr;
s->end_ptr = ptr;
pthread_mutex_init(&(s->lock), 0);
}
static inline void lock_send_buffer(struct send_buffer *s)
{
pthread_mutex_lock(... | 0 |
#include <pthread.h>
pthread_mutex_t gm;
int node_id;
struct node *next ;
}node_t;
{
int arr[5];
node_t *head;
} llist_t;
struct thread_data {
int tid;
llist_t *local_data;
};
void *t(void *args){
nvcheckpoint();
pthread_exit(0);
}
node_t* new_node(int no... | 1 |
#include <pthread.h>
int *all_buffers;
int num_producers;
int num_consumers;
int num_buffers;
int num_items;
int inpipe;
int outpipe;
int num_consumer_iterations;
pthread_mutex_t should_continue_consuming_lock;
sem_t total_full;
sem_t buffer_lock;
sem_t send_message_lock;
bool shoul... | 0 |
#include <pthread.h>
int somma_voti;
int votanti;
} Film;
struct Film arrayFilm[10];
sem_t barriera;
sem_t evento;
pthread_mutex_t mutex_threads[10];
int completati=0, bestfilm;
float votomedio = 0, bestvoto =0;
void *ThreadCode(void *t) {
long tid;
long result = 1;
int i;
int ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_muzi;
pthread_mutex_t mutex_zeny;
sem_t emptyRoom;
int muziCount;
int zenyCount;
sem_t muzi;
sem_t zeny;
sem_t turnstile;
} Buffer;
int id;
Buffer * buffer;
} WorkerData;
void BufferInit(Buffer * buffer)
{
pthread_mutex_init(&buffer->mutex_m... | 0 |
#include <pthread.h>
pthread_t *Students;
pthread_t TA;
int ChairsCount = 0;
int CurrentIndex = 0;
sem_t TA_Sleep;
sem_t Student_Sem;
sem_t ChairsSem[3];
pthread_mutex_t ChairAccess;
void *TA_Activity();
void *Student_Activity(void *threadID);
int main(int argc, char* argv[])
{
int number... | 1 |
#include <pthread.h>
pthread_t atendentes [3];
pthread_t gclientes;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
int filas_vazias = 3;
int clientes = 9;
int i;
int ncli = 0;
int tem_cliente = 0;
int tamfila[3];
sem_t empty;
sem_t full... | 0 |
#include <pthread.h>
int val;
struct node_t *next;
} node_t;
node_t *head;
node_t *tail;
pthread_mutex_t *head_lock;
pthread_mutex_t *tail_lock;
} queue_t;
queue_t *Q;
int ready = 0;
int done = 0;
pthread_mutex_t ready_lock;
pthread_mutex_t done_lock;
uint32_t que... | 1 |
#include <pthread.h> extern void __VERIFIER_error() ;
void __VERIFIER_assert(int cond) { if (!(cond)) { ERROR: __VERIFIER_error(); } return; }
int myglobal;
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_function_mutex(void *arg)
{
int i,j;
for ( i=0; i<20; i++ )
{... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.