text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
static void * thread_fn(void * args){
printf("this a thread function\\n");
return;
}
int makethread(void *(*fn)(void *),void *arg){
printf("makethread runed\\n");
int err;
pthread_t tid;
pthread_attr_t attr;
err = pthread_attr_init(&attr);
if (... | 1 |
#include <pthread.h>
char g_data[128];
pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutx = PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *arg)
{
while (1) {
pthread_mutex_lock(&mutx);
while (strlen(g_data) == 0)
pthread_cond_wait(&cv, &mutx);
printf("%s\\n", g_data... | 0 |
#include <pthread.h>
float h = 0.01;
static const float h_stride = 0.01;
float x = 0.00;
float total_area = 0.00;
int thread_count;
int threads_batched = 0;
unsigned int usecs = 100;
int threads_done = 0;
pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t area_mutex = ... | 1 |
#include <pthread.h>
int data;
pthread_mutex_t A;
pthread_mutex_t B;
pthread_mutex_t C;
void * thread_routine_1(void * arg)
{
int tmp;
pthread_mutex_lock(&A);
printf("thread 1 : lock (A)\\n");
data = tmp+1;
pthread_mutex_unlock(&A);
printf("thread 1 : unlock (A)\\n");
return 0;... | 0 |
#include <pthread.h>
{
int id;
int noproc;
int dim;
} parm;
{
int cur_count;
pthread_mutex_t barrier_mutex;
pthread_cond_t barrier_cond;
} barrier_t;
barrier_t barrier1;
double *finals;
int rootn;
void
barrier_init (barrier_t * mybarrier)
{
pthread_mutexattr_t attr;
pth... | 1 |
#include <pthread.h>
enum { MAX_THREADS = 3 };
enum { MAX_CYCLES = 5 };
static pthread_mutex_t mtx_waiting = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cnd_waiting = PTHREAD_COND_INITIALIZER;
static int num_waiting = 0;
static int cycle = -1;
static float gl_rand = 0;
static long gl_long =... | 0 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int queue[50];
int current = 0;
void* readQueue(void* arg){
printf("THREADNUMBER is %d",(unsigned int)pthread_self());
pthread_mutex_lock(&mutex);
i... | 1 |
#include <pthread.h>
int ready;
int x, y, m, p, q;
pthread_mutex_t l1, l2, l3;
void *t0(void *args){
printf("t0\\n");
fflush(stdout);
int t = 0;
pthread_mutex_lock(&l1);
printf("t0 locked l1\\n");
t = ready;
printf("t0 unlocked l1\\n");
pthread_mutex_unlock... | 0 |
#include <pthread.h>
static pthread_t* threadID;
static int activeThreadCount;
static pthread_mutex_t bufferLock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t conditionLock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t exitLock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t ... | 1 |
#include <pthread.h>
int buffer=0;
pthread_mutex_t mutex;
void delay(int secs) {
time_t beg = time(0), end = beg + secs;
do {
;
} while (time(0) < end);
}
void *produtor(){
int i=0,controle=0;
while(controle<10){
pthread_mutex_lock(&mutex);
if(buffer){
prin... | 0 |
#include <pthread.h>
void fac_constructor(struct facility_t *fac)
{
fac->name = 0;
fac->busy = 0;
fac->queue = 0;
fac->idx = (ssize_t) - 1;
fac->stats = xcalloc(1, sizeof(struct stat_t));
if (pthread_mutex_init(&fac->flock, 0)
|| pthread_cond_init(&fac->fcond, 0))
err(1, _("pthread ... | 1 |
#include <pthread.h>
static int count=0;
static pthread_mutex_t mut_count = PTHREAD_MUTEX_INITIALIZER;
static void *thr_prime(void *ptr)
{
int mark;
int i, j;
i=*(int*)ptr;
mark=1;
for (j=2;j<i/2;++j) {
if (i%j==0) {
mark=0;
break;
}
}
if (mark==1) {
pthread_mutex_lock(&... | 0 |
#include <pthread.h>
void *rrand(void *);
pthread_mutex_t varout, out, mutexsum;
double iterationLimit;
int numThreads = 0;
double totaloutside = 0, total =0;
const double PI = 3.14159265359;
unsigned seed = 300;
int main(void){
printf("Enter number of iterations: \\n");
scanf("%lf... | 1 |
#include <pthread.h>
double widthbase;
int rectxworker;
struct ij {
double low;
double high;
};
pthread_mutex_t mutex;
double total = 0;
double total2= 0;
void* suma_para(void *_data) {
struct ij *data = (struct ij *)_data;
double i=0;
double resultado = 0;
for (i=data->low; i<data->hig... | 0 |
#include <pthread.h>
int progress_enabled = 0;
int rotate = 0;
int cur_uncompressed = 0, estimated_uncompressed = 0;
int columns;
pthread_t progress_thread;
pthread_mutex_t progress_mutex = PTHREAD_MUTEX_INITIALIZER;
static void sigwinch_handler()
{
struct winsize winsize;
if(ioctl(1, TIOCG... | 1 |
#include <pthread.h>
pthread_cond_t cond;
pthread_mutex_t mutex;
sem_t sem_elfos;
volatile int count_elfos;
volatile int count_renas;
volatile int lock;
volatile int acordado;
void logP(){
int i;
if(!lock){
lock = 1;
system("clear");
printf(" [Ajudando Elfos]\\n");
i... | 0 |
#include <pthread.h>
int _debug = -77;
void debug(char *fmt, ...)
{
if(_debug == -77) {
char *buf = getenv("EZTRACE_DEBUG");
if(buf == 0) _debug = 0;
else _debug = atoi(buf);
}
if(_debug >= 0) {
va_list va;
__builtin_va_start((va));
vfprintf(stdout, fmt, va);
;
}
}
... | 1 |
#include <pthread.h>
int
TcAddKeybuf (char c)
{
int RetVal = 1, i;
pthread_mutex_lock (&TcMutex);
if (TcKeybufSize < TC_KEYBUF_SIZE)
{
RetVal = 0;
i = TcKeybufStart + TcKeybufSize;
if (i >= TC_KEYBUF_SIZE)
i -= TC_KEYBUF_SIZE;
TcKeybuf[i] = c;
TcKeybufS... | 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(void)
{
pthread_t consumer_t;
pthread_t producter_t;
pthread_mutex_init(&mutex, 0);
pthread_create(&producter_t, 0, (void ... | 1 |
#include <pthread.h>
double timeval_diff(struct timeval *a, struct timeval *b)
{
return
(double)(a->tv_sec + (double)a->tv_usec/1000000) -
(double)(b->tv_sec + (double)b->tv_usec/1000000);
}
struct list_node_s
{
int data;
struct list_node_s* next;
pthread_mutex_t mutex;
};
int thread... | 0 |
#include <pthread.h>
struct fio_data {
size_t size;
};
static inline void get_mdelay_abstime(struct timespec *abstime, unsigned long ms)
{
struct timeval delta;
gettimeofday(&delta, 0);
abstime->tv_sec = delta.tv_sec + (ms/1000);
abstime->tv_nsec = (delta.tv_usec + (ms%1000) * 100... | 1 |
#include <pthread.h>
volatile int val;
pthread_mutex_t me;
} protected_int_t;
void protected_int_init(protected_int_t *, int);
protected_int_t a_done, b_done, a_cat, b_cat;
volatile int n_merge;
int n;
int *a_array, *b_array;
void *ta_work(void *arg);
void *tb_work(void *arg);
int main... | 0 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_write = PTHREAD_COND_INITIALIZER;
int common_value = 0;
int readers = 0;
void *readerFunc(void *param);
void *writerFunc(void *param);
int main(int argc, char **argv) {
pthread_t treaders[5], twriters[5];... | 1 |
#include <pthread.h>
static pthread_cond_t runtime_init_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t runtime_init_mu = PTHREAD_MUTEX_INITIALIZER;
static int runtime_init_done;
static void (*cgo_context_function)(struct context_arg*);
void
x_cgo_sys_thread_create(void* (*func)(... | 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 < 5; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count < 7) {
... | 1 |
#include <pthread.h>
pthread_t tid;
struct job {
pthread_t tid;
Job next;
int val;
};
pthread_mutex_t q_lock = PTHREAD_MUTEX_INITIALIZER;
int insert(Job head, int val, pthread_t tid)
{
Job p, q;
p = head;
if (p != 0) {
while (p->next != 0) {
p = p->nex... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
int shared_data;
void mutex_cleanup(void *m)
{
pthread_mutex_t *p = (pthread_mutex_t *)m;
printf(" Inside cancellation handler. Cleaning up elegantly...\\n");
pthread_mutex_unlock(p);
}
void *thread_function(void *arg)
{
int old_state;
int ol... | 1 |
#include <pthread.h>
static FILE *logg_file_ptr = 0;
static pthread_mutex_t *logg_mutex = 0;
static struct tm t;
static struct timeval tval;
enum LoggLevelEnum logg_level;
int logg_construct() {
logg_file_ptr = stderr;
logg_level = get_logg_level();
if (mutex_init() != 0) {
... | 0 |
#include <pthread.h>
void receive_external_request()
{
struct event_queue_node eq_node;
pthread_mutex_lock(&ftl_to_nand->mutex);
while (ftl_to_nand->num_of_entries != 0)
{
eq_node = if_dequeue(ftl_to_nand);
QueryPerformanceCounter(&eq_node.time);
if (eq_node.time_offset >= 0)
... | 1 |
#include <pthread.h>
int iterationsNumber = 10000;
int counter = 0;
void * thread_func1()
{
int i;
int counter1 = 0;
for (i = 0; counter < iterationsNumber; i++) {
pthread_mutex_lock( &mutex1 );
counter++;
pthread_mutex_unlock( &mutex1 );
counter1 ++;
... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
len = dotstr.v... | 1 |
#include <pthread.h>
int lock_var = 0;
time_t end_time;
pthread_mutex_t mutex;
void *thread_routine1(void *arg)
{
int i;
printf("I'am the sub thread1\\n");
while(time(0) < end_time) {
pthread_mutex_lock(&mutex);
for(i=0; i<3; i++) {
lock_var++;
sleep(1);
printf("product: loc... | 0 |
#include <pthread.h>
pthread_mutex_t db_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t op_lock = PTHREAD_MUTEX_INITIALIZER;
int seats=20;
int active_op;
pthread_t op[3];
void *confirm_booking();
void *inizializza();
void *operatore();
void *wait_client();
int check_availability();
int ask... | 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;
tsp->tv_nsec = tv.tv... | 0 |
#include <pthread.h>
void* producer1(void* pid) {
int z_var = 0x60;
int PID = *(int*) pid;
printf("Producer 1 (%d): starte prod 1\\n", PID);
while(1) {
pthread_mutex_lock(&prod1_mutex);
while(!is_running_prod1) {
pthread_cond_wait(&cond_prod1, &prod1_mutex);
pthread... | 1 |
#include <pthread.h>
int filas_vazias = 3;
int totcli;
int i, t;
int ncli = 0;
int tem_cliente = 0;
int tamfila[3];
int fila_espera = 0;
int clientes = 10;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
sem_t empty;
sem_t full;
void... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cvar[2] = {PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER};
int current_cars;
int waiting_cars[2];
int wait_timestamp;
int current_direction;
char *indent = "===============";
int i;
int direction;
} Ca... | 1 |
#include <pthread.h>
int finish = 0, mutex_enable = 1, error_enable = 0;
char *cadeia[10] = {"aaaaaaaaa\\n","bbbbbbbbb\\n","ccccccccc\\n","ddddddddd\\n","eeeeeeeee\\n",
"fffffffff\\n","ggggggggg\\n","hhhhhhhhh\\n","iiiiiiiii\\n","jjjjjjjjj\\n"};
pthread_mutex_t vec_mutex[N_FILES];
void u... | 0 |
#include <pthread.h>
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t null_pls = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
void *function3();
int count = 0;
int COUNT_DONE = 0;
cha... | 1 |
#include <pthread.h>
int num_printers, num_clients, buffer_size;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int *buffer;
int printer_index = 0;
int client_index = 0;
int buffer_coun... | 0 |
#include <pthread.h>
pthread_t thread1, thread2;
static pthread_mutex_t verrou1, verrou2;
int var1, var2, var3;
void *lire(void *nom_du_thread)
{
pthread_mutex_lock(&verrou1);
printf("lire variable 1 = %d\\n",var1);
printf("lire variable 2 = %d\\n",var2);
printf("lire variable 3 = %d\\n",var3... | 1 |
#include <pthread.h>
sem_t maachSem;
sem_t dalSem;
sem_t bhaatSem;
struct my_arg{
int id;
int slTime;
char *p;
};
struct my_arg argThrd[3];
struct timeval start, stop;
pthread_mutex_t mutex;
pthread_t service[3];
pthread_attr_t attr[3];
static int count = 1;
int breaker;
void enterLog... | 0 |
#include <pthread.h>
static pthread_mutex_t gTempdirLock = PTHREAD_MUTEX_INITIALIZER;
static int gTempdirNonce = 0;
int recursiveDeleteContents(const char *path)
{
int ret;
DIR *dp;
struct dirent *de;
char tmp[PATH_MAX];
dp = opendir(path);
if (!dp) {
ret = -errno;
fprintf(... | 1 |
#include <pthread.h>
pthread_t log_thr;
pthread_mutex_t logq_lock;
pthread_mutex_t logev_lock;
pthread_cond_t logev_cond;
int logq_running;
static void
sigusr1 (int sig)
{
pthread_mutex_lock(&logq_lock);
log_reset("multipathd");
pthread_mutex_unlock(&logq_lock);
}
void log_safe (int pr... | 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->notfull, 0)... | 1 |
#include <pthread.h>
static struct axis mag_min, mag_max, tilt;
pthread_mutex_t tilt_axis_mutex;
pthread_t head_thread_id;
static bool head_track;
void *head_thread(void *args)
{
struct axis accel, gyro, mag;
head_track = 1;
unsigned char st1;
mag_max.x = 289;
mag_min.x = -143;
mag_max.y =... | 0 |
#include <pthread.h>
int debug = 0;
struct sw {
int s;
char *name;
int sleep;
};
static void *
server_worker(void *v)
{
struct sw *sw = v;
int nreq = 0;
while (1) {
char *rbuf;
char *buf = 0;
int bytes;
if ((bytes = nn_recv(sw->s, &buf, NN_MSG, 0)) < 0)
err(1, "nn_recv");
... | 1 |
#include <pthread.h>
long long MAX_LOOP;
long long counter=0;
long long trials_per_thread;
pthread_mutex_t lock;
void *Calculate_pi(void *threadid)
{
long tid;
tid = (long)threadid;
double x,y;
int i;
srand(time(0));
for(i=0;i<trials_per_thread;i++)
{
x= ((double)rand... | 0 |
#include <pthread.h>
static struct _BSM *BasicSaftyMsg=0;
extern int SendNetLinkData(int sockfd,int length,int pid, unsigned char *buffer);
static void PutWSMReqHeader(struct _WSM_MsgReq *wsmReqMsg, char *buf)
{
int i;
unsigned int lval;
char *pval;
pval = get_conf_value("WSMP_VERSION", bu... | 1 |
#include <pthread.h>
int ShareMemory[101];
int iwriteposition = 0,ireadposition = 0;
int ibuffersize = 10;
pthread_mutex_t pthreadmutex_lock;
pthread_cond_t pthread_cond_empty;
pthread_cond_t pthread_cond_full;
void *sender(void)
{
int icount;
for (icount = 0; icount < 100; icount++)... | 0 |
#include <pthread.h>
void *print_number(void *args);
int num = 0;
pthread_mutex_t mutex;
int main(void)
{
pthread_t thread;
pthread_mutex_init(&mutex, 0);
pthread_create(&thread, 0, print_number, 0);
while(num < 100) {
pthread_mutex_lock(&mutex);
num++;
pthread_mutex_unlock... | 1 |
#include <pthread.h>
struct buffer
{
int array[10];
unsigned int top;
pthread_mutex_t m;
}stack;
pthread_cond_t stack_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t stack_empty = PTHREAD_COND_INITIALIZER;
void *puta(void*arg)
{
srand(1092);
int value =0;
while (1)
{
pthread_mutex_lo... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_for_saveToPath = PTHREAD_MUTEX_INITIALIZER;
int hxfmsg(struct htx_data *p, int err, enum sev_code sev, char *text)
{
char saveToPath[128];
FILE *fp;
if(p == 0){
printf("%s",text);
if(sev< HTX_SYS_... | 1 |
#include <pthread.h>
void *producer (void *args);
void *consumer (void *args);
int buf[10];
long head, tail;
int full, empty;
pthread_mutex_t *mut;
pthread_cond_t *notFull, *notEmpty;
} queue;
queue *queueInit (void);
void queueDelete (queue *q);
void queueAdd (queue *q, int in);
void qu... | 0 |
#include <pthread.h>
struct pids * pidmanager = 0;
pthread_mutex_t alloc_mutex;
int allocate_map(void){
int i;
if(pidmanager!=0)
return 1;
pthread_mutex_init(&alloc_mutex,0);
pidmanager = (struct pids *)malloc(sizeof(struct pids));
if(pidmanager){
pidmanager->last_pid = M... | 1 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
};
struct foo *fool_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);
return (0);
}
}
r... | 0 |
#include <pthread.h>
void *thread_cb(void *);
pthread_t* threads;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double* x;
double* y;
double tmp = 0;
double averageX = 0;
double averageY = 0;
double betaTmp = 0;
double beta1 = 0;
double beta0 = 0;
int lineNum = 0;
double sumOfX = 0... | 1 |
#include <pthread.h>
pthread_cond_t is_zero;
pthread_mutex_t mutex;
int shared_data = 5;
void *thread_function (void *arg)
{
pthread_mutex_lock(&mutex) ;
while ( shared_data > 0)
{
--shared_data ;
printf("Thread - Decreasing shared_data... Value:%d\\n",shared_data);
... | 0 |
#include <pthread.h>
int fpthread_listen_init(struct static_val *s_val){
s_val->epoll_fd = epoll_create(epoll_max_sfd);
if(s_val->epoll_fd == -1){
printf("listen pthread create epoll fail, errno: %d\\n",errno);
s_val->sig_exit++;
return -1;
}
s_val->sfd_li = cre_sock_li... | 1 |
#include <pthread.h>
static sem_t _sem_recv_msgs_empty;
static sem_t _sem_recv_msgs_full;
static char *recv_msgs[16] = { 0 };
static pthread_mutex_t _lock_read_id;
pthread_mutex_t _lock_readstream;
pthread_cond_t _cond_readstream;
void thread_readstream_post_new_msg(char *msg)
{
static in... | 0 |
#include <pthread.h>
unsigned long long int COUNTER;
pthread_mutex_t LOCK = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t START = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t CONDITION = PTHREAD_COND_INITIALIZER;
void * threads (void * unused) {
pthread_mutex_lock(&START);
pthread_mutex_unlock(&START);... | 1 |
#include <pthread.h>
struct xml_cntn_fd * xml_cntn_fd_create(int *fd)
{
int retval;
struct xml_cntn_fd *new = malloc(sizeof(*new));
assert(new);
memset(new, 0, sizeof(*new));
new->fd = fd;
new->run = 1;
*new->fd = -1;
new->ready = 0;
if((retval = pthread_mutex_init(&new->mutex, 0))!=... | 0 |
#include <pthread.h>
long shimid;
key_t key = 66607;
struct ipcstruct {
int value;
int size;
int cachesending;
int proxysending;
pthread_mutex_t memMutex;
pthread_cond_t cvProxyGo;
pthread_cond_t cvCacheGo;
};
int main(int argc, char **argv){
printf("OK\\n");
int shmd;
if ( argc < 2 ... | 1 |
#include <pthread.h>
struct job {
struct job* next;
int jid;
};
struct job* job_queue;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t sem;
void*
thread_func (void *tid)
{
struct job* my_job;
while (1) {
sem_wait(&sem);
pthread_mutex_lock(&mutex);
if (job_queue == 0) {
p... | 0 |
#include <pthread.h>
pthread_t tid[5];
pthread_mutex_t lock, intLock;
char queue[10000] = { "\\0" };
int qLen = -1;
int internal_count = 0;
int flag = 0;
char getCh() {
pthread_mutex_lock(&lock);
char ch;
char temp;
if (qLen == -1) {
pthread_mutex_unlock(&lock);
return '\\0';
}
ch = que... | 1 |
#include <pthread.h>
int ar[21];
int front;
int rear;
} Quene;
Quene quene;
int isFull(Quene *q)
{
return (q->rear + 1) % 21 == q->front;
}
int isEmpty(Quene *q)
{
return q->rear == q->front;
}
int queneSize(Quene *q)
{
return (q->rear + 21 - q->front) % 21;
}
pthread_mutex_t mute... | 0 |
#include <pthread.h>
int multiplo(int x){
int ret;
ret = ((((x - 1) >> 2) << 2) + 4);
return ret;
}
struct cabecalho {
size_t tamanho;
unsigned livre;
struct cabecalho *prox;
};
struct cabecalho *head, *tail;
pthread_mutex_t bloqueio_desbloqueio;
struct cabecalho *pega_bloco_li... | 1 |
#include <pthread.h>
static int OpenSerialPortMul(const char *serpath)
{
int result = -1;
int i=0;
for (i=0; i<TRY_TIMES; i++)
{
result = OpenSerialPort(serpath);
if (-1 != result)
{
break;
}
usleep(TRY_INTERVAL*1000);
}
return result;
}
static int SetSerialPortOptMul(int... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
assiette * tampon[3];
sem_t * plein;
sem_t * vide;
const char* type(assiette * a) {
switch (*a) {
case VIDE:
return "vide";
case CUPCAKE:
return "cupcake";
case MUFFIN:
return "muffin";
case PANCAKE:
re... | 1 |
#include <pthread.h>
pthread_cond_t condition_alarme
= PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_alarme
= PTHREAD_MUTEX_INITIALIZER;
static void * thread_temperature(void * inutile);
static void * thread_alarme(void * inutile);
static int aleatoire(int maximum);
int
main(... | 0 |
#include <pthread.h>
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count = 0;
void *decrement_count(void *arg)
{
pthread_mutex_lock(&count_lock);
printf("decrement_count get count_lock\\n");
while(count == 0)
{
printf("decrement_count count == 0 \\n");... | 1 |
#include <pthread.h>
pthread_cond_t count;
pthread_mutex_t count_mutex;
pthread_mutex_t printie;
struct parameters {
int counter;
int simulationtime;
int I;
double* old;
double* current;
double* next;
}params;
void *HelloWorld(void *args);
double *simulate(const int... | 0 |
#include <pthread.h>
int counter_enq = 0;
int counter_deq = 0;
int counter_loo = 0;
int N = 100;
int T = 90;
struct listnode
{
int value;
struct lisnode *next;
};
struct queue {
struct listnode *head;
struct listnode *tail;
int size;
pthread_mutex_t mutex;
};
struct queue *queue_crea... | 1 |
#include <pthread.h>
void init_matrix (int *matrix, int fils, int cols) {
int i, j;
for (i = 0; i < fils; i++) {
for (j = 0; j < cols; j++) {
matrix[i * cols + j] = 1;
}
}
}
int *matrix1;
int *matrix2;
int *matrixR;
int matrix1_fils;
int matrix1_cols;
int matrix2_fils;
int matrix2_col... | 0 |
#include <pthread.h>
struct prodcons {
int buffer[16];
pthread_mutex_t lock;
int readpos, writepos;
pthread_cond_t notempty;
pthread_cond_t notfull;
};
void init(struct prodcons *b) {
pthread_mutex_init(&b->lock, 0);
pthread_cond_init(&b->notempty, 0);
pthread_c... | 1 |
#include <pthread.h>
int port = 0;
pthread_mutex_t port_mutex;
int Connect(const char *hostname, int port)
{
int sock;
struct hostent *host;
struct sockaddr_in host_addr;
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
perror("socket()");
}
host = gethostbyname(hostname);
... | 0 |
#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 ... | 1 |
#include <pthread.h>
struct message
{
long msg_type;
char msg_text[BUFFER_SIZE];
}msgbuf;
static pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t v = PTHREAD_COND_INITIALIZER;
void *sender(void *args)
{
int qid = *(int *)args;
while(1){
pthread_mutex_lock(&m);
whil... | 0 |
#include <pthread.h>
pthread_mutex_t * mutex_fib;
pthread_t * tids;
int * result;
size_t size;
void *fib(void * arg){
size_t id = (size_t) arg;
pthread_mutex_lock(&mutex_fib[id]);
if (id == 0) {
result[0] = 0;
} else if (id == 1) {
result[1] = 1;
... | 1 |
#include <pthread.h>
int buffer[16]={0};
int num_Produced;
int num_Consumed;
int items;
pthread_mutex_t bufferLock;
sem_t *fullSlots;
sem_t *emptySlots;
const char *full = "fullSlots";
const char *empty= "emptySlots";
void *produce(void *param);
void *consume(void *param);
int main(int argc, ... | 0 |
#include <pthread.h>
void ClockLinux_ClockImpl_OnExit(int state, struct ClockLinux_Instance *_instance);
void f_ClockLinux_sleep_ms(struct ClockLinux_Instance *_instance, int timeout_ms);
void f_ClockLinux_start_clock_process(struct ClockLinux_Instance *_instance);
void f_ClockLinux_s... | 1 |
#include <pthread.h>
int errexit(const char* format,...);
struct {
pthread_mutex_t st_mutex;
unsigned int st_concount;
unsigned int st_contotal;
unsigned int st_contime;
unsigned int st_bytecount;
}stats;
int tcp_echod(int fd)
{
time_t start;
char buf[4096];
int cc;
start=time(0);
... | 0 |
#include <pthread.h>
static pthread_mutex_t trigger_cmd_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t trigger_cmd = PTHREAD_COND_INITIALIZER;
static int command_type = m_login;
static struct commandt_data *cm_data;
void send_login(int socket, uint8_t role, char *name) {
... | 1 |
#include <pthread.h>
void *pico_mutex_init(void)
{
pthread_mutex_t *m;
m = (pthread_mutex_t *)PICO_ZALLOC(sizeof(pthread_mutex_t));
pthread_mutex_init(m, 0);
log_debug("Initialized a mutex at %p",(void *)m);
return (pthread_mutex_t *)m;
}
void pico_mutex_destroy(void *mux)
... | 0 |
#include <pthread.h>
struct arg_set{
int number;
char *fname;
int count;
};
struct arg_set *mailbox = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
void *count_words(void *);
int main(int argc, char *argv[]) {
pthread_t pid... | 1 |
#include <pthread.h>
pthread_mutex_t stick[5];
void chopsticks_init(){
pthread_mutex_init(&stick[0], 0);
pthread_mutex_init(&stick[1], 0);
pthread_mutex_init(&stick[2], 0);
pthread_mutex_init(&stick[3], 0);
pthread_mutex_init(&stick[4], 0);
}
void chopsticks_destroy(){
... | 0 |
#include <pthread.h>
int asciiCharacters[128];
char buffer[65536];
pthread_mutex_t lock;
int partitionBounds;
int threadNumber;
int max_length;
} thread_information;
void *ascii_checker(void *t_info) {
int i, threadLocation;
thread_information *threadinfo = (thread_in... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *threadFunc1(void *offset){
printf("update thread has created: %lu\\n",pthread_self());
pthread_mutex_lock(&mutex);
*((int *)offset) = 10;
sleep(1);
*((int *)offset +1) = 20;
pthread_mutex_unlock(&mutex);
re... | 0 |
#include <pthread.h>
int elementos[10];
int in = 0;
int out = 0;
int total = 0;
int producidos = 0, consumidos = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t consume_t = PTHREAD_COND_INITIALIZER;
pthread_cond_t produce_t = PTHREAD_COND_INITIALIZER;
void * product... | 1 |
#include <pthread.h>
pthread_t test_threads[2];
static pthread_mutex_t test_mutex = PTHREAD_MUTEX_INITIALIZER;
int test_reg;
void perror_exit(char *error_message)
{
printf("error: %s\\n", error_message);
exit(1);
}
void* test_mutex_thread1(void *thread_arg)
{
unsigned int... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
{
int _data;
struct _node *_next;
}node_t, *node_p, **node_pp;
node_p head;
static node_p alloc_node(int data)
{
node_p tmp = (node_p)malloc(sizeof(node_t));
if... | 1 |
#include <pthread.h>
char *get_line (char *buf, size_t bufsize);
int idle_count = 0;
int update = 0;
pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
void *tenSecTillFee(void *arg)
{
int tries = 0;
int response;
while(1){
tries = 0;
while(tries < 10) {
sleep... | 0 |
#include <pthread.h>
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: ;
goto ERROR;
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(void)
{
ret... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
unsigned int __VERIFIER_nondet_uint();
static int top=0;
static unsigned int arr[(800)];
pthread_mutex_t m;
_Bool flag=(0);
void error(void)
{
ERROR:
__VERIFIER_error(); return;
}
void inc_top(void)
{
top++;
}
void dec_to... | 0 |
#include <pthread.h>
{
int id, vector, place, **grid;
} threadinfo;
void *threadwork(void *);
int answer;
pthread_mutex_t themutex;
int main(int argc, char **argv)
{
int vector = atoi(argv[1]);
int place = atoi(argv[2]);
int **grid = createArray(vector, place);
readFile(vector, place,... | 1 |
#include <pthread.h>
int x[10000];
int i1,j,check=1,size;
int usf[1000],usl[1000];
clock_t start, end;
double time_spent;
int partition(int a[], int p, int r);
pthread_mutex_t lock,lock1,lock2,lock3,lock4;
{
int x;
int counter;
}t_data;
void *init1 (void*arg)
{
int id,c;
t_data *t=(... | 0 |
#include <pthread.h>
static int (*old_pthread_create)(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
static unsigned long page_size;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static FILE *out_file = 0;
st... | 1 |
#include <pthread.h>
void *reallocf_without_thread(void *ptr, size_t size)
{
void *ret;
t_header_block *block;
if (ptr == 0)
return (malloc_without_thread(size));
if (0 == (block = check_ptr_block(check_ptr_page(ptr), ptr)))
return (0);
else if (size == 0)
{
free_without_thread(ptr);
... | 0 |
#include <pthread.h>
double integral = 0.0;
pthread_mutex_t lock;
pthread_t threads[];
double AreaTrapezio(double dx, double h1, double h2) {
double area;
area = dx * (h1 + h2) / 2;
return area;
}
double f(double x) {
return (4 * sqrt(1 - x * x));
}
double inferi... | 1 |
#include <pthread.h>
static const int MIN_PID = 300;
static const int MAX_PID = 5000;
static const int NUM_THREADS = 300;
static uint8_t pidman[588];
static pthread_mutex_t mutex;
static int allocate_map(void)
{
memset(pidman, 0x00, sizeof pidman);
pthread_mutex_init(&mutex, 0);
re... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.