text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct thread_pass {
pthread_mutex_t server;
pthread_mutex_t clients;
pthread_cond_t done;
int work;
void *data;
};
struct thread_pass *
thread_pass_new(void *data)
{
struct thread_pass *p = malloc(sizeof(*p));
pthread_mutex_init(&p->server, 0);
pthread_mutex_init... | 1 |
#include <pthread.h>
struct thread_data {
int shmid;
pthread_mutex_t *mutex_ptr;
};
void *second_thread(void *this_data)
{
time_t childTime;
char *shm;
struct thread_data *data;
data = (struct thread_data *)this_data;
pthread_mutex_lock(data->mutex_ptr);
sleep(5);
shm = (char *)shmat(... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
unsigned long int max,t,sum;
void display_time()
{
int seconds;
seconds = time( (time_t *)0 );
printf( "Time = %d",seconds );
}
void *thread1(void *arg)
{
display_time();
unsigned long int n=*( unsigned long int * )arg;
... | 1 |
#include <pthread.h>
pthread_mutex_t number_mutex;
int globalnumber = 5;
void write_globalnumber()
{
printf("1:%d\\n", globalnumber);
pthread_mutex_lock(&number_mutex);
globalnumber++;
pthread_mutex_unlock(&number_mutex);
printf("2:%d\\n", globalnumber);
}
int read_gl... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
long thread_count;
long long n;
double sum;
pthread_mutex_t mutex;
void* Thread_sum(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double Serial_pi(long long n);
int main(int argc, char* argv[]) {
long thr... | 1 |
#include <pthread.h>
int owner=0,waitingWhite=0,waitingBlack=0,usingWhite=0,usingBlack=0;
int lastUseBlack,lastUseWhite;
pthread_mutex_t counter = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t whiteWait = PTHREAD_COND_INITIALIZER;
pthread_cond_t blackWait = PTHREAD_COND_INITIALIZER;
pthread_mutex_t o... | 0 |
#include <pthread.h>
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
union data_pointer_t
{
struct delivery_t *de;
struct new_order_t *no;
struct order_status_t *os;
struct payment_t *pa;
struct stock_level_t *sl;
};
int dump(FILE *fp, int type, void *data)
{
int i;
union data_pointer_t p... | 1 |
#include <pthread.h>
int account = 5000;
int depositamount = 100;
int withdrawamount = 100;
pthread_mutex_t cmutex = PTHREAD_MUTEX_INITIALIZER;
int deposit(int amount)
{
pthread_mutex_lock(&cmutex);
account = account+amount;
printf("Deposit %d\\n", account);
pthread_mutex_unlo... | 0 |
#include <pthread.h>
pthread_mutex_t collatzMutex;
int* initialized;
int* stop;
uint64_t* thisNum;
const uint64_t STEP = 1<<15;
void (*foo)(uint64_t*);
void takeNextNum(uint64_t* numBuf)
{
pthread_mutex_lock(&collatzMutex);
if (*stop)
{
*numBuf = 0;
} else ... | 1 |
#include <pthread.h>
static void *global_top = 0;
pthread_mutex_t global_mutex;
struct head_t {
unsigned int free;
size_t size;
struct head_t *next;
};
void *get_free_block(size_t size);
void *mealloc(size_t size);
void *mecalloc(size_t value, size_t size);
void *merealloc(void *ptr, siz... | 0 |
#include <pthread.h>
struct Node {
Node *next;
int num;
};
struct Queue {
Node *head;
Node *tail;
int queue_size;
pthread_mutex_t Queue_Lock;
pthread_cond_t isEmpty;
};
int initialize_Queue(Queue *queue_ptr)
{
queue_ptr->queue_size = 0;
queue_ptr -> head = 0;
... | 1 |
#include <pthread.h>
pthread_mutex_t s_m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t s_m2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t s_c1 = PTHREAD_COND_INITIALIZER;
const int kNumThread = 3;
const int kLoopCount = 10000000;
void *thread_func( void *arg );
static double toSec(struct timeval ... | 0 |
#include <pthread.h>
struct myStringStruct {
char qstring[128];
};
extern pthread_mutex_t mutex_print;
extern FILE* fileout_qsort;
extern FILE* filein_qsort;
int compare(const void *elem1, const void *elem2)
{
int result;
result = strcmp((*((struct myStringStruct *)elem1)).qstring, ... | 1 |
#include <pthread.h>
int available_resources = 10;;
pthread_mutex_t m1;
int request_resources(int rNum);
int release_resources(int rNum);
void process_manager();
int main(){
pthread_t threads[5];
pthread_mutex_init(&m1, 0);
for(int i = 0; i < 5; i ++){
pthread_create(&threads[i... | 0 |
#include <pthread.h>
static sem_t avvio_processo[3][2];
static sem_t avvio_confezione;
pthread_mutex_t mut;
int contenitore[3];
int nconfezioni=3;
int lap=0;
pthread_cond_t contenitore_non_pieno[3];
void init()
{
sem_init(&avvio_confezione,0,0);
pthread_mutex_init(&mut,0);
for (int i = 0; i <... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int sum=0;
void* p_func(void* p)
{
int i;
pthread_mutex_lock(&mutex);
pthread_mutex_lock(&mutex);
printf("i am child,i have lock\\n" );
pthread_mutex_unlock(&mutex);
pthread_mutex_unlock(&mutex);
pthread_exit(0);
}
int main( )
{
int ret;... | 0 |
#include <pthread.h>
void *sum_array(void *);
void verify();
int sum;
int num[20];
struct tparam
{
int start;
int stop;
};
pthread_mutex_t lock;
int main(int argc, char *argv[])
{
if(argc!=2)
{
printf("format: <prg> [num of threads]\\n");
return;
}
if(atoi(argv[1])>20)
{
printf("err... | 1 |
#include <pthread.h>
pthread_t tid[2];
pthread_mutex_t mutex;
int *array;
float arraytime[2];
int length = 1000000000;
int private_count[2];
int count = 0;
int double_count = 0;
int t = 2;
int max_threads = 0;
void *count3s_thread(void *arg) {
int i;
clock_t t1th, t2th;
int length_per_t... | 0 |
#include <pthread.h>
{
int inicio;
int fin;
char *ruta;
int *arreglo;
} estructura;
pthread_mutex_t mutex;
char *palabrasBuscar[100];
int numeroPalabrasEncontradas[100];
int tamArreglo;
int numero_lineas(char *ruta, int *tam_lineas)
{
if (ruta != 0)
{
FILE* ar = fopen(ruta, "r");
int... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int numberOfThreads;
int matrixSize;
int **matrixA;
int **matrixB;
int **matrixC;
void testArguments(int argc, char **argv);
int ** allocateMatrix(int rowSize, int colSize);
void freeMatrix(int ** matrix, int rowSize);
void imprime_matriz(int **matrix)... | 0 |
#include <pthread.h>
int memory[(2*32+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top;
int index_malloc(){
int curr_alloc_idx = -1;
pthread_mutex_lock(&m);
if(next_alloc_idx+2-1 > (2*32+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx =... | 1 |
#include <pthread.h>
{
int id;
int media;
}Aluno;
int Vec1[250], Vec2[250], Vec3[250], Vec4[250];
Aluno alunos_buffer[50];
int BufferN, contador_global=0;
pthread_mutex_t escrever_buffer;
pthread_mutex_t fim;
pthread_cond_t condicao_buffer_cheio;
void * media( void * arg ){
int i, j, soma... | 0 |
#include <pthread.h>
int NB_WAIT_BARRIER = 0;
pthread_cond_t condBarriere = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void wait_barrier(int n)
{
pthread_mutex_lock(&mutex);
NB_WAIT_BARRIER++;
if(NB_WAIT_BARRIER == n)
pthread_cond_broadcast(&condBarriere);
... | 1 |
#include <pthread.h>
int number;
int consumed;
} Bird;
sem_t wake_father_bird, food_bowl;
int food, times, count;
pthread_mutex_t lock;
void *feed(void*);
void initiate_birds(Bird*);
int main(int argc, char **argv)
{
int i;
pthread_t *bird_threads;
Bird *args;
bird_threads = malloc(... | 0 |
#include <pthread.h>
int map_minerals = 5000;
int minerals = 0;
int n = 0;
int m = 0;
int k = -1;
int command_centers_minerals[12] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
pthread_mutex_t mutex_workers;
pthread_mutex_t mutex_map_minerals;
pthread_mutex_t mutex_minerals;
pthread... | 1 |
#include <pthread.h>
static pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t sleep_mutex = PTHREAD_MUTEX_INITIALIZER;
static void *uwrap_getuid_sync(void *arg)
{
uid_t u;
(void) arg;
pthread_mutex_unlock(&sleep_mutex);
pthread_mutex_lock(&wait_mutex);
u = g... | 0 |
#include <pthread.h>
static int init_malloc(void)
{
if (g_alloc_manager.is_init == TRUE)
return (0);
g_alloc_manager.is_init = TRUE;
pthread_mutex_init(&g_locker, 0);
return (init_alloc_manager());
}
void *malloc(size_t size)
{
void *ptr;
if (size == 0 || init_malloc() != 0)
return (0)... | 1 |
#include <pthread.h>
{
int min;
int max;
int h;
int rank;
double gap;
double * val;
int * vet;
int size;
} composite
;
pthread_mutex_t barrier;
void * binCount ( void * mMh )
{
composite c = * ( ( composite * ) mMh );
int j;
double * val = c.val;
d... | 0 |
#include <pthread.h>
struct Btrace
{
unsigned long pid;
int deadlock;
unsigned char payload[1];
};
enum
{
btsize = 600,
};
static pthread_mutex_t lockdep_lk = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t* held[40][30];
static pthread_mutex_t* lockid[30];
static pthread_t pid_tab[40... | 1 |
#include <pthread.h>
struct msg {
struct msg *m_next;
int id;
};
struct msg *workq;
pthread_cond_t qready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER;
void process_msg(void) {
pthread_t tid = pthread_self();
struct msg *mp;
for( ; ; ) {
pthread_m... | 0 |
#include <pthread.h>
void* write_variables(void*);
void* print_variables(void*);
int var1 = 0;
int var2 = 0;
int running = 1;
pthread_mutex_t lock;
int main() {
if(pthread_mutex_init(&lock,0) != 0) {
printf("Init mutex failed \\n");
return(-1);
}
pthread_t thread1... | 1 |
#include <pthread.h>
struct pid_data{
pthread_mutex_t pid_mutex;
pid_t pid;
};
char buffer[1500];
char receive[1500];
int message_client(pid_t pid);
int main(int argc, char *argv[]) {
printf("Welcome to the QNX Momentics IDE\\n");
int f_desc = shm_open("/dev/shmem/sharedpid", O_RDWR,... | 0 |
#include <pthread.h>
sem_t espera_vaga, espera_dado;
pthread_mutex_t mutex;
int cont = 0, v[5] = {0, 0, 0, 0, 0};
void exibir();
void *insereItem(void *args);
void *removeItem(void *args);
int main() {
pthread_t produtor, consumidor;
int *nexecProd = malloc(sizeof(int));
int *nexecC... | 1 |
#include <pthread.h>
int main()
{
void *thread_join_status;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
pthread_mutex_init(&Motor_info_mutex, 0);
pthread_mutex_init(&MC_faults_mutex, 0);
pthread_mutex_lock(&Motor_inf... | 0 |
#include <pthread.h>
void initProducteur(){
nbC1 = 3*10;
nbC2 = 3*10;
nbC3 = 1*4000;
nbC4 = 2*10;
continuerProducteur = 1;
}
int resteTIlComposant(){
if(nbC1 == 0 && nbC2 == 0 && nbC3 == 0 && nbC4 == 0)
return 0;
return 1;
}
int recupererUnComposant(){
... | 1 |
#include <pthread.h>
static int i = 0;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t notfull = PTHREAD_COND_INITIALIZER;
static pthread_cond_t notempty = PTHREAD_COND_INITIALIZER;
void clean_func(void *arg)
{
pthread_mutex_unlock(&mutex);
}
void* producer... | 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>
double pintegral(double (*f)(double), double a, double b,
long n, int k, int tasks);
long n;
int p;
double resultat;
pthread_mutex_t my_mutex;
double f(double x) {
return sqrt(1.0-x*x);
}
void * calculate(void *parm) {
int me=*((int *)parm);
double x=pintegral(f, ... | 0 |
#include <pthread.h>
int read_cnt = 0, total_cnt = 0;
pthread_mutex_t read_mutex, access_mutex;
void *write_handler(void *arg) {
pthread_detach(pthread_self());
pthread_mutex_lock(&access_mutex);
++total_cnt;
printf("A writer comes in! Total persons: %d\\n", total_cnt);
... | 1 |
#include <pthread.h>
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *thread2 (void *arg);
void *thread3 (void *arg);
void *thread (void *arg)
{
long j = (long) arg;
int i, ret;
pthread_t th[3];
printf ("t%ld: running!\\n", j);
for (i = 0; i < 3; i++)
{
ret = pthread_... | 0 |
#include <pthread.h>
const int MAX_THREADS = 64;
int thread_count, message_avaliable, consumer;
pthread_mutex_t mutex;
void Usage(char* prog_name);
void *Hello(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
thread_count = 2;
message_ava... | 1 |
#include <pthread.h>
void customer(int cust_num) {
int i,j;
printf("%d started\\n",cust_num);
int request[NUMBER_OF_RESOURCES];
for(j = 0;j<NUMBER_OF_RESOURCES;j++)
request[j] = need[cust_num][j];
int done = 1,todo = 0;
while(1) {
pthread_mutex_lock(&lock);
for(i = 0;i<NUMBER_OF_CUSTO... | 0 |
#include <pthread.h>
void RainGet(void) {
static struct timeval tPreviousReading = { 0, 0 };
struct timeval tNow,
tInterval;
char *pRain = malloc(BB_LOGBUFFERSIZE);
gettimeofday(&tNow, 0);
timersub(&tNow, &tPreviousReading, &tInterval);
writeLog(BB_LOGLEVELHIGH, "Rain: Processin... | 1 |
#include <pthread.h>
double *matrix;
double *vector;
double *result;
pthread_t thread[3];
pthread_mutex_t mutex;
int thread_id[3];
void printf_table(double *table, int size) {
int i;
printf("Size: %d\\n\\n", size);
for (i = 0; i < size; ++i) {
printf("%lf ", table[i]);
if ((i + ... | 0 |
#include <pthread.h>
int minutes;
int seconds;
time_t curr_sec;
pthread_t thread;
}* Gametime;
static void clock_draw_image(Gametime t);
static void clock_clear_image(Gametime t);
static time_t clock_get_current_time();
static void clock_countdown(Gametime t, time_t passed_se... | 1 |
#include <pthread.h>
int no;
char str[10];
}Arg;
pthread_mutex_t mutex;
pthread_cond_t cond;
int g_flag=0;
pthread_t thread_1,thread_2;
void* thread1(void* arg)
{
printf("%s:I am thread %d\\n",(*((Arg*)arg)).str,(*((Arg*)arg)).no);
pthread_mutex_lock(&mutex);
g_flag=1;
p... | 0 |
#include <pthread.h>
int num;
pthread_mutex_t mutex_num;
void *run(void *args)
{
while (num < 100)
{
pthread_mutex_lock(&mutex_num);
if (num < 100)
{
printf("subthread %d: %d\\r\\n", (int)args, ++num);
}
pthread_mutex_unlock(&mutex_num);
}
printf("subthread finished!\\r\\n... | 1 |
#include <pthread.h>
int nombres[100];
int somme;
pthread_mutex_t lock;
sem_t sema;
char c;
}tabCritique;
void tabInit(tabCritique* t)
{
pthread_mutex_init(&(t->lock), 0);
sem_init(&(t->sema),0,0);
t->somme = 0;
}
void* filtre(void* arg)
{
tabCritique *t = (tabCritique*) arg... | 0 |
#include <pthread.h>
long long g_sum = 0;
int g_min = 32767;
int g_minX = -1;
int g_minY = -1;
int g_max = INT_MIN;
int g_maxX = -1;
int g_maxY = -1;
pthread_mutex_t dataLock;
int g_count = 0;
int g_size;
pthread_mutex_t countLock;
int numWorkers;
double startTime, endTime;
int size, strip... | 1 |
#include <pthread.h>
static size_t used_memory = 0;
static int pmalloc_thread_safe = 0;
pthread_mutex_t used_memory_mutex = PTHREAD_MUTEX_INITIALIZER;
static void
pmalloc_default_oom(size_t size){
fprintf(stderr , "pmalloc : Out of memory trying to allocate %zu bytes\\n", size);
fflush(std... | 0 |
#include <pthread.h>
static pthread_cond_t cond1;
static pthread_cond_t cond2;
static pthread_mutex_t test_lock = PTHREAD_MUTEX_INITIALIZER;
static void *
thread1_func(void* arg)
{
printf("Thread 1 (arg=%d tid=%d) entered.\\n", (unsigned)arg, gettid());
printf("1 waiting for cond1\\n");
... | 1 |
#include <pthread.h>
pthread_mutex_t *mtx = 0;
int main(int argc, char*argv[])
{
if (argc != 2 || (atoi(argv[1]) != PTHREAD_PROCESS_SHARED && atoi(argv[1])!= PTHREAD_PROCESS_PRIVATE))
{
printf("Usage: %s <mutex shared or private >\\n", argv[0]);
exit(1);
}
if (atoi(argv[1]) ... | 0 |
#include <pthread.h>
{
int id;
int nproc;
} parm;
char message[100];
pthread_mutex_t msg_mutex = PTHREAD_MUTEX_INITIALIZER;
int token = 0;
void* greeting(void *arg)
{
parm *p = (parm *) arg;
int id = p->id;
int i;
if (id != 0)
{
while (1)
{
pthread_mutex_lock(&msg_mutex);
if (t... | 1 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
struct foo *f_next;
int f_id;
};
struct foo *
foo_alloc(void)
{
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) !... | 0 |
#include <pthread.h>
static struct subscription** subscriptions = 0;
static void subscription_create(struct address* address, struct channel* channel) {
struct subscription* subscription = malloc(sizeof(struct subscription));
subscription->address = address;
*subscriptions = subsc... | 1 |
#include <pthread.h>
{
int data;
struct node *next;
}node_t;
static pthread_key_t thread_log_key;
{
node_t *top;
}stack_t;
stack_t S;
void write_to_thread_log (const char* message)
{
FILE* thread_log = (FILE*) pthread_getspecific (thread_log_key);
fprintf (thread_log, "%s\\t",message);
}... | 0 |
#include <pthread.h>
char g_fullLogPath[128] = { 0 };
char g_exeName[128] = { 0 };
int g_catchCount = 0;
int g_fd;
char *g_cache;
int g_curCacheSize = 0;
int g_localLogIsInit = 0;
pthread_mutex_t g_mutex;
int initLocalLog(const char* pExeName)
{
char* fnspi = strrchr(pExeName, '/');
if (fn... | 1 |
#include <pthread.h>
pthread_t command_thread;
pthread_t data_thread[3];
pthread_t status_thread;
pthread_t server_thread;
pthread_attr_t command_attr;
pthread_attr_t data_attr[3];
pthread_attr_t status_attr;
pthread_attr_t server_attr;
pthread_mutex_t command_mutex;
pthread_mutex_t data_mutex;
... | 0 |
#include <pthread.h>
int g_buffer[10];
unsigned int in = 0;
unsigned int out = 0;
unsigned int produce_id = 0;
unsigned int consume_id = 0;
sem_t g_sem_full;
sem_t g_sem_empty;
pthread_mutex_t g_mutex;
pthread_t g_thread[5 +1];
void* consume(void *arg)
{
int num = *((int*)arg);
free(arg);
... | 1 |
#include <pthread.h>
int memory[(2*32+1)];
int next_alloc_idx = 1;
pthread_mutex_t m;
int top;
int index_malloc(){
int curr_alloc_idx = -1;
pthread_mutex_lock(&m);
if(next_alloc_idx+2-1 > (2*32+1)){
pthread_mutex_unlock(&m);
curr_alloc_idx = 0;
}else{
curr_alloc_idx = n... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cond_reset=PTHREAD_COND_INITIALIZER;
int x=0;
void * writer(void* arg){
int numWriter = *(int*) arg;
while(1){
pthread_mutex_lock(&m);
printf(" incr%d: before x=%d\\n",numWriter,x);
x+=1;
printf(" after x=%... | 1 |
#include <pthread.h>
int thread_count;
int flag = 0;
double sum = 0, my_sum = 0;
long long n =100000;
pthread_mutex_t mutex;
void* Thread_sum(void* rank){
long my_rank = (long) rank;
double factor;
long long i;
long long my_n = n/thread_count;
long long my_first_i = my_n * my_rank;
... | 0 |
#include <pthread.h>
struct DataFlag* new_DataFlag();
struct DataFlag* new_EmptyDataFlag();
void dest_DataFlag(struct DataFlag*this);
int DataFlag_set(struct DataFlag *this, char* dataToWrite);
int DataFlag_waitAndSet(struct DataFlag *this, char* dataToWrite);
char* DataFlag_reset(struct D... | 1 |
#include <pthread.h>
struct bbsem {
pthread_mutex_t mutex;
int value;
};
struct bbsem *
bbseminit(int val)
{
struct bbsem *tmp;
tmp = malloc(sizeof(*tmp));
if (tmp == 0)
return(0);
pthread_mutex_init(&tmp->mutex, 0);
tmp->value = val;
return(tmp);
}
void
bbsemdestroy(struct bbsem *bp)
... | 0 |
#include <pthread.h>
static void *
thread(void *arg)
{
pthread_mutex_t *mtx = arg;
if (pthread_mutex_isowned_np(mtx) != 0) {
printf("pthread_mutex_isowned_np() returned non-zero\\n"
"for a mutex held by another thread\\n");
exit(1);
}
return (0);
}
int
main(int argc, char *argv[])
... | 1 |
#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(e... | 0 |
#include <pthread.h>extern void __VERIFIER_error();
extern void __VERIFIER_error(void);
extern void __VERIFIER_assume(int);
void __VERIFIER_assert(int cond)
{
if (!cond)
{
ERROR:
__VERIFIER_error();
}
return;
}
void __VERIFIER_atomic_assert(int cond)
{
if (!cond)
{
ERRO... | 1 |
#include <pthread.h>
int NUM_THREADS;
long int chunk_end;
long int chunk_init;
pthread_mutex_t lock_x;
void swapM(long int* a, long int* b)
{
long int aux;
aux = *a;
*a = *b;
*b = aux;
}
long int divideM(long int *vec, int left, int right)
{
int i, j;
i = left;
for (... | 0 |
#include <pthread.h>
sem_t c[5];
pthread_mutex_t lock;
void* func(void *y)
{
int valuel;
int valuer;
int l = (int)y;
int r;
sem_getvalue(&c[l], &valuel);
r = (l+1)%5;
sem_getvalue(&c[r], &valuer);
printf("\\nThe value of left is %d", valuel);
printf("\\nThe value of righ... | 1 |
#include <pthread.h>
struct increment {
pthread_mutex_t lock;
int record[100000];
int putn;
int value;
} increment = {
.putn = 0,
.value = 0,
};
int consumer_wait(int i)
{
pthread_mutex_lock(&increment.lock);
if (increment.putn < i) {
pthread_mutex_unlock(&increment.lock);
return i;... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int sum=0;
void* p_func(void* p)
{
int ret;
ret=pthread_mutex_lock(&mutex);
printf( "pthread_mutex_lock ret=%d\\n" ,ret);
ret=pthread_mutex_lock(&mutex);
if(0!=ret)
{
printf("pthread_mutex_lock2 ret=%d\\n" ,ret);
}
printf("i am child... | 1 |
#include <pthread.h>
bool key_waiting = 0;
uint8_t key_received;
pthread_cond_t key_cond;
pthread_mutex_t key_mutex;
pthread_t key_thread_handle;
void key_mode(int dir)
{
static struct termios oldt, newt;
if (dir == 1) {
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~( ICA... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int threads = 0;
void *PrintHello(void *threadid) {
long tid, i;
tid = (long)threadid;
usleep(500000);
printf("Thread %ld tentando obter mutex!\\n", tid);
... | 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 <= 10000000; i++) {
pthread_mutex_lock(&the_mutex);
while (buffer != 0)
pthread_cond_wait(&condp, &the_mutex);
... | 0 |
#include <pthread.h>
void *ihome_write ( void *prm)
{
unsigned int l_indx, no_message_to_display ;
while (1) {
for (l_indx = 0; l_indx < nb_Of_Output_Elements; l_indx++)
{
bcm2835_gpio_write(pins_out[l_indx], ((outputs_Array_Of_Elements[l_indx].value == TRUE ) ? HIGH : LOW ));... | 1 |
#include <pthread.h>
pthread_mutex_t forks[5];
void *philosopher(void* philo_id){
int *id = (int*) philo_id;
while(1){
if(*id == 0){
pthread_mutex_lock(&forks[0]);
printf("Philosopher %d have taken fork %d \\n", *id,*id);
pthread_mutex_lock(&forks[4]);
printf("Philosopher %d ha... | 0 |
#include <pthread.h>
int resourceNum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t full_cond = PTHREAD_COND_INITIALIZER, empty_cond = PTHREAD_COND_INITIALIZER;
void *ProducerFunc(void *pNum)
{
int num = (int)(pNum);
while(1)
{
sleep(3);
pt... | 1 |
#include <pthread.h>
char msg[256];
int fd;
pthread_mutex_t mutex;
int ReadingThreads()
{
printf("\\n\\n********************\\nStarting device reading by TaskID: %d \\nReading from the device...\\n",pthread_self());
pthread_mutex_lock(&mutex);
int ret = read(fd, msg, 256);
printf("The re... | 0 |
#include <pthread.h>
pthread_barrier_t barrier;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void* next_step(void* arg) {
int i, j;
struct st_data* my_data=(struct st_data*)arg;
int master=0;
if(my_data->from_i==0) master=1;
while(1) {
int best_i=-1, best_j=-1, best=INFINITE;
i... | 1 |
#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 *p... | 0 |
#include <pthread.h>
extern char target_message[100];
extern int target_message_length;
extern pthread_mutex_t targ_msg_mutex;
static int begin_request_handler(struct mg_connection *conn) {
mg_printf(conn,
"HTTP/1.1 200 OK\\r\\n"
"Content-Type: text/plain... | 1 |
#include <pthread.h>
pthread_t pthread[100000];
volatile int integers[100000];
pthread_mutex_t verrou;
pthread_cond_t condCrossedFirst;
void* barrer(void* args)
{
int entier = *((int*) args);
int index = entier;
int fst = 1;
while(index<100000)
{
index += entier;
if(index >= 100000) b... | 0 |
#include <pthread.h>
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
{
struct _node* _next;
int data;
}_node,*_node_p,**_node_pp;
_node_p alloc(int data)
{
_node_p _node=(_node_p)malloc(sizeof(data));
if(_node==0)
{
perror("malloc");
exit (0);... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_norm = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t CurRow_norm = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex_Row = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_threshold_cv = PTHREAD_COND_INITIALIZER;
pthread_mutex_t *mutex_Res;
double NormRo... | 0 |
#include <pthread.h>
struct t_WorkGroup_Type {
pthread_mutex_t mutex;
pthread_cond_t cond;
int ready;
} *t_workgroup;
void* t_pipeline(void *input);
void jacobi7_4(const int nx,const int ny,int nz,const double alpha,double * A0,const int timesteps,const double * B,const int ldb,double * An... | 1 |
#include <pthread.h>
pthread_mutex_t mux = PTHREAD_MUTEX_INITIALIZER;
struct hostent *
nw_gethostbyname(const char *name, int *error)
{
int i;
char *foo;
struct hostent *ret=0, *st=0;
sigset_t newmask, oldmask;
ret = (struct hostent *) calloc(1, sizeof(struct hostent));
... | 0 |
#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)
{
int loop = (int)(*((int*)arg));
while(loop-... | 1 |
#include <pthread.h>
struct foo *fh[29];
pthread_mutex_t hashlock = PTHREAD_MUTEX_INITIALIZER;
struct foo {
int f_count;
pthread_mutex_t f_lock;
int f_id;
struct foo *f_next;
};
struct foo * foo_alloc(int id) {
struct foo *fp;
int idx;
if ((fp = malloc(sizeof(struct foo))) != 0) {
... | 0 |
#include <pthread.h>
int gt_create_thread(pthread_t *threadid,void *(*start_routine)(void *), void * arg)
{
int rc;
pthread_attr_t attr,*at=0;
if(threadid==0)
return -1;
memset((void*)&attr,0,sizeof(pthread_attr_t));
rc=pthread_attr_init(&attr);
if(rc<0)
at=0;
else
at=&attr;
... | 1 |
#include <pthread.h>
int total_wc;
pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
int main(int ac, char *av[]){
pthread_t t1, t2;
void *count_words(void*);
if(ac != 3){
fprintf(stderr, "usage: %s file1 file2\\n", av[0]);
exit(1);
}
total_wc = 0;
... | 0 |
#include <pthread.h>
pthread_cond_t cond_empty, cond_full;
pthread_mutex_t mutex;
int count = 0, in = 0, out = 0;
int contadorConsumidor = 0;
int buffer[3];
void *produtor(void *arg)
{
while (1)
{
pthread_mutex_lock(&mutex);
while (count == 3)
pthread_cond_wait(... | 1 |
#include <pthread.h>
long double sum = 0;
pthread_mutex_t mutex;
void *sumfun1(void *p) {
int i;
long double local_sum = 0;
for(i = 0; i < 10000000/2; i++) {
local_sum += sin(i) * sin(i) + cos(i) * cos(i);
}
pthread_mutex_lock(&mutex);
sum += local_sum;
pthread_mutex_unlock(&mutex)... | 0 |
#include <pthread.h>
char* table;
size_t w;
int n;
int c;
int max;
pthread_mutex_t mutex;
} mt_record_struct;
mt_record_struct* mtrs;
static int _N_TABLES=0;
static double _fill_ratio = 0.8;
static int init_table(int index, size_t width, int capacity, int max_capacity);
void free... | 1 |
#include <pthread.h>
long long sum = 0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void* counting_function(void *ptr)
{
int offset =*(int *) ptr;
for(int i=0; i<500000; i++)
{
pthread_mutex_lock(&mutex);
sum=sum+offset;
pthread_mutex_unlock(&mutex);
}
pthread_exit(0... | 0 |
#include <pthread.h>
void* busy_wait_calculation(void* rank);
void* mutex_calculation(void* rank);
void* semaphore_calculation(void* rank);
double f(double x);
const int MAX_THREADS = 8;
long long a, b, n;
long flag;
double h, approximation;
pthread_mutex_t mutex;
sem_t sema;
int main(v... | 1 |
#include <pthread.h>
int makethread(void* (*fn)(void*), void* arg)
{
int err;
pthread_t tid;
pthread_attr_t attr;
err = pthread_attr_init(&attr);
if (err != 0)
return err;
err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (err == 0)
... | 0 |
#include <pthread.h>
int start;
int end;
int *arr;
int size;
} thread_data_t;
void serial_merge(int *, int, int, int, int);
int partition(int *, int, int);
unsigned int ONE = 1;
int thread_count = 0;
pthread_mutex_t mutex;
void *thread_routine_split(void *arg) {
pthread_mu... | 1 |
#include <pthread.h>
pthread_t tids[5];
char init_flag = 0;
pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER;
char wait_flag = 0;
pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait_cond = PTHREAD_COND_INITIAL... | 0 |
#include <pthread.h>
pthread_t thread[3];
pthread_mutex_t mut;
int number=0, i, j;
void *thread0()
{
printf ("thread0 : I'm thread 0\\n");
for (i = 0; i < 10; i++)
{
number++;
printf("thread0 : number = %d\\n",number);
}
... | 1 |
#include <pthread.h>
void stack_init(stack_t* stack) {
stack->top = -1;
pthread_mutex_init(&stack->lock,0);
stack->condVar = 0;
}
int stack_empty(stack_t* stack) {
while(stack->condVar) { printf("Empty venter\\n");}
return stack->top == -1;
}
void* stack_top(stack_t* stack) {
while(s... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.