text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
extern void thread_join_int(pthread_t tid, int *rval_pptr);
extern int My_pthread_create(pthread_t *tidp, const pthread_attr_t *attr, void *(*start_rtn)(void *), void *arg);
static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
static pthread_t threads[4];
static... | 1 |
#include <pthread.h>
void *controlTask(void *arg)
{
struct timeval tp;
struct timespec ts;
pthread_mutex_t verrou;
pthread_cond_t cond;
pthread_cond_init(&cond, 0);
pthread_mutex_init(&verrou, 0);
float pitch_cmd = 0.0;
float roll_cmd = 0.0;
float angular_speed_cmd = 0.0;
float ve... | 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 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);... | 0 |
#include <pthread.h>
int size;
int numWorkers;
int stripSize;
int array[2000];
int sum=0;
pthread_mutex_t lock;
void * worker (void * ptr);
double timeval_diff(struct timeval *a, struct timeval *b);
int main(int argc, char* argv[]){
struct timeval t_ini, t_fin;
double secs;
get... | 1 |
#include <pthread.h>
static pthread_cond_t cond;
static pthread_mutex_t mutex;
static pthread_t reader;
static int fd;
static long the_great_array[256];
static unsigned char * buffer;
static int buf_size = -1;
volatile static short reader_in_mutex = 0;
volatile static short main_in_mutex = 0;
v... | 0 |
#include <pthread.h>
struct RawMonitor {
pthread_mutex_t mutex;
pthread_cond_t cv;
};
struct RawMonitor *Create_RawMonitor(){
int err = 0;
struct RawMonitor *monitor = malloc(sizeof(struct RawMonitor));
pthread_condattr_t cv_attr;
pthread_mutexattr_t mx_attr;
err = pt... | 1 |
#include <pthread.h>
char* name;
long balance;
pthread_mutex_t mutex;
} Account;
Account* accounts[4];
Account*
make_account(char* name, long balance)
{
Account* acc = malloc(sizeof(Account));
acc->name = strdup(name);
acc->balance = balance;
pthread_mutex_init(&acc... | 0 |
#include <pthread.h>
void search_by_thread( void* ptr);
{
char* start_ptr;
char* end_ptr;
int slice_id;
} slice_data;
{
char* start_ptr;
char* end_ptr;
int thread_id;
int num_slices;
int slice_size;
char match_str[15];
char* array_address;
slice_data* slice_struct_address;
} thread... | 1 |
#include <pthread.h>
struct queue *create_queue(int size)
{
struct queue *q = (struct queue *) malloc(sizeof(struct queue));
q->tasks = (struct task_desc **) malloc(sizeof(struct task_desc) * size);
q->capacity = size;
q->front = 0;
q->rear = 0;
pthread_mutex_init(&q->lock, 0);
sem_init(&q... | 0 |
#include <pthread.h>
static pthread_mutex_t stdout_lock;
sem_t male_avail;
sem_t female_avail;
pthread_mutex_t mutex;
int mate_pending;
int *male_queue, *female_queue;
int male_position, female_position, male_head, female_head;
static struct timeval time0;
double elapsed_time() {
s... | 1 |
#include <pthread.h>
pthread_t t1, t2, t3;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_t thr1, thr2, thr3;
pthread_attr_t attr1, attr2, attr3;
void * fonction_2(void * unused)
{
int i, j;
fprintf(stderr, " T2 demarre\\n");
fprintf(stderr, " T2 travaille...\\n");
for (i = 0; i < 100000; i ++)
for (j = 0; j < 10000; j ++... | 1 |
#include <pthread.h>
unsigned char jrgba[] = { 1,2,3,255, 4,5,6,255, 7,8,9,255, 10,11,12,255, 13,14,15,255, 16,17,18,255,
19,20,21,255, 22,23,24,255, 25,26,27,255, 28,29,30,255 };
unsigned char jrgb[30];
{
unsigned char *rgba;
int rgba_len;
unsigned char *rgb;
... | 0 |
#include <pthread.h>
pthread_t pong_thread;
pthread_t ping_thread;
struct thread_arg ta;
void start_pong()
{
int err = pthread_create(&pong_thread, 0, pong_main_thread, &ta);
if (err == -1) {
fprintf(stderr, "Could not create pong_main_thread thread.\\n");
exit(1);
}
}
void start_ping... | 1 |
#include <pthread.h>
static pthread_mutex_t deltat_mutex = PTHREAD_MUTEX_INITIALIZER;
int deltat_write(long diff_sec)
{
long cnt, deltat;
int r = 0;
FILE *fp;
pthread_mutex_lock(&deltat_mutex);
fp = fopen("/data/misc/rtc/deltat", "r+b");
if (!fp) {
fp = fopen("/data/misc/rtc/deltat",... | 0 |
#include <pthread.h>
double integral = 0;
pthread_mutex_t mutex;
pthread_t threads[100];
double Function(double x)
{
return sqrt(1-pow(x,2));
}
void* Integrate(void* t)
{
int threadID = (int)t;
pthread_mutex_lock(&mutex);
for(int i = 0; i <= 100/100; i++)
{
double param = i + (100/1... | 1 |
#include <pthread.h>
struct msg {
struct msg *next;
int num;
};
struct msg *head;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p)
{
struct msg *mp;
while (1) {
pthread_mutex_lock(&lock);
... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5];
pthread_t phils[5];
void *philosopher (void *id);
int food_on_table ();
void get_fork (int, int, char *);
void down_forks (int, int);
pthread_mutex_t foodlock;
int sleep_seconds = 0;
int
main (int argn,
char **argv)
{
int i;
if (argn ... | 1 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t rcv;
pthread_cond_t wcv;
int writers;
short writing;
short reading;
} rwinfo_t;
rwinfo_t * rwinfo_init() {
rwinfo_t * rwinfo = malloc(sizeof(rwinfo_t));
pthread_mutex_init(&rwinfo->m, 0);
pthread_cond_init(&rwinfo->rcv, 0);
pthrea... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct info_t{
pthread_t tid;
char *msg;
struct info_t *next;
}*info_list;
void enqueue_info (struct info_t *info){
struct info_t *t;
info->next = info_list;
info_list = info;
}
void clean_func (vo... | 1 |
#include <pthread.h>
int ClientManager(void * acceptsd)
{
if (debug) printf("Hello, I'm the thread %u client manager\\n\\n",(int)pthread_self());
int mysd;
int ret;
char buffer[1000];
memset(buffer,0,sizeof(buffer));
mysd = *((int *)acceptsd);
if (debug) printf("Socket descriptor %d\\... | 0 |
#include <pthread.h>
int nitems;
struct {
pthread_mutex_t mutex;
int buff[1000000];
int nput;
int nval;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
int myMin(int a, int b) {
return a < b ? a : b;
}
void* produce(void *arg) {
for( ; ; ) {
pthread_mutex_lock(&s... | 1 |
#include <pthread.h>
struct connection;
struct locked_connection {
pthread_mutex_t mutex;
struct connection *conn;
};
struct connection_pool {
struct locked_connection lockedconn[40];
int round_robin;
};
struct connection_pool *connection_pool_new (void)
{
int i;
... | 0 |
#include <pthread.h>
int total_time = 0;
pthread_mutex_t global_mutex;
long long factorial(long n) {
long long result = 1;
long i;
for (i = 1; i <= n; ++i)
result *= i;
return result;
}
void *thread_implementation(void *t)
{
int i;
long tid;
long long result =... | 1 |
#include <pthread.h>
int aData[(20 + 1)];
int dwHead;
int dwTail;
}T_QUEUE, *PT_QUEUE;
void InitQue(T_QUEUE *ptQue)
{
memset(ptQue, 0, sizeof(*ptQue));
}
void EnterQue(PT_QUEUE ptQue, int dwElem)
{
if(IsQueFull(ptQue))
{
printf("Elem %d cannot enter Queue %p(F... | 0 |
#include <pthread.h>
pthread_mutex_t db;
pthread_mutex_t mutex;
int rc;
int lr, lw;
void read_db(int lr){
printf("Total de %d leitores lendo agora.\\n",rc);
sleep(lr);
}
void use_db(){
int use;
use = rand() % 20;
printf("Usuário utilizando conhecimento\\n");
sleep(use);
}
voi... | 1 |
#include <pthread.h>
void do_work () {
printf("%s\\n", "working...");
}
int counter = 0;
int thread_flag;
pthread_mutex_t thread_flag_mutex;
void initialize_flag ()
{
pthread_mutex_init (&thread_flag_mutex, 0);
thread_flag = 1;
}
void set_thread_flag (int flag_value)
{
pthread_mutex... | 0 |
#include <pthread.h>
int balance = 1000;
pthread_mutex_t mutex;
struct ex_arguments{
int n;
int * trans;
};
void * execute( void * args){
struct ex_arguments * xargs = (struct ex_arguments *) args;
int i;
for(i=0;i<xargs->n;i++){
pthread_mutex_lock(&mutex);
balance = bala... | 1 |
#include <pthread.h>
char *master;
char *slaves;
volatile int busy;
char *size;
pthread_mutex_t lock;
pthread_cond_t condp;
pthread_cond_t condc;
size_t random;
char *pattern;
char *pattern1;
} target_t;
void
usage()
{
fprintf(stderr, "Usage:\\n");
fprintf(stderr, "./testreplicat... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
char *data;
size_t exec_times;
}Info;
void* fighting(void *ptr){
pthread_mutex_lock(&lock);
char *part = ((Info*) ptr) ->data;
size_t exec_times = ((Info*) ptr) ->exec_times;
pthread_mutex_unlock(&lock);
for(size_t i =0; i< exec_times;i++... | 1 |
#include <pthread.h>
enum thread_status {
RUNING = 0,
EXITING,
};
pthread_t handle;
pthread_mutex_t mutex;
sem_t sem_work;
sem_t *sem_ctrl;
enum thread_status status;
int chn_num;
int chn_id;
int chn_priority;
} handle_args;
void *thread_work(void *args);
... | 0 |
#include <pthread.h>
void *threadfunc(void *arg);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int count, total, toggle;
int main(void)
{
int ret;
pthread_t new;
void *joinval;
int sharedval;
printf("1: condition variable test 5\\n");... | 1 |
#include <pthread.h>
int occupiedChairs = 0;
int taBusy = FALSE;
void *simulate_student_programming(void *studentId) {
int id = *(int *)studentId;
pthread_mutex_lock(&mutex);
int programmingSecs = rand() % SLEEP_MAX_SECS + 1;
pthread_mutex_unlock(&mutex);
printf("\... | 0 |
#include <pthread.h>
static FILE *fp = 0;
static char linestr[AU_LINE_MAX];
static char *delim = ":";
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static struct au_class_ent *get_class_area()
{
struct au_class_ent *c;
c = (struct au_class_ent *) malloc (sizeof(struct au_class... | 1 |
#include <pthread.h>
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
int buf[5];
int widx = 0;
int ridx = 0;
pthread_t threads[1 +1];
void* pro(void* arg)
{
int num = 0;
int i;
while(1){
sem_wait(&full);
pthread_mutex_lock(&mutex);
for(i=0; i<5; i++){
printf("%02d", i);
if(bu... | 0 |
#include <pthread.h>
void *Worker(void *);
void InitializeGrids(double** grid1, double** grid2);
void Barrier();
pthread_mutex_t barrier;
pthread_cond_t go;
int numArrived = 0;
int gridSize, numWorkers, numIters, stripSize;
double maxDiff[16];
double myms()
{
struct timeval ... | 1 |
#include <pthread.h>
int sum = 0;
pthread_mutex_t sum_mutex;
void *calculate( void * arg )
{
printf("thread %d run ...\\n", *( (int *)arg ) );
printf("before calculate in thread %d sum is %d\\n", *( (int *)arg ), sum );
pthread_mutex_lock( &sum_mutex );
sum += *( (int *)arg );
... | 0 |
#include <pthread.h>
pthread_mutex_t pth_mutex, pth_mutex_monitor;
void
vrrp_thread_mutex_lock(void)
{
pthread_mutex_lock(&pth_mutex);
return;
}
void
vrrp_thread_mutex_unlock(void)
{
pthread_mutex_unlock(&pth_mutex);
return;
}
void vrrp_thread_mutex_lock_monitor(void)
{
pthread_mutex_loc... | 1 |
#include <pthread.h>
int mediafirefs_mkdir(const char *path, mode_t mode)
{
printf("FUNCTION: mkdir. path: %s\\n", path);
(void)mode;
char *dirname;
int retval;
char *basename;
const char *key;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_c... | 0 |
#include <pthread.h>
int thread_count;
double sum = 0;
int n = 1000000;
pthread_mutex_t mutex;
int flag = 0;
void* thread_sum(void* rank){
long my_rank = (long) rank;
int start = n / thread_count * my_rank;
int end = n / thread_count * (my_rank + 1);
double factor = 1;
if (start... | 1 |
#include <pthread.h>
char buf[200] = {0};
pthread_mutex_t mutex;
unsigned int flag = 0;
void *func(void *arg)
{
sleep(1);
while (flag == 0)
{
pthread_mutex_lock(&mutex);
printf("本次输入了%d个字符\\n", strlen(buf));
memset(buf, 0, sizeof(buf));
pthread_mutex_unlock(&mutex);
sleep(1)... | 0 |
#include <pthread.h>
int stoj = 0;
int minute_vedra = 0;
int cakajuci_na_prestavku = 0;
int brana = 0;
pthread_mutex_t mutex_minute_vedra = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_pocet_cakajucich = PTHREAD_MUTEX_INITIALIZER;
sem_t sem_cakajuci_na_prestavku;
sem_t sem_iduci_na_prestavku;
... | 1 |
#include <pthread.h>
void *bandCal(void *pa)
{
int i,check,flag;
long long int *temp;
float *tempNorm;
int samp;
int nacc;
int bacc;
int bandTVal;
int nchans;
samp=0;
nchans = adc.nfft/2;
nacc = adc.nacc;
bacc = adc.bacc;
temp = (long long int *) malloc(... | 0 |
#include <pthread.h>
pthread_t thread_1;
pthread_t thread_2;
int counter;
pthread_mutex_t lock;
void* thread_function(void *arg)
{
pthread_mutex_lock(&lock);
counter += 1;
printf("\\nJob %d started\\n", counter);
sleep (2);
printf("\\nJob %d finished\\n", counter);
pthread_mu... | 1 |
#include <pthread.h>
int threads_glob;
pthread_mutex_t printer = PTHREAD_MUTEX_INITIALIZER;
int parent, subrank;
} somearg_t;
void *subsome(void *argument)
{
somearg_t *ranks = (somearg_t*)argument;
printf("Subthread %d of %d now responding\\n",ranks->subrank,ranks->parent);
pt... | 0 |
#include <pthread.h>
int q[2];
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 < 2)
... | 1 |
#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;
... | 0 |
#include <pthread.h>
int cine[7][20];
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t kuz = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t consume_t = PTHREAD_COND_INITIALIZER;
pthread_cond_t sits = PTHREAD_COND_INITIALIZER;
pthread_cond_t produce_t = PTHREAD_COND_INITIALIZER;
void c... | 1 |
#include <pthread.h>
pthread_mutex_t locki[32];
int inode[32];
pthread_mutex_t lockb[26];
int busy[26];
pthread_t tids[4];
void * thread_routine1()
{
int b1;
int tid1 = 1;
int i1 = tid1 % 32;
pthread_mutex_lock(&locki[i1]);
if(inode[i1] == 0) {
b1 = (i1*2)%26;
while(1) {
... | 0 |
#include <pthread.h>
int stmp = 3;
void *refresher_child_common(void *param){
while(1) {
pthread_mysleep(60 * 3);
}
}
void refresher_init(){
pthread_t refresher_common
;
pthread_create(&refresher_common, 0, refresher_child_common, 0);
}
void getTime(char *timing){
t... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *readCANData(void *canData) {
char *mqttMessage;
struct can_frame *frame = (struct can_frame *) canData;
printf("Received data from CAN bus: %s\\n", frame->data);
int size = asprintf(&mqttMessage, "ID: %d, Data:... | 0 |
#include <pthread.h>
int send_pkt( void *args) {
struct ether_hdr *eth_header;
struct ipv4_hdr *ipv4_header;
struct udp_hdr *udp_header;
unsigned char *payload_ptr;
unsigned long int sentTime, seqNo = 1;
int ret, index = 0;
double prio;
printf("STARTING SENDER\\n");
while(S... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int needs_init = 1;
void set_options()
{
convert_characters = 1;
shrink_lines = 1;
remove_empty_alt = 1;
option_no_image = 1;
option_no_alt = 1;
convert_tags = 0;
option_links = 0;
option_links_inline = 0;
option_title = 0;
set_iconv_char... | 0 |
#include <pthread.h>
const int page_size = 4096;
int64_t nr_block = 4096 * 10000;
int64_t nr_total_pages = 4096 * 10000 * 8;
static pthread_mutex_t *comp_done_lock;
static pthread_cond_t *comp_done_cond;
struct CompressParam {
int start;
int done;
pthread_mutex_t mutex;
pth... | 1 |
#include <pthread.h>
int total = 0;
pthread_mutex_t mutex;
void *count_txt(void *t){
long thread_id = (long)t;
char c;
printf("Here is %lu\\n", pthread_self());
while((c=fgetc(t))!=EOF)
{
pthread_mutex_lock(&mutex);
total++;
pthread_mutex_unlock(&mutex);
}
pthread_exit(0);
}
i... | 0 |
#include <pthread.h>
int mediafirefs_access(const char *path, int mode)
{
printf("FUNCTION: access. path: %s\\n", path);
(void)path;
(void)mode;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pthread_mutex_lock(&(ctx->mutex));
fprin... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
void *hold(void *arg) {
pthread_mutex_lock(&lock);
usleep(10000);
pthread_mutex_unlock(&lock);
return arg;
}
void *wait(void *arg) {
pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);
return arg;
}
int main() {
... | 0 |
#include <pthread.h>
int nextCustomerNo = 1;
int first = 0, last = 0;
int waitingCustomerCount = 0;
pthread_mutex_t lck;
pthread_cond_t custCond[4];
int custNos[4];
pthread_cond_t brbrCond;
void WakeUpBarber()
{
pthread_cond_signal(&brbrCond);
}
void CustomerWait(int chair)
{
pthread_c... | 1 |
#include <pthread.h>
pthread_mutex_t number_mutex1;
pthread_mutex_t number_mutex2;
int globalnumber1 = 10;
void thread2(void *arg);
void thread1(void *arg);
int main(void)
{
int status;
pthread_t thid1,thid2;
pthread_mutex_init(& number_mutex1,PTHREAD_MUTEX_TIMED_NP);
pthread_mutex... | 0 |
#include <pthread.h>
long long counter_max;
long long counter = 0;
pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER;
double *sum_res;
void printout_the_result(double pi);
void *pi_thread(void *arg) {
double sum;
long long i, beg, end, unit;
while (1) {
pthread_mutex_lock(&c... | 1 |
#include <pthread.h>
struct data{
int threadID;
pthread_cond_t cond;
};
pthread_t threads[4];
unsigned long queue_pos = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t sem;
sem_t queue[4 + 1];
int q_size = 0;
int q_front = 0;
void _queue_push(sem_t *sem)
{
q_size++;
}
voi... | 0 |
#include <pthread.h>
int rc=0,wc=0,val;
pthread_mutex_t mutex1,mwrite,mread,rallow;
pthread_t tr1,tr2,tw1,tw2;
pthread_attr_t tr1attr,tr2attr,tw1attr,tw2attr;
void *writer();
void *reader();
int main() {
pthread_mutex_init(&mwrite,0);
pthread_mutex_init(&mread,0);
pthrea... | 1 |
#include <pthread.h>
pthread_mutex_t lock_data_init;
int data_init()
{
pthread_mutex_lock(&lock_data_init);
if (g_data_info.count == 0) {
sem_init(&g_data_info.sem, 0, 0);
g_data_info.wqueue = wqueueCreate( DATA_WQUEUE_SIZE);
}
g_data_info.count++;
pthread_mutex_unlock(&lock_data_init)... | 0 |
#include <pthread.h>
void
thread_list_join_destroy(struct thread_list *list)
{
struct thread_list_node *current = list->head;
while (current) {
pthread_join(current->thread, 0);
free(current->arg);
current->arg = 0;
current->thread = 0;
current = current->next;
}
current = list->he... | 1 |
#include <pthread.h>
char* my_name;
char* test_name;
int num_threads;
long long length;
int test_argc;
void** test_argv;
} parsed_args_t;
int (*setup)(int, long long, int, void**);
int (*execute)(int, int, long long, int, void**);
int (*cleanup)(int, long long)... | 0 |
#include <pthread.h>
int main(int argc, char* argv[]){
char comando[80];
pthread_mutexattr_t mattr;
pthread_mutex_init(&mutex_config, &mattr);
pthread_mutex_init(&mutex_tlb, &mattr);
pthread_mutex_init(&mutex_cpu, &mattr);
pthread_mutex_init(&mutex_swap, &mattr);
pthread_mutex_init(&mute... | 1 |
#include <pthread.h>
pthread_mutex_t mx, my;
int x=2, y=2;
void *thread1() {
int a;
pthread_mutex_lock(&mx);
a = x;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
pthread_mutex_unlock(&my);
a = a + 1;
pthread_mutex_lock(&my);
y = y + a;
y = y + a;
y... | 0 |
#include <pthread.h>
struct donut_ring shared_ring;
pthread_mutex_t prod [NUMFLAVORS];
pthread_mutex_t cons [NUMFLAVORS];
pthread_cond_t prod_cond [NUMFLAVORS];
pthread_cond_t cons_cond [NUMFLAVORS];
pthread_t thread_id [NUMPRODUCERS+NUMCONSUMERS], sig_wait_id;
ushort get_time_microseconds()
{
... | 1 |
#include <pthread.h>
int Math_Pow(int base, int exp);
int first_time_init = 1;
void* space_ptr;
int header_size;
int mem_available;
pthread_mutex_t mutex;
int Mem_Init(int sizeOfRegion){
pthread_mutex_init(&mutex, 0);
if(first_time_init == 0){
fprintf(stderr,"Error:mem.c: Init mroe than once\... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condvar;
int shared = 0;
void *consumer_fun(void *);
void *producer_fun(void *);
int main(void){
pthread_t consumer;
pthread_t producer;
pthread_mutex_init(&mutex, 0);
pthread_cond_init(&condvar, 0);
pthread_create... | 1 |
#include <pthread.h>
double counter=0;
double counterSup100 = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
double serialFunc(){
counter++;
return counter;
}
void *multiplyMatCst(void *arg){
int i,j;
double *M;
M = (double *) arg;
for (i=0;i<5000;i++){
for (j=0;j<500... | 0 |
#include <pthread.h>
struct mythread_t {
pthread_t id;
int index;
int M, N, Q;
int P;
float **a, **b, **c;
};
pthread_mutex_t mutex;
void read_matrix(char* fname, float*** a, float** sa, int* m, int* n)
{
FILE* finptr;
int i, sz;
finptr = fopen(fname, "r");
if(!finptr) {
... | 1 |
#include <pthread.h>
struct msg {
struct msg *next;
int num;
};
struct msg *head;
struct msg *mp;
pthread_cond_t has_product = PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p)
{
for (;;) {
pthread_mutex_lock(&lock);
... | 0 |
#include <pthread.h>
int
bx_wd_show(struct bx_wd *bx_wdp) {
fprintf(stderr,"Worker Thread Data Structure: bx_wdp=%p, next=%p, prev=%p, flags=0x%016x\\n", bx_wdp, bx_wdp->bx_wd_next, bx_wdp->bx_wd_prev, bx_wdp->bx_wd_flags);
fprintf(stderr,"Worker Thread Data Structure: bx_wdp=%p, my_worker_t... | 1 |
#include <pthread.h>
int n=0;
pthread_mutex_t mylock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t qready=PTHREAD_COND_INITIALIZER;
void * thread_func(void *arg)
{
int param=(int)arg;
char c='A'+param;
int ret,i=0;
for (; i < 10; i++)
{
pthread_mutex_lock(&mylock);
... | 0 |
#include <pthread.h>
int sum_of_number = 0;
sem_t write_res_number;
sem_t read_res_number;
struct recycle_buffer {
int buffer[4];
int head, tail;
}re_buf;
pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *producer(void *arg){
int i;
for(i=0; i<=8; i++... | 1 |
#include <pthread.h>
state situation[MAXTH];
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition[MAXTH];
int philosopherCount;
void test(int i)
{
if(situation[(i + 1) % philosopherCount]!=EATING && situation[(i +philosopherCount - 1 ) % philosopherCount]!=EATIN... | 0 |
#include <pthread.h>
int GlobalCounter = 0, NewNumber = 0;;
pthread_mutex_t mutexsum;
void *Func1(void *threadid)
{
int taskId;
taskId = (int)threadid;
pthread_mutex_lock (&mutexsum);
printf("\\n\\nThread 1: Enter New Number To be added the Counter (0: Terminate the process)\\n");
scanf("%... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void * child1(void *arg)
{
pthread_cleanup_push(pthread_mutex_unlock,&mutex);
while(1){
printf("thread 1 get running \\n");
printf("thread 1 pthread_mutex_lock returns %d\\n",
pthread_mutex_lock(&mutex));
pthread... | 0 |
#include <pthread.h>
void * th_f(void *arg);
char * read_line(int fd);
char * process_line(char *src);
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
int main(int argc, char *argv[])
{
pthread_t ntid;
int status;
int fd;
fd = open (argv[1] , O_RDONLY);
if ( 0 > fd )
{
perror("... | 1 |
#include <pthread.h>
pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER;
char log_path[4096];
char log_filename[4096 + 255];
int log_has_configed = 0;
int log_fd;
void closelog()
{
fsync(log_fd);
close(log_fd);
}
void rename_logfile(const char *fname)
{
time_t now = time(0);
struc... | 0 |
#include <pthread.h>
extern int make_detach_thread(void *(*fn)(void *), void *arg);
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... | 1 |
#include <pthread.h>
static pthread_mutex_t fff0r_mutex = PTHREAD_MUTEX_INITIALIZER;
void fff0r_lock(void)
{
pthread_mutex_lock(&fff0r_mutex);
}
void fff0r_unlock(void)
{
pthread_mutex_unlock(&fff0r_mutex);
}
| 0 |
#include <pthread.h>
int i, numfull, produce, consume, numbuf, numtrd;
int *buffer;
pthread_cond_t empty;
pthread_cond_t fill;
pthread_mutex_t mutex;
pthread_t *t;
void* consumer();
void server_init(int argc, char* argv[]) {
if (argc != 4) {
fprintf(stderr, "Usage: %s server"
" [portnu... | 1 |
#include <pthread.h>
struct list_elem* next;
char* data;
}list_elem;
struct list_elem* first;
int size;
}head_list_elem;
pthread_mutex_t global_mutex;
head_list_elem* cont_allocate(){
head_list_elem* head = 0;
head = (head_list_elem*)malloc( sizeof (head_list_elem));
assert ( h... | 0 |
#include <pthread.h>
extern int done_creating_requests;
static void
cleanup_free_mutex(void* a_mutex)
{
pthread_mutex_t* p_mutex = (pthread_mutex_t*)a_mutex;
if (p_mutex)
pthread_mutex_unlock(p_mutex);
}
static void
handle_request(struct request* a_request, int thread_id)
{
... | 1 |
#include <pthread.h>
sem_t suma_total;
int total = 0;
int vect1[100000000];
int vect2[100000000];
pthread_mutex_t lock;
struct parametros_hilo {
int min;
int max;
int suma_temp;
};
void prodVect(void* parametros) {
struct parametros_hilo* params = (struct parametros_hilo*) para... | 0 |
#include <pthread.h>
const unsigned int NUM_PRINTS = 5;
const unsigned int NUM_THREADS = 8;
static char BufferA[65536];
static int CountA[128];
int EndofBuffer = 0;
pthread_mutex_t lock;
pthread_mutex_t lock2;
void cleanBuffer(int *buf) {
int i;
for (i = 0; i < 128; i++) {
buf[i]... | 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_t... | 0 |
#include <pthread.h>
const int MAX_KEY = 100000000;
struct list_node_s
{
int data;
struct list_node_s* next;
};
struct list_node_s* head = 0;
int num_hilos;
int total_ops;
double porcentaje_insertar;
double porcentaje_busqueda;
double porcentaje_borrado;
pthread_rwlock_t rwlock;
pthread_m... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *thread_1(void *arg)
{
pthread_mutex_lock(&mutex);
DPRINTF(stdout,"Thread 1 locked the mutex\\n");
pthread_exit(0);
return 0;
}
void *thread_2(void *arg)
{
int rc = 0;
pthread_t self = pthread_self();
int policy = SCHED_FIFO;
struct sche... | 0 |
#include <pthread.h>
int error;
static pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void * thr_fn1(void * arg) {
struct timespec tout;
struct tm *tmp;
char buf[64];
clock_gettime(CLOCK_REALTIME, &tout); tmp = localti... | 1 |
#include <pthread.h>
int busCounter = 0;
pthread_mutex_t busCounterLock = PTHREAD_MUTEX_INITIALIZER;
int lightDir = 0;
pthread_mutex_t lightDirLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t lightDirNorth = PTHREAD_COND_INITIALIZER;
pthread_cond_t lightDirSouth = PTHREAD_COND_INITIALIZER;
int... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int contador=0;
void *funcionConflictiva(void *argumentos){
pthread_mutex_lock(&mutex);
contador++;
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
int main(int argc,char *argv[]){
int i;
int cantidadHebras ... | 1 |
#include <pthread.h>
int total_size = 0;
pthread_mutex_t memory_mutex = PTHREAD_MUTEX_INITIALIZER;
void *first = 0;
void *last = 0;
void free_mem(void* to_delete)
{
unsigned long *addr;
unsigned long *temp;
pthread_mutex_lock(&memory_mutex);
temp = addr = (unsigned long *)last;
... | 0 |
#include <pthread.h>
pthread_t threads[100];
int seats = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t customers;
sem_t barber;
void *barberBob(void *threadid){
int haircuts = 100 -1;
while(haircuts > 0){
sem_wait(&customers);
pthread_mutex_lock(&mutex);
seat... | 1 |
#include <pthread.h>
void thread_function();
pthread_mutex_t mutex1 = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP;
volatile long long counter = 0;
volatile int flag = 0;
long think_spin, lock_spin;
int main(int argc, char *argv[])
{
pthread_t thread_id[2000];
int i, n;
struct timeval... | 0 |
#include <pthread.h>
int n, goY = 0, goZ = 0;
pthread_cond_t fimX = PTHREAD_COND_INITIALIZER, fimZ = PTHREAD_COND_INITIALIZER;
pthread_mutex_t the_mutex = PTHREAD_MUTEX_INITIALIZER;
void X(void *argp){
pthread_mutex_lock(&the_mutex);
n = n * 16;
printf("X : %i\\n", n);
pthread_cond_signal(... | 1 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
};
struct foo * foo_alloc(void);
void foo_add(struct foo *fp);
void foo_release(struct foo *fp);
void *thread_func1(void *arg);
void *thread_func2(void *arg);
int
main() {
pthread_t pid1, pid2;
int err;
void *pret;
str... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.