text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
int pbs_sigjob_err(
int c,
char *jobid,
char *signal,
char *extend,
int *local_errno)
{
int rc = 0;
struct batch_reply *reply;
if ((jobid == (char *)0) || (*jobid == '\\0') ||
(signal == (char *)0) || (*signal == '\\0'))
return (PBSE_IVALREQ);... | 1 |
#include <pthread.h>
int counter = 0;
pthread_mutex_t mux;
void thread1(void *arg);
void thread2(void *arg);
int main(int argc,char *argv[])
{
pthread_t id1,id2;
unsigned int slp1,slp2;
pthread_mutex_init(&mux,0);
printf("please print the sleep time slp1 and slp2:\\n");
scanf("%d",&slp1);
scanf... | 0 |
#include <pthread.h>
char name[80];
int amount;
} BANK_CLIENT, *BANK_CLIENT_PTR;
static BANK_CLIENT bank[2]= {{"yossi", 250}, {"shimon", 400}};
pthread_mutex_t mutex1;
void *tradeForever(){
int sums[] ={50, 100, -75, -50, 125, -100, -50};
int n = 7;
int index = 0;
int amount... | 1 |
#include <pthread.h>
{
bool done;
pthread_mutex_t mutex;
} shared_data;
static shared_data* data = 0;
void initialise_shared()
{
int prot = PROT_READ | PROT_WRITE;
int flags = MAP_SHARED | MAP_ANONYMOUS;
data = mmap(0, sizeof(shared_data), prot, flags, -1, 0);
assert(data);
... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
pthread_mutex_t mutex;
long thread_count;
long n;
int in_circle;
void* pi_calc(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double random_double()
{
double base = (double) rand() / 32767;
return (base * ... | 1 |
#include <pthread.h>
pthread_mutex_t request_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_cond_t got_request = PTHREAD_COND_INITIALIZER;
int num_requests = 0;
int done_creating_requests = 0;
struct request {
int number;
struct request* next;
};
struct request* request... | 0 |
#include <pthread.h>
void NouveauRapport()
{
FILE* fichierIndex = 0;
int caractereActuel = 0;
int cpt=0;
char chaine[10000];
int unite;
int dixaine;
int add;
if(pthread_mutex_init(&mutexRapport, 0) == -1)
{
perror("Initialisation mutex de synchro de machi... | 1 |
#include <pthread.h>
static uint32_t crc32_table[256];
static uint64_t crc64_table[256];
static bool crc_initialized = 0;
pthread_mutex_t crc_init_lock = PTHREAD_MUTEX_INITIALIZER;
static void crc_init_tables (void) {
pthread_mutex_lock (&crc_init_lock);
if (crc_initialized) {
pthrea... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
const int MSG_MAX = 100;
void* send_msg(void* rank);
void get_args(int argc, char* argv[]);
void usage(char* prog_name);
long thread_count;
int message_available;
char** messages;
pthread_mutex_t mutex;
int main(int argc, char* argv[] ) ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int n = 0;
int threads;
int iters;
int count;
void *thread(void *vargp) {
printf("Start new Thread\\n");
srand(n);
int i = 0;
int k = 0;
for (i = 0; i < count; i++) {
float x = rand() / 1.0 / 32767;
float y = rand() / 1.0 / 32767;
if (x ... | 0 |
#include <pthread.h>
static int glob = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static void *thread_routine(void *arg)
{
int loc, j;
for (j = 0; j < 10000000; j++) {
pthread_mutex_lock(&mtx);
loc = glob;
loc++;
glob = loc;
pthread_mutex_unlock... | 1 |
#include <pthread.h>
static pthread_mutex_t _auth_shadow_mutex = PTHREAD_MUTEX_INITIALIZER;
int shadow_user_pass_verify(const char *username, const char *password) {
int errsv = 0;
struct spwd *spentp = 0;
size_t salt_len = 0;
char *salt = 0, *local_hash = 0, *user_hash = 0;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students;
void* programming();
void* helping();
unsigned int ranTime(int id);
int seed = 23;
int officeClosed = 0;
int student_num;
} student_info;
int main() {
printf("CS149 Sleepi... | 1 |
#include <pthread.h>
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cnd = PTHREAD_COND_INITIALIZER;
int toexit = 0;
void * start_thread(void * arg) {
pthread_mutex_lock(&mtx);
while(0 == toexit) {
do{ printf("ptid [%ld] -- ", (long int)pthread_self()); printf("wait... | 0 |
#include <pthread.h>
int num = 0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *print1(void *arg){
pthread_mutex_lock(&mutex);
++num;
printf("%d\\n", num);
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
return 0;
}
void *print2(void *arg){
pthread_mutex_lock(&mutex);
while... | 1 |
#include <pthread.h>
static struct camData lastCamData[MAX_TRI];
static struct hokData lastHokData[NBR_ROBOTS];
static int last_cam_nbr = 0;
static long last_hok_timestamp = 0;
static pthread_mutex_t mutexCam, mutexHok;
void pushCamData(struct camData *data, int nbr) {
pthread_mutex_lock... | 0 |
#include <pthread.h>
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
void prepare(void){
printf("prepare() lock....\\n");
pthread_mutex_lock(&lock1);
pthread_mutex_lock(&lock2);
}
void parent(void){
printf("parent() ....\\n");
pthrea... | 1 |
#include <pthread.h>
pthread_t t1,t2;
pthread_mutex_t lock1 = PTHREAD_MUTEX_INITIALIZER,
lock2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t e1 = PTHREAD_COND_INITIALIZER,
e2 = PTHREAD_COND_INITIALIZER;
void* run1 (void *args)
{
int i;
pthread_mutex_lock (&lo... | 0 |
#include <pthread.h>
int thread_count;
double a, b, h;
int n, local_n;
pthread_mutex_t mutex;
double total;
void *Thread_work(void* rank);
double Trap(double local_a, double local_b, int local_n,
double h);
double f(double x);
int main(int argc, char** argv) {
long i;
pthread... | 1 |
#include <pthread.h>
int counter;
pthread_mutex_t counter_mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t counter_mutex2 = PTHREAD_MUTEX_INITIALIZER;
void *doit1(void *vptr)
{
int i;
for (i = 0; i < 5000; i++)
{
pthread_mutex_lock(&counter_mutex1);
printf("%x: %... | 0 |
#include <pthread.h>
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mut1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mut2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1B = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mut1B = PTHRE... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int value;
}SharedInt;
struct SharedInt2{
pthread_mutex_t lock;
int value;
};
sem_t sem;
SharedInt* sip;
void *functionWithCriticalSection(int* v2) {
pthread_mutex_lock(&(sip->lock));
sip->value = sip->value + *v2;
pthrea... | 0 |
#include <pthread.h>
static unsigned long mapblocksize;
static unsigned long root2;
unsigned char bitmap[125];
unsigned char *sievemap;
static int gnum_threads, sievebit = 2;
pthread_mutex_t sievemutex;
pthread_mutex_t *blockmutex;
unsigned long sieve = 2, sieveblock = 0;
void errExit(... | 1 |
#include <pthread.h>
unlong number_in_circle = 0;
unlong points_per_thread;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *runner() {
unlong number_in_circle_in_thread = 0;
unsigned int rand_state = rand();
unlong i;
for (i = 0; i < points_per_thread; i++) {
d... | 0 |
#include <pthread.h>
int start_recovery()
{
pthread_mutex_lock(&lock);
struct marked_for_recovery* head;
head = (struct marked_for_recovery*)malloc(sizeof(struct marked_for_recovery));
head->link = 0;
int field1;
char field2[MAX];
char field3[MAX];
char field4[MAX];
FILE* fd = 0;
... | 1 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void clock_gettime(int id, struct timesec *tsp) {
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
... | 0 |
#include <pthread.h>
struct CircularQueue{
int rear;
int front;
int queue[5];
int full;
int empt;
};
struct Thread{
int id;
pthread_t thread;
};
pthread_mutex_t mutex;
struct CircularQueue *cq;
void initialize(struct CircularQueue *cq){
cq->rear = -1;
cq->front = -1;
cq->full = ... | 1 |
#include <pthread.h>
static struct tree_node *create_tree_node(void *value)
{
struct tree_node *node = malloc(sizeof(struct tree_node));
if (node == 0) {
fprintf(stderr, "ERROR: Memory allocation failure.\\n");
}
pthread_mutex_init(&(node->lock), 0);
node->child_count = 0;
node->childre... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long int sum = 0;
void * sum_of_number(void *argv) {
long i = 0;
long * limit_ptr = (long *) argv;
long limit = *limit_ptr;
pthread_mutex_lock(&mutex);
sum = 0;
for (; i <=limit ; i++ ) {
sum += i;
}
sleep(1);
pri... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void *lowprio(void *null)
{
int i;
printf("LOWPRIO : contending for mutex lock \\n");
if(pthread_mutex_lock(&mutex)==0)
{
printf("LOWPRIO : lock acquired\\n");
printf("LOWPRIO : executing critical op ......\\n");
while(i<40000000)
... | 0 |
#include <pthread.h>
{
pthread_mutex_t lock;
pthread_cond_t coda[4][2];
int sospesi[4][2];
int sulponte[2];
} monitor;
monitor m;
void init_monitor(monitor* m)
{
int i = 0;
pthread_mutex_init(&m->lock, 0);
for (i = 0; i<4; i++){
pthread_cond_init(&m->coda[i][0], 0);
pthread_cond_init(&m-... | 1 |
#include <pthread.h>
void *produce(void *resource)
{
int valToAdd = 0,tasksProduced = 0;
while(resource->tasksComplete < resource->NUM_TASKS)
{
valToAdd = rand() % 100;
pthread_mutex_lock(resource->m);
if(resource->totElem > resource->BUFFER_SIZE)
{
exit(1);
}
... | 0 |
#include <pthread.h>
static void *queue_fetch_or_alloc(struct ff_circular_queue *cq,
int index)
{
if (cq->slots[index] == 0)
cq->slots[index] = av_mallocz(cq->item_size);
return cq->slots[index];
}
static void queue_lock(struct ff_circular_queue *cq)
{
pthread_mutex_lock(&cq->mutex);
}
s... | 1 |
#include <pthread.h>
pthread_mutex_t downloader_mutex, parser_mutex;
unsigned long downloaders[MAX_THREADS];
unsigned long parsers[MAX_THREADS];
int downloader_threads = 0;
int parser_threads = 0;
char *fetch(char *link) {
int fd = open(link, O_RDONLY);
if (fd < 0) {
fprintf(stderr, ... | 0 |
#include <pthread.h>
static pthread_mutex_t sig_ops_mutex;
static void sig_utils_init(void)
{
pthread_mutex_init(&sig_ops_mutex, 0);
}
int sig_has_no_handler(int sig)
{
struct sigaction sa;
sigaction(sig, 0, &sa);
if (sa.sa_flags & SA_SIGINFO)
{
return sa.sa_sig... | 1 |
#include <pthread.h>
struct http_procotol
{
char *header;
char *body;
};
{
int curcount;
pthread_mutex_t count_mutex;
} c_client;
struct http_procotol server_answer;
char msg[99999];
char path[99999];
char html[1024];
char *ROOT, *req_params[2];
int shmid;
void *shared_memory = (void ... | 0 |
#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 = (struct foo *)malloc(sizeof(struct foo));
if (fp != 0) ... | 1 |
#include <pthread.h>
int antall;
void *spise(void *);
pthread_t *filosofer;
pthread_mutex_t *gaffler;
struct ider {
int id;
};
int main(void)
{
printf("Type a number: ");
scanf("%d", &antall);
struct ider *send[antall];
pthread_t *filosofer = malloc(sizeof(pthread_t)*antall);
gaf... | 0 |
#include <pthread.h>
int total_words ;
pthread_mutex_t counter_lock = PTHREAD_MUTEX_INITIALIZER;
main(int ac, char *av[])
{
pthread_t t1, t2;
void *count_words(void *);
if ( ac != 3 ){
printf("usage: %s file1 file2\\n", av[0]);
exit(1);
}
total_words = 0;
pthread_create(&t1, 0, count_w... | 1 |
#include <pthread.h>
static char _szFileBuffer[100 + 1];
static int _nBufferPointer;
pthread_mutex_t _muxLock;
void* WriterFunction(void* pvData);
void* ReaderFunction(void* pvData);
void WriteFile(const char * psz, char * pszNumber);
void ReadFile(char * pszBuffer, char * pszNumber);
int ma... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct glob{
int a;
int b;
}obj;
void *updater(void *arg){
printf("child thread has created for updating\\n");
pthread_mutex_lock(&mutex);
obj.a=10;
sleep(1);
obj.b=20;
pthread_mutex_unlock(&mutex);
pthread_e... | 1 |
#include <pthread.h>
int thread_count;
double a, b, h;
int n, local_n;
pthread_mutex_t mutex;
double total;
void *Thread_work(void* rank);
double Trap(double local_a, double local_b, int local_n,
double h);
double f(double x);
int main(int argc, char** argv) {
long i;
... | 0 |
#include <pthread.h>
struct arg_set {
char *fname;
int count;
};
struct arg_set *mailbox = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t flag = PTHREAD_COND_INITIALIZER;
main(int ac, char *av[])
{
pthread_t... | 1 |
#include <pthread.h>
pthread_mutex_t lock1;
void add_log_record_entry(char operation[], char state[], char filename[], int tid)
{
pthread_mutex_lock(&lock1);
FILE *fd = 0;
fd = fopen("journal.txt", "a");
fprintf(fd, "%d, %s, %s, %s\\n", tid, operation, filename, state);
fclose(fd);
pthread_... | 0 |
#include <pthread.h>
int buf[4];
int first_occupied_slot = 0;
int first_empty_slot = 4;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;;
int count;
int pending_posts;
} sem_t;
sem_t sem_prod;
sem_t sem_cons;
void sem_init(sem_t *sem, int new_count) {
pthread_mutex_lock(&mut);
... | 1 |
#include <pthread.h>
char shared[10000];
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void* producer (void* a)
{
int i,j;
pthread_mutex_lock(&mutex);
for (i=0; i<10000-1; i++)
{
shared[i]='p';
for(j=0;j<10000;j++) ;
}
shared[i] = '\\0';
pthread_mutex_unlock(&mutex);
}
void* co... | 0 |
#include <pthread.h>
static int incCount = 0;
static int decCount = 0;
int count;
int incCount;
int decCount;
pthread_mutex_t lock;
int id;
} foo_t;
foo_t *fooInit(int id)
{
foo_t *foo = (foo_t *) malloc(sizeof(foo_t));
if (foo) {
foo->id = id;
foo->c... | 1 |
#include <pthread.h>
static int busy_wait_on_fence(int fence)
{
int error, active;
do {
error = sync_fence_count_with_status(fence, FENCE_STATUS_ERROR);
ASSERT(error == 0, "Error occurred on fence\\n");
active = sync_fence_count_with_status(fence,
FENCE_STATUS_ACTIVE);
... | 0 |
#include <pthread.h>
int num_of_threads = 5;
int end = 0;
pthread_barrier_t barrier;
pthread_mutex_t mut;
int dif = 10000;
struct helper {
int rank;
double localPi;
};
int max = 0;
void* calculate(void *arg) {
int rank = (*((struct helper*)arg)).rank;
(*((struct helper*)arg)).loc... | 1 |
#include <pthread.h>
static int x = 0;
static pthread_mutex_t mlock;
void th1_count();
void th2_count();
void delay( long nanosec );
int main(int argc, char** argv ) {
pthread_t thread1, thread2;
pthread_mutex_init(&mlock, 0);
if (pthread_create(&thread1,
0,
(void *) th1_count,
... | 0 |
#include <pthread.h>
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void error(char *msg)
{
fprintf(stderr, "%s, %s\\n", msg, strerror(errno));
exit(1);
}
int beers = 2000000;
void* drink_lots(void *a)
{
int i;
for (i = 0; i < 100000; i++) {
... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t space_available = PTHREAD_COND_INITIALIZER;
pthread_cond_t data_available = PTHREAD_COND_INITIALIZER;
int b[10];
int size = 0;
int front = 0, rear = 0;
void add_buffer(int i) {
b[rear] = i;
rear = (rear + 1) ... | 0 |
#include <pthread.h>
pthread_t g_thread[8];
pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
int g_mode = -1;
FILE* g_f = 0;
char* g_line = 0;
int g_index = 0;
static void runcmd(char* cmd)
{
while(system(cmd) != 0)
{
LOGE("%s failed", cmd);
usleep(1000000);
}
}
static void setacl(in... | 1 |
#include <pthread.h>
static int N = 4;
int M = 10;
int X = 50;
int Y = 2;
int Z = 5;
int cantPersonas;
sem_t sem_cajeros_disponibles;
sem_t sem_personas_en_fila;
pthread_mutex_t mutex;
bool cajerosMaximo;
void *persona(void *param);
void *cajero(void *param);
void *generarPersona(void *param);
v... | 0 |
#include <pthread.h>
int global_count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *customer_routine(void *arg)
{
while (1) {
pthread_mutex_lock(&mutex);
while (global_count == 0) {
printf("customer %d wait.... | 1 |
#include <pthread.h>
static int n;
static pthread_mutex_t* locks;
void cudaMemcpy()
{
sleep(500);
}
int compute_sums()
{
cudaMemcpy();
}
void* prefix_sum(void* p)
{
int self = * ((int*) p);
printf ("I, %d, have just woken from contemplating existence\\n", self);
pthread_mutex_lock(... | 0 |
#include <pthread.h>
extern int makethread(void *(*) (void *), void *);
struct to_info {
void (*to_fn) (void *);
void *to_arg;
struct timespec to_wait;
};
void
clock_gettime(int fd, struct timespec *tsp)
{
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;
tsp->tv_n... | 1 |
#include <pthread.h>
pthread_mutex_t adz_mutex = PTHREAD_MUTEX_INITIALIZER;
int adz_updated = 0;
char adz_current_text[ADZ_LENGTH];
pthread_mutex_t bookz_mutex = PTHREAD_MUTEX_INITIALIZER;
int bookz_done = 0;
void
display_adz(int fdout)
{
char text[ADZ_LENGTH];
pthread_mutex_lock(&a... | 0 |
#include <pthread.h>
static pthread_mutex_t _lock = PTHREAD_MUTEX_INITIALIZER;
static void cmd_queue_cleanup(struct cmd_queue *q);
int
cmd_queue_init(struct cmd_queue *queue)
{
int err = 0;
pthread_mutex_lock(&_lock);
TAILQ_INIT(&queue->cmdq_head);
err = pthread_mutex_init(&queue->cmd... | 1 |
#include <pthread.h>
int count[] = {0, 0};
pthread_mutex_t waiting[2];
pthread_mutex_t mutex, busy;
void arrive(int direction){
pthread_mutex_lock(&waiting[direction]);
pthread_mutex_lock(&mutex);
count[direction] += 1;
if (count[direction] == 1){
pthread_mutex_unlock(&m... | 0 |
#include <pthread.h>
static pthread_mutex_t check_init_lock = PTHREAD_MUTEX_INITIALIZER;
static int
mutex_pthread_init(void **priv, int just_check)
{
int err = 0;
if(just_check)
pthread_mutex_lock(&check_init_lock);
if(!*priv || !just_check)
{
pthread_mutex... | 1 |
#include <pthread.h>
int fd;
pthread_mutex_t mutex;
void *fun(void *arg)
{
int i=1000;
int n=0;
while(i--)
{
lseek(fd, n, 0);
write(fd, "-", 1);
pthread_mutex_unlock(&mutex);
n+=2;
printf("sls\\n");
}
}
int main(int argc, char* argv[])
{... | 0 |
#include <pthread.h>
extern pthread_mutex_t seq_mutex;
extern int seq_control;
char * createAT_PCMD(int flag, float roll, float pitch, float gaz, float yaw){
char * command = (char*) calloc(64, sizeof(char));
printf("CREATE PCMD : %d/ (%f)%d /(%f)%d /(%f)%d /(%f)%d\\n",
flag,
... | 1 |
#include <pthread.h>
int id;
pthread_t threadConsumidor;
}t_consumidor;
int in;
int out;
int buf[5];
sem_t empty;
sem_t full;
pthread_mutex_t mutex;
}BUFFER;
BUFFER sc;
int fibo[25];
int QTD_CONSUMERS;
int cont = 0;
void* consumer(void* thread);
void* producer();
void pri... | 0 |
#include <pthread.h>
int process_request ( struct client_node *client, char *msg_buffer )
{
int request = * ( ( int * ) msg_buffer + 1 );
switch ( request )
{
case REQUEST_EXIT:
close ( client->sockfd );
remov... | 1 |
#include <pthread.h>
extern int makethread(void *(*)(void *), void *);
struct to_info {
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
void clock_gettime(int id, struct timespec *tsp) {
struct timeval tv;
gettimeofday(&tv, 0);
tsp->tv_sec = tv.tv_sec;... | 0 |
#include <pthread.h>
void displayTurn_action(){
pthread_mutex_lock(shm.tableResourcesMutex);
int turn=getTurn(shm.t);
pthread_mutex_unlock(shm.tableResourcesMutex);
printf("\\nThe current turn is: %d\\n",turn);
}
void playCard_action(){
printf("Your Cards: \\n");
printHandCards(player);
p... | 1 |
#include <pthread.h>
void alu_control(void *not_used){
pthread_barrier_wait(&threads_creation);
char alu_op;
char alu_control_sign = 0;
char cfuncao;
while(1){
pthread_mutex_lock(&control_sign);
if(!cs.isUpdated){
while(pthr... | 0 |
#include <pthread.h>
void *producer1(void *arg);
void *producer2(void *arg);
void *consumer(void *arg);
char buffer[5];
sem_t empty,full;
pthread_mutex_t prod,cons;
int main() {
int res,i;
pthread_t a_thread,b_thread,c_thread;
void *thread_result;
int print_count1 = 0;
sem_i... | 1 |
#include <pthread.h>
void print_matrix(char* label, double **m);
void print_matrix(char* label, double **m) {
int i, j;
printf("%s:\\n", label);
for (i = 0; i < ((((1 << 5)) < (4)) ? ((1 << 5)) : (4)); i++) {
for (j = 0; j < ((((1 << 5)) < (4)) ? ((1 << 5)) : (4)); j++) {
p... | 0 |
#include <pthread.h>
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static void die_with_error(char *message)
{
perror(message);
exit(1);
}
static void radix_tree_init(struct radix_tree *tree, int bits, int radix)
{
if (radix < 1) {
perror("Invalid radix\\n");
return;
}
i... | 1 |
#include <pthread.h>
static const int debug = 1;
static uint8_t _bus = 1;
static int _i2cFile = -1000;
static pthread_mutex_t _lock;
static int _mutex_created = 0;
static void getLock() {
if (!_mutex_created) {
pthread_mutex_init(&_lock, 0);
_mutex_created = ... | 0 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node {
int number;
struct node *next;
} *head = 0;
static void cleanup_handler(void *arg)
{
printf("Cleanup handler of second thread.\\n");
... | 1 |
#include <pthread.h>
void *sorting_thread(void *threadNumber);
void writeTimestamp()
{
long time_now = clock();
printf("%ld ", time_now);
}
char *readFileAsString(char* filepath)
{
int fileSize = 0;
FILE *pFile = fopen(filepath, "rb");
if (pFile == 0)
{
puts("error opening file");
}
... | 0 |
#include <pthread.h>
pthread_key_t index_ips(struct ip_pair **p)
{
pthread_key_t key;
pthread_key_create(&key, 0);
register int8_t i;
for (i = 0; i <= p[0]->total; i++) {
if (pthread_equal(pthread_self(), p[i]->thread)) {
pthread_setspecific(key, p[i]->d_ip);
return key;
}
}
retu... | 1 |
#include <pthread.h>
void *philosopher (void *id);
pthread_mutex_t *chopstick;
int numOfSeats, numOfTurns;
int main (int argc, char **argv)
{
if (argc < 3)
{
printf("Usage: philosophers <number of seats> <number of turns>");
return 1;
}
numOfSeats = atoi(argv[1]);
... | 0 |
#include <pthread.h>
pthread_mutex_t count_mutex;
pthread_cond_t count_empty_cond;
int count = 20;
const int MAX_LEN = 64;
const int INC_RATE = 2;
enum THREAD_ENUM{
FILL_THREAD=0,
EMPTY_THREAD=1,
ALL_THREADS
};
char THREAD_NAMES[ALL_THREADS][MAX_LEN]={
"FILL",
"EMPTY"
... | 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) {
fp... | 0 |
#include <pthread.h>
void mai_print_pagenodes(unsigned long *pageaddrs,int size)
{
int pagenodes[MAXPAGES];
int i;
int err;
printf("Must update Linux Kernel to get this information\\n");
}
double mai_get_time_pmigration()
{
return time_last_pmig;
}
void mai_print_th... | 1 |
#include <pthread.h>
int ticketcount = 10;
pthread_mutex_t lock;
pthread_cond_t cond;
void* salewinds1(void* args)
{
while(1)
{
pthread_mutex_lock(&lock);
if(ticketcount > 0)
{
printf("windows1 start sale ticket!the ticket is:%d\\n",ticketcount);
ticketcount --;
if... | 0 |
#include <pthread.h>
static union free_packet *free_packets;
static union free_packet *next_free_packet;
static size_t count_free_packets;
static pthread_mutex_t mem_lock = PTHREAD_MUTEX_INITIALIZER;
struct packet *playrtp_new_packet(void) {
struct packet *p;
pthread_mutex_lock(&mem... | 1 |
#include <pthread.h>
int contador_global = 0;
pthread_mutex_t lock;
void *exercicio1e2(){
pthread_t tid = pthread_self();
printf("Nova thread criada. TID = %d!\\n",(unsigned int)tid);
pthread_exit(0);
}
void *exercicio3(){
for(int i = 0; i < 100; i++)
contador_global++;
pthread_exi... | 0 |
#include <pthread.h>
static struct timeval start_time;
pthread_mutex_t wait_time_mutex = PTHREAD_MUTEX_INITIALIZER;
double overall_waiting_time;
double getCurrentSimulationTime(){
struct timeval cur_time;
double cur_secs, init_secs;
init_secs = (start_time.tv_sec + (double) start_time.tv_us... | 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) {
pthread_create(&tid, &attr,... | 0 |
#include <pthread.h>
extern int idx, sink;
extern double dsink;
extern void *psink;
void bit_shift_main (void);
void dynamic_buffer_overrun_main (void);
void dynamic_buffer_underrun_main (void);
void cmp_funcadr_main (void);
void conflicting_cond_main (void);
void data_lost_main (void);
void data... | 1 |
#include <pthread.h>
void CONSUMO_ALEATORIO_DE_TIEMPO_DE_CPU(void)
{
static int veces = 0;
veces += getpid() + 1;
veces ^= times(0);
veces %= 8 * 8;
usleep(veces*10);
}
volatile int RECURSO_COMPARTIDO = 0;
pthread_mutex_t mutex;
pthread_cond_t a_leer, a_escribir;
int leyendo, escribiendo;
... | 0 |
#include <pthread.h>
int sum=0;
pthread_mutex_t lock;
pthread_t *rowthread,*colthread,*calculationthread;
int nRows,nCols,nThread;
int **MatrixA,**MatrixB,**MatrixC;
int offsetR,offsetC;
void * MultiplyandAdd(void *arg)
{
int sum=0;
int *a=(int *)arg;
int i=*a;
int j=*++a;
int offset=*++a... | 1 |
#include <pthread.h>
static int logged = 0;
pthread_mutex_t lock;
void original_log(char * str)
{
if (logged) return;
debug_log(str);
logged = 1;
}
void debug_log(char * str)
{
printf("%s : %s\\n", __func__, str);
}
void log(char * str)
{
pthread_mutex_lock(&lock);
if (!logged) {
... | 0 |
#include <pthread.h>
void pickup(int j);
void putdown(int i);
void test(int k);
void philosopher(int * id);
pthread_mutex_t lock;
char state[50];
pthread_cond_t self;
int num_phil;
int main(int argc,char *argv[]){
int n, *who;
pthread_t phils[50];
void * retval;
if(argc != 2) {
... | 1 |
#include <pthread.h>
struct record{
int count;
pthread_mutex_t mutex;
};
struct record *mutex_init()
{
struct record *fp;
fp = malloc(sizeof(struct record));
if(fp != 0)
{
fp->count = 100;
if(pthread_mutex_init(&fp->mutex, 0)!=0)
{
free(fp);
return 0;
}
return fp;
}
pri... | 0 |
#include <pthread.h>
static pthread_mutex_t *lockarray;
static void lock_callback(int mode, int type, char* file, int line) {
(void) file;
(void) line;
if (mode & CRYPTO_LOCK) {
pthread_mutex_lock(&(lockarray[type]));
}
else {
pthread_mutex_unlock(&(lockarray[type]));
}
}
static un... | 1 |
#include <pthread.h>
extern int g_mid;
extern pthread_mutex_t g_cmap_lock;
extern struct cmap *g_cmap;
extern struct msgr *g_msgr[];
int mds_send_hb_thread(struct redfish_thread *rt)
{
struct mtran *tr;
struct bsend *ctx;
int succ, i, num_mds, ret, first, use_timer_a, num_sent;
struct... | 0 |
#include <pthread.h>
int fd;
int ini;
int fin;
} arg;
pthread_mutex_t mx;
int codeF[256] = {0};
void codes (arg *args) {
int i, j, l, code[256] = {0};
unsigned char c[65536];
if (lseek (args->fd, args->ini, 0)<0) {printf ("LSEEK...\\n"); exit(1);}
for (i = args->ini + 65536... | 1 |
#include <pthread.h>
int nextid;
pthread_mutex_t nextid_mutex;
int* array;
int* sum;
int num_threads;
int nums_per_thread;
int counter;
pthread_mutex_t counter_mutex;
sem_t* barrier_sem;
} Shared;
int sem_post_n(sem_t *sem, int n) {
int i, ret;
for (i = 0; i<n; i++) {
ret = sem_po... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
void *
threadA(void *param )
{
int i;
for (i = 0; i < 5; i++) {
pthread_mutex_lock(&mutex1);
printf("threadA --> %d iteration\\n", i);
sleep(rand() % 3);... | 1 |
#include <pthread.h>
int buffer[100];
int nextp, nextc;
int count=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void printfunction(void * ptr)
{
int count = *(int *) ptr;
if (count==0)
{
printf("All items produced are consumed by the consumer \\n");
}
else
{
for (int i=0; i<=... | 0 |
#include <pthread.h>
int
pthread_rwlock_tryrdlock (pthread_rwlock_t * rwlock)
{
int result;
pthread_rwlock_t rwl;
if (rwlock == 0 || *rwlock == 0)
{
return EINVAL;
}
if (*rwlock == PTHREAD_RWLOCK_INITIALIZER)
{
result = pte_rwlock_check_need_init (rwlock);
... | 1 |
#include <pthread.h>
pthread_mutex_t value_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t value2_lock = PTHREAD_MUTEX_INITIALIZER;
int value = 0;
int value2 = 0;
void* thread_func1(void *arg)
{
pthread_mutex_lock(&value_lock);
int count = 1;
while (count++ <= 5) {
value += 1;
printf("t... | 0 |
#include <pthread.h>
struct valueset {
int min;
int max;
int next_size;
int next_off;
uint8_t *buf;
pthread_mutex_t lock;
int seq;
};
struct valueset *
valueset_init(int min, int max)
{
struct valueset *vs;
int i;
vs = malloc(sizeof(*vs));
memset(vs, 0, sizeof(*vs));
pthr... | 1 |
#include <pthread.h>
struct aqueue {
size_t length, offset;
unsigned pos;
bool closed;
pthread_cond_t pushwait, popwait;
pthread_mutex_t mutex;
void *buffer[];
};
struct aqueue *aqueue_create(size_t length)
{
struct aqueue *q = xmalloc(sizeof *q + length * sizeof *q->... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.