text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct proc {
struct proc *link;
int buf[4];
int N;
pthread_mutex_t mux;
pthread_cond_t ok_to_write, ok_to_read;
pthread_t thread;
}
*proc_init(struct proc *parent, void *(*routine)(void*))
{
struct proc *cb = malloc(sizeof(struct proc));
a... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t db_lleno;
pthread_cond_t db_vacio;
int concurrente_init()
{
int ret;
ret = db_banco_init();
return ret;
}
int concurrente_destroy()
{
int ret;
ret = db_banco_destroy();
return ret;
}
int concurrente_crear_cuenta(... | 0 |
#include <pthread.h>
int buffer[5];
int in;
int out;
sem_t empty;
sem_t full;
pthread_mutex_t mutex;
} t_sync;
t_sync shared;
void *Producer(void *arg) {
int i, item, index;
index = (intptr_t)arg;
for(i = 0; i < 4; i++) {
item = i;
sem_wait(&shared.empty);
pthread_... | 1 |
#include <pthread.h>
pthread_mutex_t count_lock=PTHREAD_MUTEX_INITIALIZER;
int count=0;
void r1(char *fname, int x, char **bufp)
{
double temp;
int local_count=0;
int fd;
for (local_count = 0; local_count < 1000; local_count++) {
pthread_mutex_lock(&count_lock);
te... | 0 |
#include <pthread.h>
pthread_mutex_t barberReady, accessSeats;
sem_t custReady;
int freeSeats = 5;
void* barber(void * arg){
while(1){
sem_wait(&custReady);
pthread_mutex_lock(&accessSeats);
freeSeats++;
pthread_mutex_unlock(&barberReady);
pthread_mutex_unlock(&accessSe... | 1 |
#include <pthread.h>
int main(int argc, char const *argv[])
{
int i;
PORT = atoi(argv[1]);
if ((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1){
printf("ERRO NA CRICAO DO SOCKET");
return 1;
}
if(configurarMestre()==1)
return 1;
printf("Escravo Inicializado\\n");
if(recvfrom(... | 0 |
#include <pthread.h>
int buffer[20];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;
void put(int value) {
buffer[fill_ptr] = value;
fill_ptr = (fill_ptr + 1) % 20;
count++;
}
int get() {
int tmp = buffer[use_ptr];
use_ptr = (use_ptr + 1) % 20;
count--;
return tmp;
}
sem_t ... | 1 |
#include <pthread.h>
int nitems;
int buff[ 100000];
struct{
pthread_mutex_t mutex;
int nput;
int nval;
} put = {
PTHREAD_MUTEX_INITIALIZER
};
struct{
pthread_mutex_t mutex;
pthread_cond_t cond;
int nready;
} nready = {
PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER
};
v... | 0 |
#include <pthread.h>
static struct scap_tasks * scap_tasks = 0;
void scapassess_process_init()
{
assert ( scap_tasks == 0 );
scap_tasks = rscap_alloc(sizeof ( *scap_tasks ));
scap_tasks->tasks = 0;
scap_tasks->task_id_counter = 1;
pthread_mutex_init(&scap_tasks->mx, 0);
}
struct scap_ta... | 1 |
#include <pthread.h>
int MAX = 20001;
int p_sleep;
int c_sleep;
int producer_count;
int consumer_count;
int item_p;
int item_c;
bool isproducersleeping = 0;
bool isconsumersleeping = 0;
pthread_mutex_t lock;
pthread_cond_t cond_consume;
pthread_cond_t cond_produce;
struct Queue
{
int fr... | 0 |
#include <pthread.h>
struct queue_context {
int head;
int tail;
int cap;
struct queue_message* message;
int threshold;
int overload;
};
struct message_queue {
struct queue_context queue[2];
pthread_mutex_t lock;
int reader;
int writer;
};
struct message_queue*
queue_create() {
struc... | 1 |
#include <pthread.h>
pthread_spinlock_t lock;
pthread_mutex_t mutex;
void echo_input() {
char ch;
ch = getchar();
fflush( stdin );
while( getchar() != '\\n' );
printf( "You typed: %c\\n", ch );
}
void *input_with_spinlock( void *data ) {
pthread_spin_lock( &lock );
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_print = PTHREAD_MUTEX_INITIALIZER;
void print_time_error(void)
{
char buffer[30];
time_t current_time;
struct tm *time_struct;
current_time = time(0);
time_struct = localtime(¤t_time);
if (time_struct == 0)
{
... | 1 |
#include <pthread.h>
pthread_t pGIDSMulticastReader;
void fnStartGIDS( void )
{
pthread_attr_t paGIDSMulticastReader;
pthread_attr_init( &paGIDSMulticastReader);
pthread_attr_setdetachstate( &paGIDSMulticastReader, PTHREAD_CREATE_DETACHED );
pthread_create( &pGIDSMulticastReader, &paGIDSMulti... | 0 |
#include <pthread.h>
int timestamp()
{
struct timeval val;
gettimeofday(&val, 0);
return val.tv_sec * 1000 + val.tv_usec / 1000;
}
int num_of_thread = 1;
int sum = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* foo(void* p)
{
int local_sum = 0;
for (int i = 0 ; i < 50000... | 1 |
#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 thread_count; int total_ops;
double insert_percent; double search_percent; double delete_percent;
pthread_rwlock_t rwlock;
pthread_mutex_t count... | 0 |
#include <pthread.h>
struct jc_type_file_rand_abort {
struct jc_type_file_comm_hash *comm_hash;
};
static struct jc_type_file_rand_abort global_abort;
static int jc_type_file_rand_abort_init(
struct jc_comm *jcc
)
{
return global_abort.comm_hash->init(global_abort.comm_hash, jcc);
}
static... | 1 |
#include <pthread.h>
extern char **environ;
pthread_mutex_t 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>
struct mt
{
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(void)
{
int i;
struct mt *mm;
pid_t pid;
mm=mmap(0,sizeof(*mm),PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);
memset(mm,0,sizeof(*mm));
pthread_mutexat... | 1 |
#include <pthread.h>
int q[3];
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 < 3)
... | 0 |
#include <pthread.h>
pthread_mutex_t logmutex = PTHREAD_MUTEX_INITIALIZER;
void julog(const char *fmt, ...)
{
struct timeval tv;
gettimeofday(&tv, 0);
va_list args;
char buf[1024] = {0};
pthread_mutex_lock(&logmutex);
__builtin_va_start((args));
vsnprintf(buf, sizeof(buf) -... | 1 |
#include <pthread.h>
int lca_ind,check[20]={0},tree[20];
pthread_mutex_t mutex;
void *lca(void *ind)
{
int p=(int)ind;
while(1)
{
pthread_mutex_lock(&mutex);
if(check[p]==1)
{
lca_ind = p;
pthread_mutex_unlock(&mutex);
return ;
}
check[p]=1;
p/=2;
pthread_mutex_unlock(... | 0 |
#include <pthread.h>
pthread_mutex_t mut=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
int count=1,Num_Threads;
int* ready_threads;
void* func(void * arg){
int ID=*(int*)arg,i;
count+=1;
sleep(count);
printf("thread %d ready\\n",ID);
ready_threads[ID]=-1;
pthread_m... | 1 |
#include <pthread.h>
int thread_count;
int message_available;
int consumer;
char* message;
pthread_mutex_t mutex;
void *Hello(void* rank);
int main(int argc, char* argv[]) {
long thread;
pthread_t* thread_handles;
thread_count = strtol(argv[1], 0, 10);
message_available = 0;
... | 0 |
#include <pthread.h>
int state = 0;
int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t conc, conp;
int flag = 0;
FILE *input_fp;
FILE *output_fp;
int rPos = 0;
int wPos = 0;
short value;
char ts[13];
} SampleType;
SampleType buf[11];
char ts[13]... | 1 |
#include <pthread.h>
static int nThreads=0;
void mai_set_number_threads(int nthreads)
{
pthread_mutex_lock(&(sinfo.lock_place));
sinfo.nthreads = nthreads;
pthread_mutex_unlock(&(sinfo.lock_place));
}
int get_number_threads()
{
char command[120];
command[0]='\\0';
char tem... | 0 |
#include <pthread.h>
struct arg_struct{
int id_init;
int id_fin;
int thread_id;
};
struct anagram{
char word1[50];
char word2[50];
}anagrams[30000];
char words[120000][50];
int anagrams_id = 0;
pthread_mutex_t lock;
int check_anagram(char a[], char b[])
{
int first[26] = {0},... | 1 |
#include <pthread.h>
int sum;
int id;
char message[50];
pthread_t thread;
} MThread;
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_function (void *arg) {
MThread *thread = arg;
int i;
sleep(rand());
pthread_mutex_lock( &condition_mutex );
for(i = 0; ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t lock1, unlock1;
sem_t full, empty;
int stack[3];
int cnt;
pthread_t pid,cid;
pthread_attr_t attr;
void *producer(void *param);
void *consumer(void *param);
void initializeData()
{
pthread_mutex_init(&mutex, 0);
sem_init(&full, ... | 1 |
#include <pthread.h>
int sum;
int cpt=0;
pthread_mutex_t mutex, mutex_fin;
pthread_cond_t cond_print, cond_fin;
int fin_flag=0, print_flag=0;
void * thread_rand(void * i){
int random_val = (int) (10*((double)rand())/ 32767);
printf("tid: %u;\\trandom_val: %d\\n",(unsigned int)pthread_se... | 0 |
#include <pthread.h>
void * mirroringPI (void * arg) {
uint8_t buffer_send_receive[DATA_SIZE_MAX];
assert (SPI_init() >=0);
init_data();
clock_gettime(CLOCK_REALTIME, &T1);
while (1) {
waitPeriod (1000000, &T1, &T2);
clock_gettime(CLOCK_REALTIME, &T1); ;
... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=... | 0 |
#include <pthread.h>
int readercount, writercount;
pthread_mutex_t rdcnt, wrcnt, mutex;
pthread_mutex_t r, w;
struct reader_writer {
long tid;
double sleep_time;
};
struct timeval start;
void *writer(void *arg)
{
struct reader_writer *rw_data = (struct reader_writer*) arg;
pthre... | 1 |
#include <pthread.h>
float pi_seqential = 0, pi_parallel = 0;
long num_threads = 0, parallel_hits = 0;
pthread_mutex_t mutex;
void execute_sequential_version(void);
void handle_sequential_version(void);
void *run(void *);
void execute_parallel_version(void);
void handle_parallel_version(void);
... | 0 |
#include <pthread.h>
pthread_mutex_t amutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t got_request = PTHREAD_COND_INITIALIZER;
void *threadFunc(void *arg){
char *str;
str = (char*)arg;
pthread_mutex_lock(&amutex);
int rc = pthread_cond_wait(&got_request, &amutex);
pthread_mutex_unlock(&... | 1 |
#include <pthread.h>
int Graph[100][100];
int dist[100][100];
void initMatrices()
{
int n,m;
for(n=0;n<101;n++)
for(m=0;m<101;m++)
{
Graph[n][m]=-1;
if(n==m) dist[n][m]=0;
else dist[n][m] = -1;
}
}
pthread_mutex_t mutex_lock;
pthread_cond_t condition_var;
int readCoun... | 0 |
#include <pthread.h>
pthread_mutex_t m;
struct param{
char *frase;
int numero;
};
void hiloMensaje(struct param *mensa){
printf("%s %d \\n", mensa->frase, mensa->numero);
}
void tablas(int num){
int i=0;
pthread_mutex_lock(&m);
while(i<6)
{
printf("%d * %d = %d \\n",num,i,(i*i));
i++... | 1 |
#include <pthread.h>
static pthread_mutex_t *lock_cs;
static long *lock_count;
static void SSL_pthreads_locking_callback(int mode, int type, char *file, int line)
{
if(mode & CRYPTO_LOCK)
{
pthread_mutex_lock(&(lock_cs[type]));
lock_count[type]++;
} else
pthread_mutex_unlock(&(l... | 0 |
#include <pthread.h>
struct thread_time_ops time_thread[50];
int nrOfTokens;
pthread_mutex_t lock;
char rw;
double getRealTime(){
struct timeval timecheck;
gettimeofday(&timecheck,0);
return (double)timecheck.tv_sec *1000 + (double)timecheck.tv_usec/1000;
}
char* getFileName(int id... | 1 |
#include <pthread.h>
enum {
TXCRC1, TXCRC2, TXTAIL, TXDONE, TXIDLE,
TXRECV,
TXPRE1, TXPRE2, TXPRE3, TXSYN1, TXSYN2,
};
static uint8_t nodeid;
static uint8_t group;
static volatile uint8_t rxfill;
static volatile int8_t rxstate;
volatile uint16_t rf12_crc;
volatile uint8_t rf12_... | 0 |
#include <pthread.h>
double intervalWidth, intervalMidPoint, area = 0.0;
int numberOfIntervals;
pthread_mutex_t area_mutex = PTHREAD_MUTEX_INITIALIZER;
int interval, iCount;
double myArea = 0.0, result;
void myPartOfCalc(int myID){
int myInterval;
double myIntervalMidPoint;
myArea = ... | 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 arr[100];
pthread_mutex_t lock;
pthread_t* tid1[10];
pthread_t* tid2[10];
pthread_t* printThread;
FILE *fp;
int getRandom(int, int);
void* putsData(void*);
void* getsData(void*);
void* print(void* size);
void inputArguments(int*, int*);
void createProducerThrea... | 1 |
#include <pthread.h>
pthread_mutex_t readlock;
pthread_mutex_t writelock;
int read_cnt=0;
char buf[100];
void reader(void* arg)
{
pthread_mutex_lock(&readlock);
if(++read_cnt==1)
pthread_mutex_lock(&writelock);
pthread_mutex_unlock(&readlock);
printf("%d读者读取内容：%s\\n",pthread_self(),buf);
pth... | 0 |
#include <pthread.h>
pthread_cond_t condition;
pthread_mutex_t mutex;
int number, turn = 1, outExit = 0;
void* input(void *arg) {
do {
if(turn) {
pthread_mutex_lock(&mutex);
printf("Unesite jedan ceo broj:\\n");
scanf("%d", &number);
turn = 0;
if(number < 0) {
outExit = 1;... | 1 |
#include <pthread.h>
struct args {
int ** valoresGrafo;
int numVertices;
int instancia;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int result[10000];
int main(int argc, char *argv[]) {
char * inputFileName = argv[1];
char * outputFileName = argv[2];
int ... | 0 |
#include <pthread.h>
int PBSD_gpu_put(
int c,
char *node,
char *gpuid,
int gpumode,
int reset_perm,
int reset_vol,
char *extend)
{
int sock;
int rc = 0;
struct tcp_chan *chan = 0;
sock = connection[c].ch_socket;
if ((chan = DIS_tcp_setup(sock)) == 0)
{
re... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int id;
} parm;
int the_answer = 0;
void *bad_thread(void *args)
{
int id;
parm *p;
p = (parm *)args;
id = p->id;
int i, tmp;
for (i=0; i<(id+1)*100000; i++)
tmp = i % 10;
pthread_mutex_lock(&lock);
the_answer += tmp;
... | 0 |
#include <pthread.h>
bool queue_init(struct _queue *queue, size_t bufsize) {
memset(queue, 0, sizeof(struct _queue));
if (pthread_mutex_init(&queue->lock, 0) != 0)
goto queue_init_err0;
queue->size = bufsize;
queue->buffer = malloc(queue->size);
if (queue->buffer == 0)
g... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
sem_t full, empty;
buffer_item buffer[5];
int counter;
pthread_t tid;
pthread_attr_t attr;
void *producer(void *param);
void *consumer(void *param);
void initializeData() {
pthread_mutex_init(&mutex, 0);
sem_init(&full, 0,... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *func1(void *arg)
{
pthread_mutex_lock(&mutex);
int *a = (int *)arg;
printf("pthread%d start\\n", *a);
int i = 0;
for(;i<10;i++)
{
printf("pthread%d is running\\n", *a);
sleep(1);
}
printf("pthread end\\n");
... | 1 |
#include <pthread.h>
int block;
int busy = 0;
int inode = 0;
pthread_mutex_t m_inode;
pthread_mutex_t m_busy;
void *allocator(void * arg){
pthread_mutex_lock(&m_inode);
if(inode == 0){
pthread_mutex_lock(&m_busy);
busy = 1;
pthread_mutex_unlock(&m_busy);
inode = 1;
}
bloc... | 0 |
#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;
for(;;){
pthread_mutex_lock(&lock);
... | 1 |
#include <pthread.h>
int threadsNum;
char *fileName;
int recordsNum;
char *searched;
int file;
int signr;
pthread_t *threads;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *threadFunction(void *);
void signalHandler(int signal) {
printf("PID: %d TID: %ld received signal no %d\\n",... | 0 |
#include <pthread.h>
static pthread_mutex_t file_at_lock = PTHREAD_MUTEX_INITIALIZER;
static int file_at_dfd = -1;
static char saved_cwd[MAXPATHLEN];
static int
file_chdir_lock(int dfd)
{
int ret;
pthread_mutex_lock(&file_at_lock);
if (getcwd(saved_cwd, sizeof(saved_cwd)) == 0)
saved_cwd... | 1 |
#include <pthread.h>
static int checkArray[9] = {1,2,3,4,5,6,7,8,9};
int valid = 1;
pthread_mutex_t mutex;
void *checkRow(void *arg) {
int *localArray = (int *) arg;
int *temp = malloc(9*sizeof(int));
memcpy(temp, localArray, 9*sizeof(int));
ins_sort(temp);
if (memcmp(temp, checkArray, (9... | 0 |
#include <pthread.h>
pthread_t tids[5];
int thread_num;
int thread_exit_code;
} thread_data;
int fib(int n) {
if (n==0) return 1;
if (n==1) return 1;
return fib(n-1) + fib(n-2);
}
thread_data my_data[5];
pthread_mutex_t my_mutex;
void *printIt(void *thread_num) {
lo... | 1 |
#include <pthread.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing(void *arg)
{
pthread_mutex_lock(&lock);
unsigned long i = 0;
counter += 1;
printf("\\n Job %d started\\n", counter);
for(i=0; i<(0xFFFFFFFF);i++);
printf("\\n Job %d finished\\n", counter);... | 0 |
#include <pthread.h>
int worker1_id;
int worker2_id;
void *worker1(void *param);
void *worker2(void *param);
pthread_mutex_t mtx1;
pthread_mutex_t mtx2;
int main(int argc, char *argv[])
{
srand(time(0));
pthread_mutex_init(&mtx1, 0);
pthread_mutex_init(&mtx2, 0);
printf("main:... | 1 |
#include <pthread.h>
void *dostuff(void *);
pthread_mutex_t gary;
int main(){
pthread_t tarry[4];
int thread_ids[4] = {0};
int status = 0;
int i = 0;
pthread_mutex_init( &gary, 0 );
for( i = 0; i < 4; i++ ){
thread_ids[i] = i;
status = pthread_... | 0 |
#include <pthread.h>
static pthread_t ht_thread;
static pthread_cond_t ht_cond;
static pthread_mutex_t ht_lock = PTHREAD_MUTEX_INITIALIZER;
static inline void
hwtimer_inc_clock ( struct timespec *ts )
{
ts->tv_nsec += ((1000000000LL) / HWTIMER_HZ);
if (ts->tv_nsec >= (1000000000LL) ) ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
const size_t N_THREADS = 4;
void *blocking(void *arg) {
int retcode;
char buffer[16384];
int *argi = (int *) arg;
int my_tidx = *argi;
retcode = pthread_mutex_lock(&mutex);
printf("%d: in blocking thread: got mutex\\n", my_t... | 0 |
#include <pthread.h>
pthread_t PIDARR[5];
pthread_mutex_t forks[5]={PTHREAD_MUTEX_INITIALIZER,PTHREAD_MUTEX_INITIALIZER,PTHREAD_MUTEX_INITIALIZER,PTHREAD_MUTEX_INITIALIZER,PTHREAD_MUTEX_INITIALIZER};
sem_t waiter;
void* philosopher(void *arg){
pthread_t PID=pthread_self();
pthread_mutex_t* righ... | 1 |
#include <pthread.h>
void Threads_Glue_Yield(void)
{
SDL_Delay(10);
}
void Threads_Glue_AcquireMutex(void **Lock)
{
if(!*Lock) {
*Lock = malloc( sizeof(pthread_mutex_t) );
pthread_mutex_init( *Lock, 0 );
}
pthread_mutex_lock( *Lock );
}
void Threads_Glue_ReleaseMutex(void ... | 0 |
#include <pthread.h>
int main()
{
pthread_mutex_t mutex;
pthread_mutexattr_t mta;
if(pthread_mutexattr_init(&mta) != 0)
{
perror("Error at pthread_mutexattr_init()\\n");
return PTS_UNRESOLVED;
}
if(pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_ERRORCHECK) != 0)
{
printf("Test FAIL... | 1 |
#include <pthread.h>
void ts_packet_init(void)
{
int i;
for(i = 0; i < TS_PACKET_NUM; i++){
memset(tp.tp_buf[i].buf, 0, sizeof(tp.tp_buf[i].buf));
tp.tp_buf[i].used = TS_PACKET_NOUSED;
}
tp.tp_head = tp.tp_tail = 0;
pthread_mutex_init(&tp.tp_mutex, 0);
}
void write_ts_packet(char *buf... | 0 |
#include <pthread.h>extern void __VERIFIER_error() ;
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int();
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=... | 1 |
#include <pthread.h>
static bool is_kernel_writing = 0;
static unsigned long magic_num = 0;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static unsigned long GetDispifInfoAddr(int fd) {
void *addr = 0;
struct mtk_dispif_info disp... | 0 |
#include <pthread.h>
static int net_ready = 0;
static int w_progress = -1;
static char rbuf[3][2048][1024];
static pthread_mutex_t *log_mutex;
struct net_arg_struct {
int id;
};
struct io_arg_struct {
int id;
};
struct net_arg_struct net_args;
struct io_arg_struct io_args... | 1 |
#include <pthread.h>
void *thread_update(void *threadid);
int i;
double X_acc;
double Y_acc;
double Z_acc;
double Roll;
double Pitch;
double Yaw;
struct timespec Sample_time;
}Space_Param1;
Space_Param1 Space_Param;
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
void *thread_updat... | 0 |
#include <pthread.h>
int buffer[5];
int readingHead;
int writingHead;
sem_t occuppees;
sem_t libres;
pthread_mutex_t mut;
void *write( void *n );
void *read();
int main (int argc, const char* argv[])
{
pthread_t writer1;
pthread_t writer2;
pthread_t writer3;
pthread_t reader... | 1 |
#include <pthread.h>
int res = 12345 ;
int * px = 0 ;
int * py = 0 ;
pthread_mutex_t verroupx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t verroupy = PTHREAD_MUTEX_INITIALIZER;
int nblibre = 0;
void* mon_threadpx(void * arg){
int max = *(int*)arg ;
int i ;
for(i = 0 ; i < max ; i++ ){
... | 0 |
#include <pthread.h>
int val;
struct list_node* next;
} list_node;
pthread_mutex_t read_mutex;
pthread_mutex_t append_mutex;
pthread_cond_t no_readers;
pthread_cond_t no_erasers;
unsigned reader_count;
unsigned del_req;
list_node* start_node;
} clist;
void clist_init(clist* list) {
... | 1 |
#include <pthread.h>
int val;
struct node *next;
struct node *prev;
} node;
node* front = 0;
node* rear = 0;
pthread_mutex_t mutexFront = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexRear = PTHREAD_MUTEX_INITIALIZER;
void print_queue() {
node* current = front;
while (current != 0) ... | 0 |
#include <pthread.h>
pthread_mutex_t forks[5];
pthread_t phils[5];
pthread_mutex_t foodlock;
int eated[5];
int sleep_seconds = 3000;
void *philosopherRoutine(void*);
int get_food();
void get_fork(int,int,char*);
void put_forks(int,int);
int main ( int argc , char **argv ) {
int i;
... | 1 |
#include <pthread.h>
static pthread_key_t key;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
pthread_mutex_t env_mutex = PTHREAD_MUTEX_INITIALIZER;
extern char **environ;
static void
thread_init(void) {
pthread_key_create(&key, free);
}
char *
getenv(const char *name) {
int i, ... | 0 |
#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;
for(;;){
pthread_mutex_lock(&lock);
while(head == 0)
pth... | 1 |
#include <pthread.h>
void readrec_dir(char *directory,pthread_mutex_t *mtx,pthread_mutex_t *cmtx,int newsock,int queue_size,pthread_cond_t *cond_nonempty,pthread_cond_t *cond_nonfull) {
char *buffer;
DIR *dir;
struct dirent entry;
struct dirent *result = 0;
if (strcmp(direct... | 0 |
#include <pthread.h>
int
aio_cancel (fildes, aiocbp)
int fildes;
struct aiocb *aiocbp;
{
struct requestlist *req = 0;
int result = AIO_ALLDONE;
if (fcntl (fildes, F_GETFL) < 0)
{
errno = EBADF;
return -1;
}
pthread_mutex_lock (&aio_requests_mutex);
i... | 1 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t wait = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg){
int err, signo;
for ( ; ; ){
err = sigwait(&mask, &signo);
switch (signo){
case SIGINT:
printf("interru... | 0 |
#include <pthread.h>
int fdd, dir;
long spd = 1;
long order[10];
long long distance_prev, distance_pres;
int breakflag;
pthread_mutex_t mut;
void *sensor_read()
{
int fd, res, retioctl, cmd;
int k = 0;
long long timebuf = 0, tmp;
int dirprev;
fd = open("/dev/pulse", O_RDWR);
if (fd < ... | 1 |
#include <pthread.h>
pthread_mutex_t sword;
pthread_barrier_t shield;
int current_floor;
int dest;
int is_locked;
enum {ELEVATOR_ARRIVED=1, ELEVATOR_OPEN=2, ELEVATOR_CLOSED=3} state;
} elevator;
elevator E[ELEVATORS];
int is_locked[ELEVATORS];
void scheduler_init() {
for(int i = 0; i < EL... | 0 |
#include <pthread.h>
extern int makethread (void * (*) (void *), void * );
void * timeout_helper (void * arg);
void timeout (const struct timespec * when, void (* func) (void *), void * arg);
void retry (void * arg);
struct to_info {
void (* to_fn) (void *);
void * to_arg;
struct time... | 1 |
#include <pthread.h>
int value = 0;
void *count(void *arg);
char name[64];
pthread_mutex_t *mlock;
} mythread_args_t;
int main() {
pthread_t th1, th2, th3;
void *rval;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
mythread_args_t args1 = {"th1", &mutex};
mythread_args_t a... | 0 |
#include <pthread.h>
{
pthread_t tid;
int equal;
int cntrl;
} PARAM_t;
{
pthread_mutex_t mutex;
pthread_cond_t cond;
int flag;
} JUDGE_t;
static JUDGE_t judge;
static void *
func(void *arg)
{
int i = 0;
PARAM_t *ptr = (PARAM_t *)arg;
for (i = 0; i < (10);... | 1 |
#include <pthread.h>
static
void* renderer_run(void* arg) {
struct renderer* r = (struct renderer*)arg;
int ret;
DEBUG_LOG(("%s renderer thread started\\n", r->name));
pthread_cond_signal(&r->cond);
pthread_mutex_lock(&r->mutex);
while (1) {
ret = pthread_cond_wait(&r->cond, &r->mutex... | 0 |
#include <pthread.h>
{
int head;
int tail;
int validItems;
int data[5];
pthread_mutex_t lock;
}cmdque;
cmdque cmd_buff;
void cmd_init(cmdque *cmd_buff)
{
int i;
cmd_buff->head=0;
cmd_buff->tail=0;
cmd_buff->validItems=0;
for(i=0;i<5;i++)
cmd_buff->data[i]=0;
if(pthread_mutex_init(&cmd_... | 1 |
#include <pthread.h>
struct node
{
char user[5];
char process;
int arrival;
int duration;
int priority;
struct node *next;
}*head;
struct display
{
char user[5];
int timeLastCalculated;
struct display *next;
}*frontDisplay, *tempDisplay, *rearDisplay;
pthread_mutex_t m1 = PTHREAD_MUTEX_... | 0 |
#include <pthread.h>
pthread_mutex_t primeiro, segundo;
void *tarefa1(){
printf("TAREFA1: Tentando pegar o primeiro mutex...\\n");
pthread_mutex_lock(&primeiro);
printf("TAREFA1: CONSEGUI o primeiro mutex!\\n");
printf("TAREFA1: Realizando alguma atividade do primeiro recurso...\\n");
... | 1 |
#include <pthread.h>
char* ph_name[] = {"Newton","Einstein","Maxwel","Planck","Bohr"};
pthread_mutex_t forks[5];
void swap_if_larger( int* fork1, int* fork2)
{
int temp;
if (*fork1 > *fork2)
{
temp = *fork1;
*fork1 = *fork2;
*fork2 = temp;
}
return 0;
}
void*... | 0 |
#include <pthread.h>
extern int vasprintf(char **, const char *, va_list);
int
queue_init(struct queue *queue, const char *fmt, ...)
{
va_list ap;
memset(queue, '\\0', sizeof(*queue));
if (pthread_cond_init(&queue->cond, 0) != 0)
return (-1);
if (pthread_mutex_init(&queu... | 1 |
#include <pthread.h>
void *process_func();
sem_t sem;
pthread_barrier_t barrier;
pthread_cond_t cond;
pthread_mutex_t lock;
int active = 0;
int full = 0;
int main()
{
pthread_t process[500];
long i;
sem_init(&sem, 0, 3);
pthread_barrier_init(&barrier, 0, 3);
pthread_cond_... | 0 |
#include <pthread.h>
void *thr_signal(void *arg);
void *thr_wait(void *arg);
pthread_t signal_t[10];
pthread_t wait_t[5];
static int count = 0;
pthread_cond_t qready;
pthread_mutex_t mutex;
static void mutex_clean(void *mutex);
void thread_prac3_cond() {
count = 1;
pthread_co... | 1 |
#include <pthread.h>
pthread_mutex_t * l;
pthread_mutex_t gl1;
pthread_mutex_t gl2;
struct irrel {
int i;
};
struct rel {
int i;
int j;
pthread_mutex_t *ptr;
pthread_mutex_t lock;
};
struct rel j;
bar () {
l = malloc(sizeof(pthread_mutex_t));
}
pthread_mutex_t * doMalloc () {
r... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
int current = 0;
int tCount = 0;
int passCounter = 0;
void my_sleep(int id) {
struct timespec ts;
unsigned int seed = getpid() * (id + 1);
ts.tv_nsec = (int)(rand_r(&seed) / ((double)32767 + 1) * 500000000);
ts.tv_sec = 0;
nanos... | 1 |
#include <pthread.h>
pthread_mutex_t m_Mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m_Mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t m_CondVar = PTHREAD_COND_INITIALIZER ;
int cond = 0;
void signaling()
{
printf("Signal !!!\\n");
pthread_mutex_lock(&m_Mu... | 0 |
#include <pthread.h>
static struct timeval begin_time;
static long int late = 0;
static pthread_mutex_t lock;
static long int *temp;
static struct setting setting;
static struct record *records;
static int fd;
static int thread;
static void trace_replay(void *arg)
{
struct timeval end_time, resu... | 1 |
#include <pthread.h>
static pthread_mutex_t atomic_mtx;
static void
atomic_init(void)
{
pthread_mutex_init(&atomic_mtx, 0);
}
uint64_t
atomic_add_64_nv(volatile uint64_t *target, int64_t delta)
{
uint64_t newval;
pthread_mutex_lock(&atomic_mtx);
newval = (*target += delta);
pthread_mut... | 0 |
#include <pthread.h>
int tid;
} thread_data_t;
int matrix[4][4];
int done_count;
sem_t delay[4];
pthread_mutex_t m;
void swap(int *x, int *y);
void shear_sort(void *arg);
int main()
{
int i, j, num;
pthread_t threads[4];
thread_data_t data[4];
FILE *fd = fopen("inpu... | 1 |
#include <pthread.h>
int value;
struct tnode *left, *right;
pthread_mutex_t m;
} treeNode;
treeNode *root;
} treeRoot;
void insert(treeRoot *tree, int val)
{
treeNode **tptr = &(tree->root);
while (*tptr != 0){
if ((*tptr)->value == val)
return;
if ((*tptr)->va... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.