text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int producer(void *args);
int consumer(void *args);
pthread_mutex_t mutex;
sem_t product;
sem_t warehouse;
char buffer[8][10];
int bp=0;
int main(int argc,char **args)
{
pthread_mutex_init(&mutex,0);
sem_init(&warehouse,0,8);
sem_init(&product,0,0);
int clone_flag,arg... | 1 |
#include <pthread.h>
static void arruma_ordem (int id);
static void checa_terceiro ();
int sorteia_vel (int id) {
int i, eq, ret, v;
if (g_modo == 'u') return 1;
if (cic[id].volta <= 0) return 0;
eq = id / g_n;
pthread_mutex_lock (&mutex_ord[eq]);
v = cic[id]... | 0 |
#include <pthread.h>
const int NrProd = 3, NrCons = 2;
const int BufLen = 6;
int in = 0, out = 0;
sem_t empty, full;
pthread_mutex_t mutex;
int producerID = 0, consumerID = 0;
void handler(int signo)
{
printf("Exit program.\\n");
exit(0);
}
void *producerFunc(void *arg)
{
int i... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
static pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
static void *
thread_helper(void *arg)
{
void (*testfunc)(void) = arg;
testfunc();
pthread_mutex_lock(... | 0 |
#include <pthread.h>
int event_filter(const struct inotify_event *event)
{
int n = 0;
if ((event->mask) & IN_IGNORED)
n = 1;
if (!((event->mask) & IN_ISDIR) && ((event->mask) & IN_CREATE))
n = 1;
if (strchr((event->name), ... | 1 |
#include <pthread.h>
static int glob = 0;
static pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t mtx3 = PTHREAD_MUTEX_INITIALIZER;
static void *
threadFunc1(void *arg)
{
pthread_mutex_lock(&mtx1);
if(glob%2==0){... | 0 |
#include <pthread.h>
void handle_error(const char *file, int lineno, const char *msg) {
fprintf(stderr, "** %s:%d %s\\n", file, lineno, msg);
ERR_print_errors_fp(stderr);
}
static pthread_mutex_t *mutex_buf = 0;
static void locking_function(int mode, int n, const char *file, int line) {... | 1 |
#include <pthread.h>
pthread_mutex_t sharedElementMutex;
pthread_cond_t canConsumeCondition;
int canConsume = 0;
int sharedElement = 0;
int done = 0;
void *theThread(void *parm){
int rc;
printf("Consumer Thread %u: Entered\\n", pthread_self());
rc = pthread_mutex_lock(&sharedEl... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
... | 1 |
#include <pthread.h>
pthread_mutex_t number_mutex1;
int globalnumber1 = 10;
int globalnumber2 = 5;
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);
if(pthread_create(&t... | 0 |
#include <pthread.h>
double sum=0.0, a[1000000];
pthread_mutex_t sum_mutex;
void *do_work(void *tid)
{
int i, start, *mytid, end;
double mysum=0.0;
mytid = (int *) tid;
start = (*mytid * 1000000 / 8);
end = start + 1000000 / 8;
printf ("Thread %d doing iterations %d to %d\... | 1 |
#include <pthread.h>
extern void do_work ();
int thread_flag;
pthread_mutex_t thread_flag_mutex;
void initialize_flag ()
{
pthread_mutex_init (&thread_flag_mutex, 0);
thread_flag = 0;
}
void* thread_function (void* thread_arg)
{
while (1) {
int flag_is_set;
pthread_mute... | 0 |
#include <pthread.h>
pthread_mutex_t varLock = PTHREAD_MUTEX_INITIALIZER;
int var = 0;
int id;
int value;
} thread_info;
void *threadFunc(void *info) {
thread_info *INFO = (thread_info*) info;
printf("Sou a thread %d. Meu valor é: %d\\n", (int)INFO->id, INFO->value);
int l... | 1 |
#include <pthread.h>
void mux_2_alusrca(void *not_used){
pthread_barrier_wait(&threads_creation);
while(1)
{
pthread_mutex_lock(&control_sign);
if (!cs.isUpdated){
while(pthread_cond_wait(&control_sign_wait, &control_sign) != 0);
... | 0 |
#include <pthread.h>
pthread_t t[2];
pthread_mutex_t lock;
int i;
int number;
int *retval;
void die(int re, const char * msg) {
if (re != 0) {
perror(msg);
}
}
void *func1(void * arg) {
printf("the func1 thread %s\\n", (char *) arg);
for (i = 0; i < 10; i++) {
printf("the number... | 1 |
#include <pthread.h>
FILE* MF_LOG_FILE;
void mf_logger_open(const char* path)
{
if(path == 0)
{
log_warn("Log path is not specific");
path = mf_default_log_path;
}
MF_LOG_FILE = fopen(path, "w");
if(MF_LOG_FILE == 0)
{
log_err("File open failed");
exit(0);
}
pthread_mutex_init(&... | 0 |
#include <pthread.h>
int shared_variable;
int waiting_readers;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t read_sig = PTHREAD_COND_INITIALIZER;
pthread_cond_t write_sig = PTHREAD_COND_INITIALIZER;
int resource_counter;
void *reader(void *arg);
void *writer(void *arg);
int... | 1 |
#include <pthread.h>
void init_gbl(int status, int imgCtoW_th, int imgWtoC_th, int saturation)
{
pthread_mutex_init(&g_stInfrad_ctl.mutex, 0);
g_stInfrad_ctl.imgCtoW_th = imgCtoW_th;
g_stInfrad_ctl.imgWtoC_th = imgWtoC_th;
g_stInfrad_ctl.status = status;
g_stInfrad_ctl.img_saturation = sat... | 0 |
#include <pthread.h>
pthread_mutex_t mtx;
pthread_cond_t cnd;
} pmtx_t;
void *Mutex_Init()
{
pmtx_t *pmtx = malloc(sizeof(pmtx_t));
int ret = pthread_mutex_init(&pmtx->mtx, 0);
if (ret) {
DEBUG("%s (%i) :: CreateMutex error (%d) !\\n", __func__, 36, ret);
return 0;
}
return pmtx;
}
void... | 1 |
#include <pthread.h>
pthread_t fid[1],cid[20];
pthread_mutex_t cpu=PTHREAD_MUTEX_INITIALIZER,s[20];
int num;
int remain;
int state;
}pcb;
int remain;
int index;
}temp;
pcb thread[20],nThread[20];
temp pcbIns[20];
int total=0;
int first=0;
int waitTime=0;
void insertionSort(n){
int j=1;
... | 0 |
#include <pthread.h>
int main(int argc, char *argv[])
{
int fd = 0, zero = 0, i = 0;
int *addr = 0;
int nloops = 0;
pid_t cpid = 0;
pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t *p_mutex;
pthread_mutexattr_t mattr;
if(argc != 2)
{
... | 1 |
#include <pthread.h>
pthread_mutex_t x,wsem;
pthread_t tid;
int readcount;
void intialize()
{
pthread_mutex_init(&x,0);
pthread_mutex_init(&wsem,0);
readcount=0;
}
void * reader (void * param)
{
int waittime;
waittime = rand() % 5;
printf("\\nReader is trying to enter");... | 0 |
#include <pthread.h>
int make_listen(int port);
void handle_connection(FILE* fin, FILE* fout);
int remove_trailing_whitespace(char* buf);
static pthread_mutex_t mutex;
static pthread_cond_t condvar;
static int n_connection_threads;
void* connection_thread(void* arg) {
FILE* f = (FILE*) arg;
... | 1 |
#include <pthread.h>
static int matrice_a[100][100];
static int matrice_b[100][100];
static int matrice_c[100][100];
static pthread_mutex_t mutex_matrice_mul;
static void init(void)
{
int i, j;
for (i = 0; i < 100; i++) {
for (j = 0; j < 100; j++) {
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_personas[10];
pthread_mutex_t mutex[10][3];
int personas[10];
int capacidad_salas[10][3];
void *fila(void *);
void capacidad(int, int, int);
int main() {
pthread_t taquillas[10][3];
int i, j;
srand((int)time(0));
for (i = 0; i < 10; i++... | 1 |
#include <pthread.h>
const char* noCon = "NO_CONN";
void
resetCon(int index){
pthread_mutex_lock(&connection_mutex);
connections[index].status = NOCONN;
strcpy(connections[index].nickname,noCon);
strcpy(connections[index].hostname,noCon);
strcpy(connections[index].realname,noCon);
connectio... | 0 |
#include <pthread.h>
struct header_t {
size_t size;
unsigned freemem;
struct header_t *next;
};
struct header_t *head = 0, *lst = 0;
pthread_mutex_t global_malloc_lock;
struct header_t *get_free_block(size_t size)
{
struct header_t *curr = head;
while(curr) {
if (curr->freemem && curr->si... | 1 |
#include <pthread.h>
pthread_mutex_t *global_lock;
int main(int argc, char *argv[]) {
global_lock = mmap(0, sizeof(*global_lock), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
pid_t pid = fork();
int k = 1000000;
if (pid > 0) {
struct timespec nStart, nEnd... | 0 |
#include <pthread.h>
pthread_mutex_t lock2;
int main(int argc, char* argv[]) {
int id;
SharedMem *ptr;
id = shmget (atoi(argv[1]), 0, 0);
if (id == -1){
perror ("child shmget failed");
exit (1);
}
ptr = shmat (id, (void *) 0, 1023);
if (ptr == (void ... | 1 |
#include <pthread.h>
char name;
char target;
int gen;
pthread_mutex_t *my_mutex;
pthread_cond_t *my_cond;
int *my_health;
pthread_mutex_t *target_mutex;
pthread_cond_t *target_cond;
int *target_health;
}thread_arg_t;
char name;
char target;
... | 0 |
#include <pthread.h>
pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t thread_cond_var = PTHREAD_COND_INITIALIZER;
int counter = 1;
void wait_on_cond_var (void)
{
pthread_mutex_lock (&cond_mutex);
pthread_cond_wait(&thread_cond_var, &cond_mutex);
pthread_mutex_unl... | 1 |
#include <pthread.h>
void *do_one_thing(void *);
void *do_another_thing(void *);
void do_wrap_up(int, int);
int r1 = 0, r2 = 0, r3 = 0;
pthread_mutex_t r3_mutex=PTHREAD_MUTEX_INITIALIZER;
extern int
main(int argc, char **argv)
{
pthread_t thread1, thread2;
if (argc > 1)
r3 = atoi(arg... | 0 |
#include <pthread.h>
pthread_mutex_t theMutex;
pthread_cond_t condc, condp;
int buffer[10];
int back=0, size=0;
void* producer(void* ptr)
{
int x;
while(1==1)
{
pthread_mutex_lock(&theMutex);
printf("Producer Locked\\n");
while(size==10)
{
printf("Producer waiting\\n");
pthread_c... | 1 |
#include <pthread.h>
pthread_cond_t LR_eating;
pthread_mutex_t table_mutex;
sem_t printStat;
char phil_stats[];
int Nphils;
void changePrintStates(char state, int idPhil){
sem_wait(&printStat);
phil_stats[idPhil] = state;
int i;
for (i = 0; i < Nphils; ++i) {
print... | 0 |
#include <pthread.h>
static int _spoolbuf_slots_open_unlocked(struct spoolbuf_slots_st *spoolslots,
struct spoolbdbv_st *spooldb,
char *fkey, int *sd,
int f_read_unlocked);
struct spoolbuf_slots_st *spoolbuf_slots_create(int N){
int status = 0;
int i;
assert(N > 0... | 1 |
#include <pthread.h>
static pthread_mutex_t g_mutex;
static pthread_mutexattr_t g_attr;
static pthread_t g_thread1;
static void hold_mutex(int c)
{
int ret;
if (c == 0) {
return;
}
printf("enter hold_mutex [caller %d]\\n", c);
ret = pthread_mutex_lock(&g_mutex);
hold_mutex(c-1);
s... | 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 = lo... | 1 |
#include <pthread.h>
void print_mem(void *ptr, size_t size)
{
size_t i;
char *str;
i = 0;
str = (char *)ptr;
while (i < size && i < 25)
{
if ((str[i]) > 33 && (int)(str[i]) < 127)
ft_putchar(str[i]);
else if (str[i] == 0)
ft_putchar('0');
else
ft_putchar('.');
ft_putchar(' ... | 0 |
#include <pthread.h>
void *hilo1(void *p);
void *hilo2(void *p);
int acabar;
char cadena[50];
pthread_mutex_t muti = PTHREAD_MUTEX_INITIALIZER;
int main(void)
{
pthread_t th1;
pthread_t th2;
int i;
int res;
void *result;
printf("main: Comenzando la primera prueba, sin mute... | 1 |
#include <pthread.h>
pthread_cond_t fakeCond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t fakeMutex = PTHREAD_MUTEX_INITIALIZER;
void btn_risingInterrupt() {
if (digitalRead(GPIO_BTN_PLAY)==HIGH || digitalRead(GPIO_BTN_STOP)==HIGH) {
pthread_cond_signal(&fakeCond);
}
}
void* threadP... | 0 |
#include <pthread.h>
int numberPhilosophers;
int philosopherLocation[10];
int philosopherStatus[10];
int chopstickStatus[10];
pthread_mutex_t chopsticks[10];
int randomwait(int bound) {
int wait = rand() % bound;
sleep(wait);
return wait;
}
void printPhilosophers () {
int i;
... | 1 |
#include <pthread.h>
char locker = '\\0';
long long counter = 0;
int opt_yield=0;
int s_test_lock = 0;
pthread_mutex_t m_test_mutex;
void add(long long* pointer, long long value) {
long long sum = *pointer + value;
if (opt_yield)
pthread_yield();
*pointer = sum;
}
void* thread_action(void*... | 0 |
#include <pthread.h>
static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
static unsigned int init_n = 0;
int SCE_Init_Utils (FILE *outlog)
{
int ret = SCE_OK;
if (pthread_mutex_lock (&init_mutex) != 0) {
SCE_Init_Error (outlog);
SCEE_Log (42);
SCEE_LogMsg... | 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;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y + a;
y = y +... | 0 |
#include <pthread.h>extern int __VERIFIER_nondet_int(void);
extern void __VERIFIER_error() ;
int element[(800)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(800)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int ... | 1 |
#include <pthread.h>
void *allocate_tiny(size_t size)
{
void *block;
pthread_mutex_lock(&g_global_lock);
if (g_book_keeper.tiny.head == 0)
{
g_book_keeper.tiny.head = allocate_new_zone(TINY_MAX);
divide_zone((void*)&(g_book_keeper.tiny.head),
(void*)&(g_book_keeper.tiny.tail), TINY_MA... | 0 |
#include <pthread.h>
static char* output_string = 0;
static pthread_mutex_t output_lock;
static int initialized = 0;
static pthread_t thread;
static void* query_volume_thread() {
if( output_string == 0 ) {
output_string = calloc( 128, sizeof(char) );
}
while( initializ... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
void *functionCount1();
void *functionCount2();
int count = 0;
void main()
{
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCount1, 0);
pth... | 0 |
#include <pthread.h>
unsigned int males;
unsigned int females;
unsigned int total_males;
unsigned int total_females;
pthread_mutex_t mutex;
pthread_cond_t full;
} bathroom_t;
static bathroom_t shared_bathroom = {
.males = 0,
.females = 0,
.total_males = ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
FILE *f;
int *accesses;
struct timeval *recent;
int number = 0;
int wwidth;
int status;
void load_time( struct timeval x )
{
int i;
if( number == wwidth )
... | 0 |
#include <pthread.h>
int i;
{
pthread_mutex_t mutex;
pthread_cond_t cond;
int buf[200000000];
int nput;
int next_val;
} share_t;
share_t share_data = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER};
void *produce(void *ptr)
{
for (;;) {
pthread_mutex_l... | 1 |
#include <pthread.h>
void control_pid_par()
{
clear_to_color(screen, COL_BG);
layout_base("Control PID parameters");
button_set(rectx1, recty1, "Previus");
textout_centre_ex(screen, font, "SET THE GAINS FOR CONTROLLER", sezx/2, d, COL_BUT, BG);
button_set(pidx1,... | 0 |
#include <pthread.h>
pthread_cond_t Cond_Var;
pthread_mutex_t Lock;
pthread_t Thread_Id;
} Shared_Task;
Shared_Task Shared_T;
struct TSK Tasks;
struct timespec ts;
struct timespec nextperiod;
pthread_cond_t cv[30];
int firstexec = -1;
void Un_Thread(int *i);
void Fonc1(int i);
int ma... | 1 |
#include <pthread.h>
pthread_t threads[ 20 ];
pthread_t chicken_thread;
pthread_mutex_t cmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cvar = PTHREAD_COND_INITIALIZER;
int count = 10;
int condition = 0;
extern int bar(int t, int x);
static void *
start_chicken(void *arg)
{
C... | 0 |
#include <pthread.h>
void *producer_t();
void *consumer_t();
char buffer[7][14];
int in=0, out=0, count=0;
pthread_mutex_t buf_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t empty_slot = PTHREAD_COND_INITIALIZER;
pthread_cond_t item_avail = PTHREAD_COND_INITIALIZER;
FILE *fp0, *fp1;
pthr... | 1 |
#include <pthread.h>
struct channel g_channel[MAX_CHANNELS];
static pthread_mutex_t channel_hash = PTHREAD_MUTEX_INITIALIZER;
void isempty_name_channel(const char *name, struct channel **channel,
const char *func_name)
{
if(name == 0){
complain_error_msg(1, ... | 0 |
#include <pthread.h>
void *calculate_frame(void *unused)
{
while (1) {
usleep(dt * 1000000);
if (paused())
continue;
if (game_end_flag)
break;
pthread_mutex_lock(&run_yield);
capture_passive_mouse_input();
apply_thrust(1);
process_motion(1);
process_asteroid_motion(1)... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_oeb;
uint64_t get_48(uint32_t addr_low, uint32_t addr_mid, uint32_t addr_high)
{
uint16_t low = inw(addr_low);
uint32_t mid = inw(addr_mid);
uint64_t high = inw(addr_high);
return (high << 32) + (mid << 16) + low;
}
int oeb_init()
{
... | 0 |
#include <pthread.h>
static void
node_unlink (struct node *node, struct ftpfs *fs)
{
struct netnode *nn = node->nn;
if (nn->ncache_next)
nn->ncache_next->nn->ncache_prev = nn->ncache_prev;
if (nn->ncache_prev)
nn->ncache_prev->nn->ncache_next = nn->ncache_next;
if (fs->node_cach... | 1 |
#include <pthread.h>
pthread_mutex_t func1_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_spinlock_t func2_mutex;
pthread_rwlock_t func34_mutex = PTHREAD_RWLOCK_INITIALIZER;
void *pthread_func1(void *unused)
{
pthread_mutex_lock(&func1_mutex);
printf("Func1 mutex lock.\\n");
pthread_mutex... | 0 |
#include <pthread.h>
struct autharg {
char username[32], password[32], hostname[32];
char *vp;
};
static int numthreads = 32;
static pthread_t *threads;
static int running = 1;
static struct sigaction sigint;
static pthread_mutex_t wait_sigint = PTHREAD_MUTEX_INITIALIZER;
void sigint_called(... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int job[2] = {0};
void *t1_handler(void *arg)
{
long id = (long)arg;
int data;
int i;
while(1){
pthread_mutex_lock(&mutex);
while(job[id] == 0){
pthread_cond_wa... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i < 10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
printf("inc_count():... | 1 |
#include <pthread.h>
int PBSD_sig_put(
int c,
char *jobid,
char *signal,
char *extend)
{
int sock;
int rc = 0;
struct tcp_chan *chan = 0;
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
if ((chan = DIS_tcp_setup(sock)) == 0)
{
rc ... | 0 |
#include <pthread.h>
void *start_calculation(void *arg)
{
pthread_mutex_lock(&lock_vars);
info.highwayLenght = 0.0;
int i, k = 0;
for (i = 0; i < COUNT - 1; i++)
{
for (k = i + 1; k < COUNT - 1; k++)
{
float road = distance_between_city(cityCenter[i]... | 1 |
#include <pthread.h>
struct th_info {
int id;
};
int buffer;
int empty = 1;
pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t full_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t empty_cond = PTHREAD_COND_INITIALIZER;
void make_product(int tid) {
pthread_mutex_lock... | 0 |
#include <pthread.h>
struct job{
struct job* next;
};
struct job* job_queue;
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
void init_job_queue(){
job_queue = 0;
int value;
sem_init(&job_queue_count, 0,0);
}
void* thread_function (void*... | 1 |
#include <pthread.h>
double* A;
double* B;
double produto_escalar = 0;
int id;
} TArgs;
pthread_mutex_t s;
void* trabalhador(void* args){
TArgs* arg = (TArgs*) args;
int id = arg->id;
int inicio, fim, i;
double soma;
inicio = id*(6/2);
fim = inicio + (... | 0 |
#include <pthread.h>
pthread_mutex_t region_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t space_available = PTHREAD_COND_INITIALIZER;
pthread_cond_t data_available = PTHREAD_COND_INITIALIZER;
int b[5];
int size = 0;
int front,rear=0;
main()
{
pthread_t producer_thread;
pthread_t consum... | 1 |
#include <pthread.h>
int check[20]={0},tree[20]={-1},lca_ind;
pthread_mutex_t mutex;
void lca(void* lca_index)
{
int p = (int)lca_index;
while(1)
{
pthread_mutex_lock(&mutex);
if(check[p]==1)
{
lca_ind = p;
pthread_mutex_unlock(&mutex);
return;
}
check[p]=1;
p/=2;
pthrea... | 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 = 1; i <= 1000000000; i++) {
pthread_mutex_lock(&the_mutex);
while (buffer != 0)
pthread_cond_wait(&condp, &the_mutex);
buffer... | 1 |
#include <pthread.h>
void *find_png(void *path){
char *file, *file_ext, file_path[1000];
DIR *inDir;
struct dirent *inDirent;
inDir = opendir(path);
if (!inDir) {
fprintf(stderr, "Error while searching for png files: invalid file path.\\n");
fprintf(stderr, " Unable to op... | 0 |
#include <pthread.h>
pthread_mutex_t sem_mutex;
pthread_cond_t sem_cond;
unsigned int sem_count;
int sem_magic;
} sem_t;
sem_t *sem_open(const char *pathname, int oflag, ...)
{
int fd, i, created, save_errno;
mode_t mode;
va_list ap;
sem_t *sem, seminit;
struct stat statbuf;
unsigned in... | 1 |
#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... | 0 |
#include <pthread.h>
{
int buffer[10];
pthread_mutex_t mutex;
pthread_cond_t notfull;
pthread_cond_t notempty;
int write_pos;
int read_pos;
}pc_st;
pc_st pc;
void init_pc(pc_st *pt)
{
memset(pt->buffer, 0, sizeof(pt->buffer));
pthread_mutex_init(&pt->mutex, 0);
pthread_cond_init(&pt... | 1 |
#include <pthread.h>
static pthread_mutex_t la_data_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t trigger_la_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t trigger_lagent = PTHREAD_COND_INITIALIZER;
struct liveagentt_data *la_data;
void send_board_content() {
... | 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>
{
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>extern void __VERIFIER_error() ;
int element[(400)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(400)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
... | 1 |
#include <pthread.h>
pthread_t Prisoner[64];
pthread_mutex_t mutexlight;
pthread_mutex_t mutexstop;
int light;
int stop;
void *prisoner(void *arg)
{
long tid;
tid = (long)arg;
if(tid ==0)
{
int count = 1;
for(;count < 64;)
{
pthread_mutex_lock (&... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc=PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err,signo;
for(;;)
{
err=sigwait(&mask,&signo);
if(err!=0)
err_exit(err,"sigwait fialed");
switch (signo)
... | 1 |
#include <pthread.h>
int data = -100;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void *writer(void *arg) {
int val;
pthread_mutex_lock(&mutex1);
printf("Enter a value: ");
scanf("%d", &val);
data = val;
pthread_mutex_unlock(&mutex1);
return 0;
}
void *reader(void *arg) {
int v... | 0 |
#include <pthread.h>
void* producer(void* arg);
void* consumer(void* arg);
int buffer[100];
int count = 0;
int in = -1;
int out = -1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t buffer_has_space = PTHREAD_COND_INITIALIZER;
pthread_cond_t buffer_has_data = PTHREAD_CON... | 1 |
#include <pthread.h>
int occurenceArray[128];
char buffer[65536];
void printArray();
int i = 0;
int sum = 0;
pthread_mutex_t lock;
int badge;
int startOfBuffer;
int endOfBuffer;
} define_thread_type;
void *count(void *param)
{
pthread_mutex_lock(&lock);
define_thread_type *thr... | 0 |
#include <pthread.h>extern void __VERIFIER_error();
unsigned int __VERIFIER_nondet_uint();
static int top = 0;
static unsigned int arr[400];
pthread_mutex_t m;
_Bool flag = 0;
void error(void)
{
ERROR:
__VERIFIER_error();
return;
}
void inc_top(void)
{
top++;
}
void dec_top(void)
{
top--;
}
int get_top(vo... | 1 |
#include <pthread.h>
const int BUFFER_SIZE = 10;
pthread_mutex_t mutex;
sem_t sem_empty, sem_full;
int g_idx;
void ConsumerFunc(void) {
volatile int flag = 1;
while (flag) {
sem_wait(&sem_full);
pthread_mutex_lock(&mutex);
printf(" Consumer get out of buffer %d\\... | 0 |
#include <pthread.h>
int npos;
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cvar=PTHREAD_COND_INITIALIZER;
int buf[10000000], pos=0, val=0;
void *fill(void *);
void *verify(void *);
int main(int argc, char *argv[]) {
int k, nthr, count[100];
pthread_t tidf[1... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int data = 0;
void *thread1(void *arg)
{
pthread_mutex_lock(&mutex);
data++;
printf ("t1: data %d\\n", data);
pthread_mutex_unlock(&mutex);
return 0;
}
void *thread2(void *arg)
{
pthread_mutex_lock(&mutex);
data+=2;
printf ("t2: ... | 0 |
#include <pthread.h>
pthread_mutex_t x,wsem;
pthread_t tidC[20],tidP[20];
int readcount;
void intialize()
{
pthread_mutex_init(&x,0);
pthread_mutex_init(&wsem,0);
readcount=0;
}
void *reader (void *param)
{
int waittime;
int *ind = (int *)param;
printf("Reader %d is tryi... | 1 |
#include <pthread.h>
int i = 0;
pthread_mutex_t i_mutex;
pthread_mutexattr_t i_mattr;
void* thread_func1(){
for(int x=0; x < 1000000; x++){
pthread_mutex_lock(&i_mutex);
i = i + 1;
pthread_mutex_unlock(&i_mutex);
}
return 0;
}
void* thread_func2(){
for(in... | 0 |
#include <pthread.h>
pthread_mutex_t ma[4];
pthread_mutex_t mi;
void *wa(void *arg)
{
unsigned id = (unsigned long) arg;
pthread_mutex_lock(&ma[id]);
pthread_mutex_unlock(&ma[id]);
return 0;
}
void *ra(void *arg)
{
unsigned id = (unsigned long) arg;
pthread_mutex_lock (&mi);
pthread_mut... | 1 |
#include <pthread.h>
size_t words;
size_t lines;
size_t characters;
}statistics;
uint8_t filename[20];
statistics values = {0, 0, 0};
struct sigaction sigInit;
sigset_t maskSet;
FILE *usrFile = 0;
sem_t signalThread2;
sem_t signalThread3;
pthread_mutex_t lockStat;
void s... | 0 |
#include <pthread.h>
const char plugin_name[] = "OStrich Scheduler plugin";
const char plugin_type[] = "sched/ostrich";
const uint32_t plugin_version = 100;
static int plugin_errno = SLURM_SUCCESS;
static pthread_t ostrich_thread = 0;
static pthread_t backfill_thread = 0;
static pthread_mute... | 1 |
#include <pthread.h>
char *smackfs_mnt = 0;
int smackfs_mnt_dirfd = -1;
static pthread_mutex_t smackfs_mnt_lock = PTHREAD_MUTEX_INITIALIZER;
static int verify_smackfs_mnt(const char *mnt);
static int smackfs_exists(void);
int init_smackfs_mnt(void)
{
char *buf = 0;
char *startp;
char *e... | 0 |
#include <pthread.h>
void register_bank(void *not_used){
pthread_barrier_wait(&threads_creation);
int read_register_1, read_register_2, write_register, write_data;
while(1){
pthread_mutex_lock(&control_sign);
if(!cs.isUpdated){
while... | 1 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
... | 0 |
#include <pthread.h>
int nprod = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;;
int fp1(int nprod) {
return nprod < 0;
}
void* prod(void* d) {
pb:
pthread_mutex_lock(&m);
nprod++;
pthread_mutex_unlock(&m);
pthread_mutex_lock(&m);
nprod++;
pthread_mutex_unlock(&m... | 1 |
#include <pthread.h>
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=0;
q->amount=0;
}
int empty(QType *... | 0 |
#include <pthread.h>
static int malloc_cnt, free_cnt;
void *p;
char *sfile;
int lineno;
} allocrecord;
static allocrecord inuse[(65536)];
static int nused = 0;
static int nused_max = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int find(void *p, int last) {
int hi... | 1 |
#include <pthread.h>
struct barrier {
int counter;
pthread_mutex_t mutex;
pthread_cond_t condition;
};
static struct barrier my_barrier = {
.counter = 0,
.mutex = PTHREAD_MUTEX_INITIALIZER,
.condition = PTHREAD_COND_INITIALIZER
};
unsigned int random_uint(unsigned... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.