text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct job {
struct job* next;
};
struct job* job_queue;
extern void process_job (struct job*, int*);
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
void initialize_job_queue ()
{
job_queue = 0;
sem_init (&job_queue_cou... | 1 |
#include <pthread.h>
void *print(void *m);
struct data {
pthread_mutex_t lock1;
pthread_mutex_t lock2;
};
int main ()
{
int rt;
pthread_t tid;
pthread_attr_t attr;
struct data d;
struct data *dPtr = &d;
rt = pthread_mutex_init(&(d.lock1), 0);
rt = pthread_mutex_init(&... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t condition;
int value;
} my_struct_t;
my_struct_t data = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};
void *waiting_thread(void *);
void *signalling_thread(void *);
int
main(int argc, char **argv)
{
pthr... | 1 |
#include <pthread.h>
struct mt
{
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(void)
{
int fd,i;
struct mt *mm;
pid_t pid;
fd = open("m_test",O_CREAT | O_RDWR,0777);
ftruncate(fd,sizeof(*mm));
mm = mmap(0,sizeof(*mm),PROT_READ|PROT_... | 0 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
volatile int x = 1;
void *print_odd(void *arg)
{
int run = 1;
while (run) {
pthread_mutex_lock(&lock);
if (x % 2 == 0) {
pthread_cond_wait... | 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>
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
int producedCake = 0;
int Table[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
void Mom(){
int momPosition = -1;
while(producedCake < 100){
if(momPosition == 10 -1){
momPosition = 0;
} else {
... | 1 |
#include <pthread.h>
char g_storage[20];
size_t g_stock = 0;
pthread_mutex_t g_mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t g_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t g_empty = PTHREAD_COND_INITIALIZER;
void show (const char* who, const char* op, char prod) {
printf ("%s：", who);
... | 0 |
#include <pthread.h>
struct zhw_cache_t {
void **pool;
size_t valid_num;
size_t cache_num;
size_t item_size;
pthread_mutex_t lock;
};
struct zhw_cache_t *zhw_cache_create(size_t cache_num, size_t item_size)
{
struct zhw_cache_t *p = calloc(1, sizeof(struct zhw_cache_t));
... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int next_id = 1;
static void milli_sleep(int millis) {
struct timespec tm;
tm.tv_sec = 0;
tm.tv_nsec = millis * 1000000;
nanosleep(&tm, 0);
}
static void* hid_thread(void* arg) {
int fd... | 0 |
#include <pthread.h>
struct foo *fh[29];
struct foo *fps[100] = {0};
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(int i)
{
struct foo *fp;
int idx;
... | 1 |
#include <pthread.h>
char buffer[1024];
pthread_mutex_t mutex;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread_play_0(void *arg);
void Error_print(int num,char *pStr)
{
if(num != 0) {
perror(pStr);
exit(1);
}
}
int main(void)
{
int ret;
pthread_t id;
pthread_attr_t t... | 0 |
#include <pthread.h>
void *Producer();
void *Consumer();
char *BUFFER;
int BufferIndex=0;
pthread_cond_t Buffer_Not_Full=PTHREAD_COND_INITIALIZER;
pthread_cond_t Buffer_Not_Empty=PTHREAD_COND_INITIALIZER;
pthread_mutex_t mVar=PTHREAD_MUTEX_INITIALIZER;
int main()
{
pthread_t ptid,ctid;... | 1 |
#include <pthread.h>
int p_id;
int p_fila;
int p_columna;
int p_weapon;
}people;
char** board;
int N;
int M;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void move_people(people *persona, char** board){
int i, j;
i = persona->p_fila;
j = persona->p_colu... | 0 |
#include <pthread.h>
int pthread_barrier_init(pthread_barrier_t* barrier,
const void* barrier_attr,
unsigned count) {
int rc;
_uv_barrier* b;
if (barrier == 0 || count == 0)
return EINVAL;
if (barrier_attr != 0)
return ENOTSUP;
... | 1 |
#include <pthread.h>
int sum = 0;
int arr[8][100];
pthread_mutex_t sum_mutex;
void* do_work(void* num)
{
int i, j;
int cols_start, cols_end;
int* int_num;
int local_sum = 0;
int_num = (int *) num;
cols_start = *int_num * 100 / 4;
cols_end = cols_start + 100 / 4;
printf ... | 0 |
#include <pthread.h>
enum
{
NUM_ASYNC_IO = 20,
PAGE_SIZE = 8,
PAGE_NUMBER = 32
};
enum TYPE_OF_OPERATION
{
READ,
WRITE
};
struct paging_file_info
{
char *file_name;
int fdw;
int fdr;
struct aiocb *aiocb_blocks;
};
struct buff_page_info
{
int is_active;
int page_number;
};
pth... | 1 |
#include <pthread.h>
char mfork[10];
struct cv_t{
pthread_mutex_t m;
pthread_cond_t cv;
};
struct cv_t mcv = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER};
void * mthread(void *num)
{
int sec;
int l, r;
int _i;
for (_i=0; _i<3; _i++){
sec = rand() % 3;
sleep(sec);
r = ((in... | 0 |
#include <pthread.h>
int calculateNext(int s2) {
int calculateNext_return;
do {
calculateNext_return = __nondet_int();
} while(calculateNext_return == s2 || calculateNext_return == 0);
return calculateNext_return;
}
int seed;
pthread_mutex_t m;
int PseudoRandomUsingAtomic_nextInt(... | 1 |
#include <pthread.h>
int buffer[3];
int add = 0;
int rem = 0;
int num = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c_cons = PTHREAD_COND_INITIALIZER;
pthread_cond_t c_prod = PTHREAD_COND_INITIALIZER;
void *producer(void *param);
void *consumer(void *param);
int main... | 0 |
#include <pthread.h>
{
int id;
int tipo;
} Data;
Data fila[150];
int in = 0;
int out = 0;
int formados = 0;
int atendidos = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cajero_t = PTHREAD_COND_INITIALIZER;
pthread_cond_t cliente_t = PTHREAD_COND_INITIALIZER;
... | 1 |
#include <pthread.h>
sem_t N_FREE, lock;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int available[4] = {1,1,1,1};
pthread_t machineArr[4];
pthread_t stationArr[4];
int k;
int m;
void* runMachine(void *m);
void* runStation(void *k);
void release(int machine);
void setup(int stations,... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
const int MSG_MAX = 50;
void* send_msg(void* rank);
void get_args(int argc, char* argv[]);
void usage(char* prog_name);
long thread_count;
long long n;
int message_available, consumer;
char** messages;
pthread_mutex_t mutex;
int main(int argc,... | 1 |
#include <pthread.h>
pthread_mutex_t insert_lock;
pthread_mutex_t delete_lock;
pthread_mutex_t search_count_lock;
struct node *head = 0;
int search_count = 0;
struct node {
int val;
struct node* next;
};
void push()
{
struct node* new_node = malloc(si... | 0 |
#include <pthread.h>
pthread_mutex_t condition_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_cond = PTHREAD_COND_INITIALIZER;
int turn=0;
long Counter = 0;
void *Conter()
{
while(1)
{
pthread_mutex_lock( &condition_mutex );
if(turn==0) pthread_cond_wait( &condition_cond, &... | 1 |
#include <pthread.h>
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
int count = 0;
int sum=0;
void *functionCount1();
void *functionCount2();
void main() {
pthread_t thread1, thread2;
pthread_create( &thread1, 0, &functionCou... | 0 |
#include <pthread.h>
int arr[1024];
pthread_mutex_t l = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
int lectores = 0;
int escritores = 0;
void *escritor(void *arg)
{
int i;
int num = *((int *)arg);
for (;;) {... | 1 |
#include <pthread.h>
int is_prime(int n) {
int i;
if (n <= 2) return 1;
if (n % 2 == 0) return 0;
for (i = 3; i < n; i += 2) {
if (n % i == 0) return 0;
}
return 1;
}
struct search_range {
int start;
int end;
... | 0 |
#include <pthread.h>
inline size_t
software_cas(size_t* reg, size_t oldval, size_t newval, pthread_mutex_t *lock)
{
pthread_mutex_lock(lock);
if (memcmp(reg, &oldval, sizeof(void*)) == 0)
{
memcpy(reg, &newval, sizeof(void*));
pthread_mutex_unlock(lock);
return oldval;
... | 1 |
#include <pthread.h>
struct arg_set{
char *fname;
int count;
};
struct arg_set *mail_box;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
int main(int ac, char *av[]){
pthread_t t1, t2;
struct arg_set args1, args2;
void *count... | 0 |
#include <pthread.h>
sem_t queue_length;
struct transaction_queue_node_t *transaction_head, *transaction_tail;
pthread_mutex_t mutex_queue = PTHREAD_MUTEX_INITIALIZER;
volatile int transaction_id;
struct transaction_queue_node_t *dequeue_transaction()
{
struct transaction_queue_node_t *node;
sem... | 1 |
#include <pthread.h>
void *barber_entry(void *ptr);
void *customer_entry(void *ptr);
pthread_mutex_t mutex;
int freeseats = 5;
int maxseats = 5;
main()
{
pthread_mutex_init(&mutex, 0);
pthread_t thread1, thread2;
int iret1, iret2;
iret1 = pthread_create( &thread1, 0, barber_entry... | 0 |
#include <pthread.h>
struct net_args {
int id;
struct addrinfo* addrinfo;
pthread_mutex_t* lock;
pthread_cond_t* cond;
pthread_barrier_t* barrier;
int* len;
char* data;
int* ready;
};
void print_usage(FILE* fp) {
fprintf(fp, "Usage:\\n\\n");
fprintf(fp, " -h\\t\\tshow usage\\n");
fpri... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *myfunc(void *arg)
{
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
return 0;
}
void *fork_thread(void *arg)
{
pthread_t t;
pthread_create(&t, 0, myfunc, 0);
if (fork() == 0) {
pthread_mutex_init(&mutex, 0);
pthre... | 0 |
#include <pthread.h>
void *test_connect(void *arg);
int count = 0;
pthread_mutex_t lock;
char *host = 0;
int main(int argc, char *argv[]) {
host = argv[1];
pthread_t thread[12];
int i;
pthread_mutex_init(&lock, 0);
for (i = 0; i < 12; i++)
pthread_create(&thread[i], 0, test_connect, 0);... | 1 |
#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():... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct {
int status;
int value;
} memory;
void *consume(void *pv)
{
for (;;) {
pthread_mutex_lock(&mutex);
if (memory.status == 1) {
printf("%d\\n", memory.value);
memory.status = 0;
}
pthread_mut... | 1 |
#include <pthread.h>
struct alarm_elem {
int seconds;
time_t alarm_time;
struct alarm_elem *link;
char message[64];
};
struct alarm_elem *alarm_list = 0;
time_t current = 0;
pthread_mutex_t alarm_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t alarm_cond = PTHREAD_COND_INITIALIZER;
void a... | 0 |
#include <pthread.h>
enum memmodel
{
MEMMODEL_RELAXED = 0,
MEMMODEL_CONSUME = 1,
MEMMODEL_ACQUIRE = 2,
MEMMODEL_RELEASE = 3,
MEMMODEL_ACQ_REL = 4,
MEMMODEL_SEQ_CST = 5
};
inline static void mysync(int id, int volatile * b){
if(id == 0) {
*b = 1;
} else {
w... | 1 |
#include <pthread.h>
void *password_comparer(void *thread_arg) {
struct thread_data *t_data;
struct crypt_data *c_data;
int comp_len, i;
ssize_t read = 0;
char *password, *result;
pid_t tid = syscall(SYS_gettid);
t_data = (struct thread_data *) thread_arg;
c_data = t_data->c_data;
c_da... | 0 |
#include <pthread.h>
void *dinner_order(void *ph);
void dinner_start();
{
int status;
const char *name;
pthread_mutex_t *fork_left, *fork_right;
pthread_t thread;
}Philos;
int main()
{
dinner_start();
return 0;
}
void dinner_start()
{
int i;
int fail_attemp;
const ch... | 1 |
#include <pthread.h>
void*rightCounter();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int rightcounter = 0;
void*leftCounter();
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
int leftcounter = 0 ;
int right[]={1,2,2,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0};
int left[]={1,2,2,4,5,6,7... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t e1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t e2 = PTHREAD_COND_INITIALIZER;
void* behav1 (void *args)
{
pthread_mutex_lock (&mutex1);
pthread_cond_b... | 1 |
#include <pthread.h>
void
pthread_create_(pthread_t * thread, const pthread_attr_t * attr,
void * start_routine, void * arg)
{
if ((pthread_create(thread, attr, start_routine, arg)) != 0) {
fprintf(stderr, "[ERROR] Pthread creating error\\n");
exit(1);
}
}
void
pthread_join_(pthread... | 0 |
#include <pthread.h>
char str[50];
pthread_mutex_t mutex;
void * write_thread (void *p)
{
printf("\\n In Write thread\\n");
if(pthread_mutex_lock(&mutex)==0)
{
printf(" Enter A string : ");
fgets(str,25,stdin);
printf("\\n Write job is over\\n");
pthread_mutex_unlock(&mutex);
}
... | 1 |
#include <pthread.h>
pthread_t thread[2];
pthread_mutex_t mut;
int number=0, i;
void *thread1()
{
printf("thread 1 start\\n");
for(i=0;i< 10;i++)
{
printf("thread 1[%d]=%d \\n",i, number);
pthread_mutex_lock(&mut);
number++;
pthread_mutex_unlock(&m... | 0 |
#include <pthread.h>
int q[2];
int qsiz;
pthread_mutex_t mq;
void queue_init ()
{
pthread_mutex_init (&mq, 0);
qsiz = 0;
}
void queue_insert (int x)
{
int done = 0;
printf ("prod: trying\\n");
while (done == 0)
{
pthread_mutex_lock (&mq);
if (qsiz < 2)
... | 1 |
#include <pthread.h>
pthread_t thread_id;
int client_fd;
struct thread_node *next;
} thread_node;
static int running;
thread_node *head;
int start_index;
int sock_fd;
FILE *editor_fp;
struct addrinfo hints, *result;
pthread_mutex_t mutex;
char text[1048576];
void sync_send() {
thread_node *c... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int id;
int parameter;
} tp = {PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER,0,0};
char services[25][50] = {
"AddTwoNumbers","SubtractTwoNumbers","MultiplyTw... | 1 |
#include <pthread.h>
void *display_task(void *arg)
{
struct task_par *tp;
tp = (struct task_par *)arg;
double dt_p = 0 , dt_v = 0, dt_t = 0;
int p, b;
double t = 0;
set_period(tp);
while(1)
{
pthread_mutex_lock(&mux_page);
p = page;
... | 0 |
#include <pthread.h>
int valid;
pthread_cond_t cv;
pthread_mutex_t mtx;
int predicate;
int barrier_val;
int blocked_threads;
} barrier_t;
pthread_mutex_t barrier_init_mutex = PTHREAD_MUTEX_INITIALIZER;
int barrier_init(barrier_t *b, int val)
{
int rv;
if ((rv=pthread_mut... | 1 |
#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 = localt... | 0 |
#include <pthread.h>
char work_area[1024];
int time2exit = 0;
pthread_mutex_t work_mutex;
void *slave(void *arg)
{
sleep(1);
pthread_mutex_lock(&work_mutex);
while (strncmp("end", work_area, 3) != 0)
{
printf("you input %d characters\\n", strlen(work_area) - 1);
... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
void *fun1() {
for (int i = 0 ; i < 1000000 ; i++) {
pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);
}
return 0;
}
void *fun2() {
for (int i = 0 ; i < 1000000 ; i++) {
pthread_mutex_lock(&lock);
pt... | 0 |
#include <pthread.h>
void oo_wqlock_init(struct oo_wqlock* wql)
{
wql->lock = 0;
pthread_mutex_init(&wql->mutex, 0);
pthread_cond_init(&wql->cond, 0);
}
void oo_wqlock_lock_slow(struct oo_wqlock* wql)
{
pthread_mutex_lock(&wql->mutex);
while( 1 ) {
uintptr_t v = wql->lock;
if(... | 1 |
#include <pthread.h>
pthread_mutex_t lock[5];
int sum = 40;
void *fun(void *p)
{
int n = *(int *)p;
while(1)
{
sleep(1);
if(n == 1)
{
if(sum==0)
{
printf("eatting finished\\n");
break;
}
... | 0 |
#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) {
... | 1 |
#include <pthread.h>
unsigned pegapassos(int argc, char** argv) {
if (argc < 2 || argc > 2) {
printf("O programa recebe o número de passos.\\n");
exit(0);
}
return strtoul(argv[1], 0, 10);
}
static unsigned STEP_NUM;
static unsigned THREAD_NUM;
static double STEP;
static double pi... | 0 |
#include <pthread.h>
static int threads = 0;
static struct mpi_bench_param_bounds_s param_bounds =
{
.min = 0,
.max = THREADS_DEFAULT,
.mult = 1,
.incr = 1
};
static int compute_stop = 0;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_t tids[THREADS_... | 1 |
#include <pthread.h>
void *produce(void*);
void *consume(void*);
struct {
pthread_mutex_t mutex;
int buff[1000000];
int n;
} shared = { PTHREAD_MUTEX_INITIALIZER };
int main(int argc, char *argv[]) {
int i;
int count[5];
pthread_t producers[5];
pthread_t consumer;
for(i = 0; i < 5;... | 0 |
#include <pthread.h>
struct ogst_connecter *ogst_connecter_new(struct ogst_connecter *(*gen)(void),
char *path)
{
int len;
struct ogst_connecter *sock;
sock = gen();
if ((sock->sd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
sock->socket.sun_family = A... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void read_fifo(int r_fd)
{
int n;
char buf[1024];
while (1)
{
pthread_cond_wait(&cond,&lock);
n = read(r_fd,buf,sizeof(buf));
buf[n] = ... | 0 |
#include <pthread.h>
static pthread_mutex_t getgr_mutex = PTHREAD_MUTEX_INITIALIZER;
static int
convert (struct group *ret, struct group *result,
char *buf, int buflen)
{
int len;
int count;
char **gr_mem;
char *buf1;
if (!buf) return -1;
*result = *ret;
result->gr_name = ... | 1 |
#include <pthread.h>
static FILE *fv_log_file = 0;
static struct fv_buffer fv_log_buffer = FV_BUFFER_STATIC_INIT;
static pthread_t fv_log_thread;
static bool fv_log_has_thread = 0;
static pthread_mutex_t fv_log_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t fv_log_cond = PTHREAD_COND_I... | 0 |
#include <pthread.h>
struct element{
void* value;
element *next;
};
struct queue{
llist in;
llist out;
};
pthread_mutex_t push = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t pop = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t blocking = PTHREAD_MUTEX_INITIALIZER;
pthread_t id1;
struct queue... | 1 |
#include <pthread.h>
pthread_mutex_t mutex[10] = {
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INITIALIZER,
PTHREAD_MUTEX_INI... | 0 |
#include <pthread.h>
char buf[200] = {0};
pthread_mutex_t mutex;
unsigned int flag = 0;
pthread_cond_t cond;
void *func(void *arg)
{
while (flag == 0)
{
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("本次输入了%d个字符\\n", strlen(buf));
memset(buf, 0, sizeof(buf... | 1 |
#include <pthread.h>
int state[5];
pthread_cond_t philArray[5];
pthread_mutex_t the_mutex;
void test(int i) {
if (state[i] == 1 && state[(i + 4) % 5] != 2 && state[(i + 1) % 5] != 2) {
state[i] = 2;
printf("Philosopher %d starts eating.\\n", i);
printf("[%d,... | 0 |
#include <pthread.h>
extern char hash[TCP_HASH_SIZE+1];
extern void *hash_flows2;
void bulk_tcp(struct seg6_sock *sk, struct nlattr **attrs, struct nlmsghdr *nlh) {
struct parser_tcp *tcphdr ;
struct parser_ipv6 *ip6hdr ;
struct tcp_flow_2 *flow2;
struct bulk_buffer *buffer;
... | 1 |
#include <pthread.h>
char *word;
int count;
struct dict *next;
} dict_t;
char *
make_word( char *word ) {
return strcpy( malloc( strlen( word )+1 ), word );
}
FILE *infile1;
pthread_mutex_t lock;
dict_t *wds = 0;
dict_t *
make_dict(char *word) {
dict_t *nd = (dict_t *) malloc( sizeof(di... | 0 |
#include <pthread.h>
pthread_mutex_t mtx[3];
pthread_t t[10];
int cnt[3];
void* doIt(void *arg) {
while(cnt[0] < 5 || cnt[1] < 5 || cnt[2] < 5) {
int x = 1 + rand() % 900;
printf("Thread: %d\\n", x);
if(x <= 300) {
pthread_mutex_lock(&mtx[0]);
... | 1 |
#include <pthread.h>
int get_round(int length);
void *Merge(void*args);
void print_array(int length);
int number_array[4096];
int barrier;
pthread_mutex_t mutex;
pthread_cond_t cond;
pthread_t tid[4096];
int left;
int mid;
int right;
}args;
int main(int argc, char *argv[])
{
FILE... | 0 |
#include <pthread.h>
void *enteroffice(void * arg);
void *answerQ(void * arg);
pthread_mutex_t print_mutex;
pthread_mutex_t qa_mutex;
sem_t q_asked;
sem_t answered;
sem_t office_max;
struct Params{
int studentNumber;
int questionNumber;
};
int main(int argc, char **argv){
int args[3... | 1 |
#include <pthread.h>
int
_aasg_bidalloc(struct aasg_peer *aasgp,
void (*completion_handler)(struct asg_batch_id_t *),
struct asg_batch_id_t **bid)
{
int id;
struct aasg_transport *aasgx;
aasgx = aasgp->aasgx;
*bid = malloc(sizeof(struct asg_batch_id_t));
if (*bid == 0)
re... | 0 |
#include <pthread.h>
void usage();
int factorial(int n);
void *T1(void *t);
void *T2(void *t);
bool finished = 0;
int count = 0 ;
pthread_mutex_t count_mutex;
int data_array[10];
} thread_data;
thread_data global_data;
int main(int argc, char *argv[])
{
if(argc!=3)
{usage(); return(1);... | 1 |
#include <pthread.h>
int count=0,pos=0,num=0;
char *str;
char buffer[5];
FILE *fp;
pthread_mutex_t count_mutex;
pthread_cond_t condc, condp;
int readf(FILE *fp)
{
if((fp=fopen("message.txt", "r"))==0){
printf("ERROR: can't open string.txt!\\n");
return 0;
}
str=(char *)malloc(si... | 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>
pthread_mutex_t mutex_dernier_thread = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_dernier_thread = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_libere = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_libere = PTHREAD_COND_INITIALIZER;
void* chaine(void* arg)
{
int... | 0 |
#include <pthread.h>
buffer_item buffer[5];
sem_t full,empty;
pthread_mutex_t mutex;
int in = 0, out = 0;
int insert_item(buffer_item item) {
sem_wait(&empty);
pthread_mutex_lock(&mutex);
buffer[in] = item;
printf("buffer[%d]:", in);
in = (in + 1) % 5;
pthread_mutex_unlock(&mutex);
sem_post... | 1 |
#include <pthread.h>
unsigned char jrgba[] = { 1,2,3,255, 4,5,6,255, 7,8,9,255, 10,11,12,255, 13,14,15,255, 16,17,18,255,
19,20,21,255, 22,23,24,255, 25,26,27,255, 28,29,30,255 };
unsigned char jrgb[30];
{
unsigned char *rgba;
int rgba_len;
unsigned char *rgb;
... | 0 |
#include <pthread.h>
void *status_thread_handler(void *arg)
{
int led;
int beep;
int temperature;
char buf[4];
while (1)
{
pthread_mutex_lock(&SHM->led_mutex_start);
led = SHM->led_emit_status;
pthread_mutex_unlock(&SHM->led_mutex_start);
pthread_mutex_lock(&SHM->beep_mutex_status... | 1 |
#include <pthread.h>
sem_t officeSpace;
pthread_mutex_t globalLock ;
pthread_cond_t answerCond;
pthread_mutex_t answer_lock;
pthread_cond_t askedCond;
pthread_mutex_t asked_lock;
int askerId ;
int studentId ;
int sQuestionId;
pthread_mutex_t proflock;
int studentsLeft;
pthread_mutex_t student_lock... | 0 |
#include <pthread.h>
static pthread_mutex_t POS_Turret_Write_Lock = PTHREAD_MUTEX_INITIALIZER;
static int POS_Turret_Pitch_Percent;
static int POS_Turret_Yaw_Percent;
void Init_Turret(void)
{
pthread_mutex_unlock(&POS_Turret_Write_Lock);
POS_Turret_Pitch_Percent=0;
POS_Turret_Yaw_Per... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t thereAreOxygen, thereAreHydrogen;
int numberOxygen = 0 , numberHydrogen=0;
int activeOxygen = 0 , activeHydrogen=0;
long currentOxygen = 0 , currentHydrogen=0;
int flagExit=0;
void dataIn(){
int var=-3;
if(numberHydrogen==1 && fl... | 0 |
#include <pthread.h>
char shared_read_buffer[(unsigned long)80*1024];
long shared_word_count = 0;
pthread_mutex_t count_mutex;
struct thread_info {
pthread_t thread_id;
int thread_num;
};
struct read_bound {
unsigned long boundary_array[1 +1];
} bound_struct;
unsigned long f... | 1 |
#include <pthread.h>
FILE *fdatabase, *fquery, *fout;
pthread_mutex_t mutex;
int bmhs(char *string, int n, char *substr, int m) {
int d[256];
int i, j, k;
for (j = 0; j < 256; j++)
d[j] = m + 1;
for (j = 0; j < m; j++)
d[(int) substr[j]] = m - j;
i = m - 1;
while (i < n) {
k... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_numero_disponibili = PTHREAD_MUTEX_INITIALIZER;
void incrementaconttorepadre(struct threadnumero *numerothreadprinc)
{
pthread_mutex_lock( &mutex_numero_disponibili );
if(numerothreadprinc->threadliberi>=MASSIMO_THREAD_LIBERI)
{
printf("ADDIO %d\... | 1 |
#include <pthread.h>
struct barrier {
int num;
int hit;
int hits[16];
pthread_cond_t ncond;
pthread_mutex_t nlock;
pthread_cond_t brcond;
pthread_mutex_t brlock;
pthread_t tids[16];
int tid_count;
pthread_t daemon_tid;
};
void *pbdaemon(void *arg) {... | 0 |
#include <pthread.h>
int circbuf_init(struct circbuf *cbuf, char *buffer, int len, const char *name)
{
cbuf->buffer = buffer;
cbuf->posWrite = cbuf->posRead = 0;
cbuf->nlen = len;
pthread_mutex_init(&cbuf->lock, 0);
pthread_cond_init(&cbuf->notEmpty, 0);
pthread_cond_init(&cbuf->notFull, 0... | 1 |
#include <pthread.h>
static pthread_mutex_t lock;
static void* thread(void* idp) {
int tid = (intptr_t)idp;
int i;
atomic_printf("thread %d starting ...\\n", tid);
for (i = 0; i < 1000; ++i) {
pthread_mutex_lock(&lock);
sched_yield();
pthread_mutex_unlock(&lock);
}
a... | 0 |
#include <pthread.h>
int PBSD_mgr_put(
int c,
int function,
int command,
int objtype,
char *objname,
struct attropl *aoplp,
char *extend)
{
int rc = PBSE_NONE;
int sock;
struct tcp_chan *chan = 0;
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_so... | 1 |
#include <pthread.h>
inline void client_set_id(struct client_t *target, const unsigned id)
{
target->cl_id = id;
}
inline void client_set_sock(struct client_t *target, const int sock)
{
target->cl_sock = sock;
}
inline void client_set_room(struct client_t *target, struct room_t *room)
{
targe... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void mutex_cleanup(void *arg)
{
pthread_mutex_unlock((pthread_mutex_t*)arg);
return;
}
void *pthread1(void *arg)
{
int ret;
pthread_mutex_lock(&mutex);
pthread_cleanup_push(mutex_cleanup, &mutex);
fprintf(stdout, "p... | 1 |
#include <pthread.h>
void *getMoney(char *);
int totalMoney = 4000;
int * moneyPtr = &totalMoney;
pthread_mutex_t mutex1;
int main()
{
pthread_t stu1, stu2, stu3;
char a='a',b ='b',c ='c';
char * charptrA = &a, *charptrB=&b, *charptrC=&c;
pthread_mutex_init(&mutex1, 0);
whi... | 0 |
#include <pthread.h> extern void __VERIFIER_error() ;
void __VERIFIER_assert(int cond) { if (!(cond)) { ERROR: __VERIFIER_error(); } return; }
int myglobal;
pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
void *thread_function_mutex(void *arg)
{
int i,j;
for ( i=0; i<20; i++ )
{... | 1 |
#include <pthread.h>
static sem_t no_judge;
static sem_t exit_sem;
static sem_t all_gone;
static pthread_mutex_t mutex;
static pthread_mutex_t rand_lock;
static pthread_cond_t confirmed;
static pthread_cond_t all_signed_in;
static int num_immigs, num_specs;
static int entered = 0;
static in... | 0 |
#include <pthread.h>
struct executionTimeMotor forwardMotorExecutionArr[(32* (TURNS + 1)) + ((TURNS + 1) * 2)];
struct executionTimeMotor backwardMotorExecutionArr[(32* (TURNS + 1)) + ((TURNS + 1) * 2)];
struct motorBlockTime forwardMotorBlockArr[(32* (TURNS + 1)) + ((TURNS + 1) * 2)];
struct mot... | 1 |
#include <pthread.h>
struct mod_arr{
int *arr;
int size;
};
struct arr_merge{
struct mod_arr* arr1;
struct mod_arr* arr2;
struct mod_arr* arr3;
int count;
};
pthread_mutex_t mutex_var = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
void t... | 0 |
#include <pthread.h>
unsigned long long int data=0;
int current_readers=0;
sem_t sem_readers;
pthread_mutex_t mx = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t protect_readers_count = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t protect_start = PTHREAD_MUTEX_INITIALIZER;
void* readers(void *arg)... | 1 |
#include <pthread.h>
struct fade *fade_init(int samplerate, float level)
{
struct fade *s;
if (!(s = malloc(sizeof (struct fade))))
{
fprintf(stderr, "fade_init: malloc failure\\n");
exit(5);
}
s->samplerate = samplerate;
s->baselevel = level;
... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.