text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
extern int verbose;
extern int ddssock;
extern pthread_mutex_t dds_comm_lock;
void dds_exit(void *arg)
{
int *sockfd = (int *) arg;
pthread_t tid;
tid = pthread_self();
}
void *dds_register_seq(void *arg)
{
struct DriverMsg msg;
struct ControlProgram *control_pro... | 1 |
#include <pthread.h>
int beers = 2000000;
pthread_mutex_t beers_lock = PTHREAD_MUTEX_INITIALIZER;
void* drink_lots(void *a)
{
int i;
if (2 == 1) {
pthread_mutex_lock(&beers_lock);
for (i = 0; i < 100000; i++) {
beers -= 1;
}
pthread_mutex_un... | 0 |
#include <pthread.h>
int cmpfunc (const void * a, const void * b)
{
if (*(double*)a > *(double*)b) return 1;
else if (*(double*)a < *(double*)b) return -1;
else return 0;
}
int checkForDuplicate(struct threaddata* thread_data_array, int noElevators, int floor, int direction)
{
... | 1 |
#include <pthread.h>
void subsec(void);
void second(void);
void minute(void);
void display(void);
pthread_mutex_t countmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_threshold_subsec;
pthread_cond_t count_threshold_second;
struct Watch {
int minute;
int second;
int subsec;
} watch_... | 0 |
#include <pthread.h>
struct mq_s {
mq_t *next;
int data;
};
mq_t *wq;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t c_lock = PTHREAD_MUTEX_INITIALIZER;
void* process_msg(void *arg) {
mq_t *mp;
for ( ; ; ) {
pthread_mutex_lock(&c_lock);
pri... | 1 |
#include <pthread.h>
pthread_mutex_t* lock;
pthread_mutex_t lock2;
pthread_mutex_t lock3;
pthread_t *SCV;
int workers = 5;
int minerals = 5000;
int remaining_minerals = 5000;
int collected_minerals = 0;
int soldiers = 0;
int scv_alloc_counter = 6;
int mutex_alloc_counter = 2;
void* thread_func(void... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int message[] = {79,59,12,2,79,35,8,28,20,2,3,68,8,9,68,45,0,12,9,67,68,4,7,5,23,27,1,21,79,85,78,79,85,71,38,10,71,27,12,2,79,6,2,8,13,9,1,13,9,8,68,19,7,1,71,56,11,21,11,68,6,3,22,2,14,0,30,79,1,31,6,23,19,10,0,73,79,44,... | 1 |
#include <pthread.h>
char buffer[128];
int buffer_has_data=0;
pthread_mutex_t mutex;
pthread_cond_t cond;
void write_buffer(char *data)
{
pthread_mutex_lock(&mutex);
if(buffer_has_data==0)
{
sprintf(buffer,"%s",data);
buffer_has_data=1;
pthread_cond_signal(&cond);
}
printf("write ... | 0 |
#include <pthread.h>
pthread_mutex_t chopstick[5];
void *thread_func(int n);
int main()
{
int i,res;
pthread_t a_thread[5];
for(i=0;i<5;++i)
{
res=pthread_mutex_init(&chopstick[i],0);
if(res==-1)
{
perror("mutex initialization failed");
exit(1);
}
}
for(... | 1 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition_var = PTHREAD_COND_INITIALIZER;
int printers = 0;
void * print_job_requester(void * printjobno){
pthread_mutex_lock(&mutex1);
if(printers == 3)
pthread_cond_wait(&condition_var, &mutex1)... | 0 |
#include <pthread.h>
pthread_t notifier_tid = 0;
static void print_host_event( char etype, uint32_t ip) {
char mac_str[17 + 1],
ip_str[INET_ADDRSTRLEN + 1],
*etype_str,
*name,
next_etype;
struct host *h;
if(!inet_ntop(AF_INET, &(ip), ip_str, INET_ADDRSTRLEN))... | 1 |
#include <pthread.h>
int sem_init(sem_t * sem, int pshared, unsigned int value)
{
sem->count=value;
pthread_cond_init(&sem->cond, 0);
pthread_mutex_init(&sem->mutex, 0);
return 0;
}
int sem_destroy(sem_t * sem)
{
int err1,err2;
err1=pthread_cond_destroy(&sem->cond);
... | 0 |
#include <pthread.h>
int (* lock) (pthread_mutex_t *mutex);
int (* unlock) (pthread_mutex_t *mutex);
}cts_thread_fns;
static cts_thread_fns cts_thread_funtions =
{
pthread_mutex_lock,
pthread_mutex_unlock
};
static pthread_mutex_t conn_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex... | 1 |
#include <pthread.h>
pthread_cond_t enterLounge;
pthread_mutex_t lock;
int occupancy;
int waitingDeans;
void init() {
pthread_mutex_init(&lock, 0);
pthread_cond_init(&enterLounge, 0);
occupancy = 0;
waitingDeans = 0;
sign = 0;
return;
}
void mathProfArrive() {
pthrea... | 0 |
#include <pthread.h>
struct randgen_msgbuf {
long type;
double number;
};
int randgen_buffer_size = -1;
int randgen_qid;
pthread_t randgen_supplier_tid;
pthread_mutex_t randgen_supplier_lock;
int randgen_supplier_status;
void* randgen_supplier(void* context) {
if (context... | 1 |
#include <pthread.h>
struct jobcontrol;
struct jobarg
{
int number;
int running;
struct jobcontrol *jc;
int result;
int N;
char *box1;
char *box2;
};
struct jobcontrol
{
FILE *in, *out;
pthread_cond_t jobdone;
pthread_mutex_t lock;
int next_job;
struct jobarg *arg;
pthread_t *tid... | 0 |
#include <pthread.h>
static char running = 1;
static unsigned long counter = 0;
static useconds_t micsec = 1000;
pthread_mutex_t c_mutex;
int i;
void *process(void *arg)
{
while (running)
{
pthread_mutex_lock(&c_mutex);
if (i > 4)
{
pthread_exit(0);
}
counter++;
pthread_mutex_... | 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 *param)
{
pthread_mutex_l... | 0 |
#include <pthread.h>
size_t const thread_no = 64000000;
char mess[] = "This is a test";
void *message_print(void *ptr){
int error = 0;
int signal_exit = (SIGRTMIN+10);
sigset_t signal_set;
siginfo_t info;
struct timespec timer;
timer.tv_sec = 10;
timer.tv_nsec = 0;
int status;
... | 1 |
#include <pthread.h>
int n, m;
int *v;
int *e;
int *w;
int *c;
int *f;
int *u;
int mssp;
int work_mssp;
pthread_mutex_t lock_c = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_work_mssp = PTHREAD_MUTEX_INITIALIZER;
int min(int a, int b) {
if (a > b)
return b;
else
r... | 0 |
#include <pthread.h>
static pthread_mutex_t log_mutex_lock_ = PTHREAD_MUTEX_INITIALIZER;
static char log_msg_buf_[256];
void ixsys_print_init()
{
}
void ixsys_print(int err_flag, char *format, ...)
{
va_list args;
pthread_mutex_lock(&log_mutex_lock_);
__builtin_va_start((ar... | 1 |
#include <pthread.h>
static int ft_fd = -1;
static pthread_mutex_t cmd_mutex;
void ft_send_cmd(const char *fmt, ...)
{
char cmdBuffer[80] = {0,};
va_list args;
pthread_mutex_lock(&cmd_mutex);
__builtin_va_start((args));
vsnprintf(cmdBuffer,sizeof(cmdBuffer),fmt, args);
;
ALOGE("fm_... | 0 |
#include <pthread.h>
struct thermal_sensor_data {
pthread_t thermal_sensor_thread;
pthread_mutex_t thermal_sensor_mutex;
pthread_cond_t thermal_sensor_condition;
int threshold_reached;
int sensor_shutdown;
struct sensor_info *sensor;
};
static void *thermal_sensor_uevent(void *data)
{
int ... | 1 |
#include <pthread.h>
int q_main,flag_main;
pthread_mutex_t mtx_main;
pthread_mutex_t cond_main;
int q_roll, flag_roll;
pthread_mutex_t mtx_roll;
pthread_mutex_t cond_roll;
int q_pass, flag_pass;
pthread_mutex_t mtx_pass;
pthread_mutex_t cond_pass;
int wait_pas = 0;
void *passenger();
void *r... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_spinlock_t lock;
pthread_cond_t cond;
pthread_mutex_t mutex_cond;
void exit_handler(void *voidptr) {
int argument = *((int *)voidptr);
}
void* thread_function(void *voidptr) {
int argument = *((int *)voidptr);
pthread_clean... | 1 |
#include <pthread.h>
pthread_cond_t empty_slot = PTHREAD_COND_INITIALIZER;
pthread_cond_t avail_item = PTHREAD_COND_INITIALIZER;
pthread_mutex_t buflock = PTHREAD_MUTEX_INITIALIZER;
char buffer[10][12];
int in = 0, out = 0, count = 0;
FILE *inputfile, *outputfile;
pthread_t t[2];
void* produce... | 0 |
#include <pthread.h>
static const size_t INITIAL_CAPACITY = 1024;
unsigned int* array;
unsigned int* front;
unsigned int* back;
size_t capacity;
size_t size;
} Sockets;
static Sockets sockets = { 0, 0, 0, 0, 0 };
static pthread_mutex_t m_qaccess;
static pthread_cond_t c_isItem;
stati... | 1 |
#include <pthread.h>
int matrixSize, num, thr;
double matrix[15][15];
double result[1000], sum;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
double calDet(double **matrix, int size) {
if (size == 1)
return matrix[0][0];
int subk;
double result = 0.0;... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void prepare()
{
pthread_mutex_lock(&mutex);
printf("I'm prepare\\n");
}
void parent()
{
pthread_mutex_unlock(&mutex);
printf("I'm parent\\n");
}
void child()
{
pthread_mutex_unlock(&mutex);
printf("I'm child\\... | 1 |
#include <pthread.h>
pthread_mutex_t regiao_critica = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t buffer_cheio = PTHREAD_COND_INITIALIZER;
pthread_cond_t buffer_vazio = PTHREAD_COND_INITIALIZER;
int posicoes_ocupadas=0;
int valor=0;
int buffer[50];
void *produtor(void *argumentos){
while (... | 0 |
#include <pthread.h>
enum estados_signo{VACIO,MUJERES,HOMBRES};
enum estados_signo signo = VACIO;
enum generos{MUJER,HOMBRE};
sem_t capbano_sem, espmujeres_sem, esphombres_sem;
pthread_mutex_t mujespc_mutex, homespc_mutex, persc_mutex,signo_mutex;
int mujespc,homespc,persc;
void *persona(void* ... | 1 |
#include <pthread.h>
struct rs_mutex {
pthread_mutex_t mutex;
pthread_mutexattr_t attr;
};
struct rs_mutex *rs_mutex_alloc() {
struct rs_mutex *rmtx = (struct rs_mutex *) malloc(sizeof(struct rs_mutex));
if (rmtx == 0) return 0;
if (pthread_mutexattr_init(&rmtx->attr)) {
... | 0 |
#include <pthread.h>
void do_one_thing(int *);
void do_another_thing(int *);
void do_wrap_up(int, int);
int r1 = 0, r2 = 0, r3 = 0;
pthread_mutex_t r3_mutex=PTHREAD_MUTEX_INITIALIZER;
extern int
main(int argc, char **argv)
{
pthread_t thread1, thread2;
if (argc > 1)
r3 = atoi(argv[1]);
... | 1 |
#include <pthread.h>
pthread_mutex_t queueMutex;
pthread_mutex_t secOneMutex;
pthread_mutex_t secTwoMutex;
pthread_mutex_t secThreeMutex;
sem_t removeAlarm;
int ID_BASE = 100;
int first_Section[20];
int firstSecCounter = 0;
int second_Section[20];
int third_Section[20];
int GS_front = -1, RS... | 0 |
#include <pthread.h>
void synchronize (int total_threads)
{
static pthread_mutex_t mutex
= PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t condvar_in
= PTHREAD_COND_INITIALIZER;
static pthread_cond_t condvar_out
= PTHREAD_COND_INITIALIZER;
static int threads_in = 0;
s... | 1 |
#include <pthread.h>
void RowSwitch_pthread(int **A, int row);
void *FindMax(void *thr_arg);
void RowSwitch_sequential(int **A, int row);
void PrintArray(int **A);
struct thread_data {
int st;
int ed;
int column_num;
};
struct thread_data thread_data_array[2];
uint64_t time_findmaxp = 0;... | 0 |
#include <pthread.h>
pthread_t gRubyThread;
pthread_mutex_t gMainLock;
pthread_cond_t gRubyDone;
void* the_ruby_thread(void* aRubyProgram)
{
printf("Ruby thread is starting interpreter\\n");
ruby_run_node(aRubyProgram);
printf("Ruby thread is done, waking up C program...\\n");
p... | 1 |
#include <pthread.h>
void wrightchanger_nomutex();
void edgeworthchanger_nomutex();
void wrightchanger_mutex();
void edgeworthchanger_mutex();
char *firstname;
char *lastname;
pthread_mutex_t attorneymutex;
int main(int argc, char *argv[]) {
int i;
pthread_t t1,t2;
firstname=malloc(32);
... | 0 |
#include <pthread.h>
void *connection_handler(void* socket_desc){
int client_socket = *(int*)socket_desc;
while(1){
uint8_t client_message[2000];
int recv_value;
recv_value = recv(client_socket, client_message, sizeof(client_message),0);
if(recv_value==0){
... | 1 |
#include <pthread.h>
int shmd;
long shimid;
key_t key = 66607;
int LEN = 1024;
struct ipcstruct *mystruct;
struct ipcstruct {
int value;
int size;
int cachesending;
int proxysending;
pthread_mutex_t memMutex;
pthread_cond_t cvProxyGo;
pthread_cond_t cvCacheGo;
};
static void _sig_handl... | 0 |
#include <pthread.h>
int i;
int acount=0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condVar = PTHREAD_COND_INITIALIZER;
int accessible = 1;
void waitMySemaphor(int amountToWithdraw);
void signalMySemphor();
void *threadClientWithdrawer(void* args);
void *threadClientDep... | 1 |
#include <pthread.h>
void callback(int op, int arg1, int arg2)
{
printf("callback(%d, %d, %d) called\\n", op, arg1, arg2);
}
int ile = 0;
pthread_mutex_t mutex;
void *watek (void *data)
{
pid_t pid = getpid();
pid_t id = pthread_self();
pthread_mutex_lock(&mutex);
ile++;
pthread_m... | 0 |
#include <pthread.h>
int value;
int th;
pthread_mutex_t mutex;
}Best;
pthread_mutex_t mutex;
sem_t sem;
int count;
}Barrier;
Barrier barrier;
Best best;
sem_t sem;
void sigfunc(int signo);
void fill_rand(int *vektor, int size, int max, int flag);
void *thFunc(void *arg);
int main... | 1 |
#include <pthread.h>
static double a[1024][1024];
static double b[1024][1024];
static double c[1024][1024];
pthread_mutex_t locks[1024][1024];
pthread_t threads[8];
static void
init_matrix(void)
{
int i, j;
for (i = 0; i < 1024; i++)
for (j = 0; j < 1024; j++) {
a[i][j] ... | 0 |
#include <pthread.h>
extern pthread_attr_t pthread_attr_default;
pthread_mutex_t lock;
long lmsize = 102400;
unsigned long long ll;
long syscalls = 300;
void sighand(int sig)
{
unsigned long i;
switch(sig){
case SIGDANGER:{
printf("Received sigdanger - S... | 1 |
#include <pthread.h>
void * taquillas(void *);
void * web(void *);
void * movil(void *);
pthread_mutex_t *mutex_silla;
int* sillas;
int main(int argc, const char * argv[]) {
int i;
mutex_silla = (pthread_mutex_t*)malloc(10*sizeof(pthread_mutex_t));
for (i=0;i<10;++i){
pthre... | 0 |
#include <pthread.h>
int sum = 0;
pthread_cond_t slots = PTHREAD_COND_INITIALIZER;
pthread_cond_t items = PTHREAD_COND_INITIALIZER;
pthread_mutex_t slot_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t item_lock = PTHREAD_MUTEX_INITIALIZER;
int nslots = 8;
int producer_done = 0;
int ... | 1 |
#include <pthread.h>
{
int lines;
int columns;
int position;
long ** matrix;
pthread_mutex_t MTX;
} matrix_attr;
long SortAndReturnMedian(long * array, int size);
long ** Read(int m, int n);
void Print(long ** matrix, int m, int n);
void CalculateOneLine(matrix_attr * M);
... | 0 |
#include <pthread.h>
struct msg {
int id;
struct msg* next;
};
pthread_cond_t ready = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
struct msg* queue;
void walk() {
struct msg* q = queue;
while (q) {
printf("%d->", q->id);
q = q->next;
}
printf... | 1 |
#include <pthread.h>
{
int data;
struct node *next;
}node_t,*node_p,**node_pp;
node_p head=0;
void alloc_node(node_pp node,int data)
{
*node=(node_p)malloc(sizeof(node_t));
node_p newnode=*node;
newnode->data=data;
newnode->next=0;
}
void init()
{
alloc_node(&head,0);
}
int is_emp... | 0 |
#include <pthread.h>
pthread_t pong_thread;
pthread_t ping_thread;
struct thread_arg ta;
void start_pong()
{
int err = pthread_create(&pong_thread, 0, pong_main_thread, &ta);
if (err == -1) {
fprintf(stderr, "Could not create pong_main_thread thread.\\n");
exit(1);
}
}
void start_ping... | 1 |
#include <pthread.h>
pthread_mutex_t shopLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t customerReady = PTHREAD_COND_INITIALIZER;
pthread_cond_t barberReady = PTHREAD_COND_INITIALIZER;
int waiting_customers = 0;
int wartenummer = 1;
int abgearbeitet = 0;
int chair_count;
struct thread_args {
... | 0 |
#include <pthread.h>
pthread_mutex_t m_access;
pthread_mutex_t m_read_num;
pthread_mutex_t is_write;
int read_num = 0;
char buf[1024];
void *read_hand(void * arg)
{
pthread_detach(pthread_self());
pthread_mutex_lock( &is_write);
pthread_mutex_unlock( &is_write );
pthread_mutex_lock(&m_read_n... | 1 |
#include <pthread.h>
int val = 0;
pthread_mutex_t m;
void recurse(int arg)
{
int ret = pthread_mutex_lock(&m);
if (ret) {
printf("child: mutex already locked\\n");
return;
}
if (arg) {
val += 1;
recurse(arg - 1);
}
pthread_mutex_unlock(&m... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond_var;
int chopstick[6]={1};
void pickup_forks(int philosopherNumber){
pthread_mutex_lock(&mutex);
while (!(chopstick[philosopherNumber] && chopstick[(philosopherNumber+1)%5])) {
pthread_cond_wait(&cond_var, &mutex);
printf("The... | 1 |
#include <pthread.h>
char coup_tcp[13];
char coup_part[13];
char rdy = 0;
pthread_mutex_t synchro_mutex;
pthread_cond_t synchro_cv;
char * send_plateau_a()
{
static int player = 0;
static int first = 1;
static pthread_t th;
int retour = 0;
if (first)
{
first = 0;
c... | 0 |
#include <pthread.h>
struct mt
{
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
void sys_err(char *arg) {
perror(arg);
}
int main(int argc, char const *argv[])
{
int fd, i, err;
struct mt *mm;
pid_t pid;
fd = open("mt_test", O_CREAT | O_RDWR, 0644);
ftruncate(fd, s... | 1 |
#include <pthread.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static int *pipes;
static int num_pipes, num_active, num_threads, num_evts;
static int epfd;
static int epet;
static int stop;
static unsigned long long getustime(void) {
struct timeval tm;
gettimeofday(&tm, ... | 0 |
#include <pthread.h>
int mediafirefs_mknod(const char *path, mode_t mode, dev_t dev)
{
printf("FUNCTION: mknod. path: %s\\n", path);
(void)path;
(void)mode;
(void)dev;
struct mediafirefs_context_private *ctx;
ctx = fuse_get_context()->private_data;
pthread_mutex... | 1 |
#include <pthread.h>
extern int timingsock;
extern pthread_mutex_t timing_comm_lock;
extern int verbose;
extern struct TRTimes bad_transmit_times;
void *timing_ready_controlprogram(struct ControlProgram *arg)
{
struct DriverMsg msg;
pthread_mutex_lock(&timing_comm_lock);
if (arg!=0) {
... | 0 |
#include <pthread.h>
void *thread_function (void *arg);
int test_ready = 0;
int can_terminate = 0;
int hw_watch_count = 0;
static int watched_data[4];
pthread_mutex_t data_mutex;
int
main ()
{
int res;
pthread_t threads[4];
int i;
pthread_mutex_init (&data_mutex, 0);
for (i... | 1 |
#include <pthread.h>
static pthread_mutex_t mutex;
static pthread_cond_t teller_available;
int id;
int checked_in;
int doing_service;
pthread_cond_t done;
pthread_t thread;
struct teller_info_t *next;
struct teller_info_t *end;
} *p_teller;
static p_teller teller_list = 0;
... | 0 |
#include <pthread.h>
static int const buff_size = 1024;
unsigned int convert(char* string){
int a = atoi(strtok(string, "."));
int b = atoi(strtok(0, "."));
int c = atoi(strtok(0, "."));
int d = atoi(strtok(0, "."));
unsigned int ipInteger = a * pow(256, 3) + b * pow(256, 2) + c * pow(256... | 1 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
int main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
... | 0 |
#include <pthread.h>
int numberOfThreads = 2;
int numberOfBarriers = 100;
pthread_mutex_t lock;
{
int receivingCount;
int sentCount;
int threadID;
}Thread;
void disseminationBarrier(Thread* thread,Thread** threadList,int threadId)
{
int r,s = 0,t,neighborIndex;
int numOfRoun... | 1 |
#include <pthread.h>
pthread_t barman, firstDude, secondDude, thirdDude;
pthread_mutex_t fridge;
int bottleInFridge = 10;
int visit[3][3];
int stage = 0;
bool barmanIsBusy = 0;
void *barmanOps(){
pthread_mutex_init(&fridge, 0);
srand((unsigned int)time(0));
while(1){
if(rand... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
pthread_cond_t cond;
{
int data;
struct node *next;
}node_t,*node_p,**node_pp;
node_p head = 0;
static node_p alloc_node(int data)
{
node_p temp = (node_p)malloc(sizeof(node_t));
if(0 == temp)
{
perror("malloc");
return 0;
}
temp->data = dat... | 1 |
#include <pthread.h>
void *ssu_thread1(void *arg);
void *ssu_thread2(void *arg);
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond1 = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2 = PTHREAD_COND_INITIALIZER;
int count =... | 0 |
#include <pthread.h>
static pthread_barrier_t barrier;
int Global;
pthread_mutex_t mtx;
void *Thread1(void *x) {
barrier_wait(&barrier);
pthread_mutex_lock(&mtx);
Global++;
pthread_mutex_unlock(&mtx);
return 0;
}
void *Thread2(void *x) {
Global--;
barrier_wait(&barrier);
retur... | 1 |
#include <pthread.h>
struct service {
int req[64];
int res[64];
int status;
};
struct service *queue[32];
int rqueue, wqueue, nr_queue;
pthread_mutex_t mtx1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mtx2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mtx3 = PTHREAD_MUTEX_INITIALIZER;
pthread_... | 0 |
#include <pthread.h>
int main(int argc, char ** argv) {
inicializar_variables();
inicializar_semaforos();
nombreMapa = string_duplicate(argv[1]);
crear_archivo_log();
signal(SIGUSR2, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGUSR1, signal_handler);
if (chequear_ar... | 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;
void startOxygen(){
pthread_mutex_lock(&lock);
++activeOxygen;
++curren... | 0 |
#include <pthread.h>
int readers;
int writer;
pthread_cond_t readers_proceed;
pthread_cond_t writer_proceed;
int pending_writers;
pthread_mutex_t read_write_lock;
} mylib_rwlock_t;
void mylib_rwlock_init (mylib_rwlock_t *l) {
l -> readers = l -> writer = l -> pendin... | 1 |
#include <pthread.h>
pthread_mutex_t x,wsem;
pthread_t tidC[20],tidP[20];
int readcount;
void intialize()
{ printf("\\nhello\\n");
pthread_mutex_init(&x,0);
pthread_mutex_init(&wsem,0);
readcount=0;
}
void *reader (void *param)
{
int waittime;
int *ind = (int *)param;
pr... | 0 |
#include <pthread.h>
pthread_mutex_t lock;
float Vals[1000];
float **s;
int tid;
}sumArgs;
float **s;
float avg;
int tid;
}stdArgs;
void *calcAverage(void *param){
pthread_mutex_lock(&lock);
sumArgs *args = (sumArgs *)param;
while(args->tid < 1000){
args->s[0][0] += Vals[args->tid]... | 1 |
#include <pthread.h>
static pthread_mutex_t build_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t build_cond = PTHREAD_COND_INITIALIZER;
static uint64_t dirtyPaths;
static char **paths;
static int pathCount;
extern char **environ;
static int WatchSubdirs_printHelp;
static int WatchSu... | 0 |
#include <pthread.h>
{
int add;
int take;
int buffer[10];
}product;
product proBuff = {0,0,{0}};
unsigned int proId = 1;
pthread_mutex_t mutex;
sem_t full;
sem_t empty;
void *Gen(void *id)
{
while(1)
{
pthread_mutex_lock(&mutex);
if(!(((proBuff.add + 1) % 10 )... | 1 |
#include <pthread.h>
pthread_mutex_t turno;
pthread_mutex_t mutex;
pthread_mutex_t db;
int rc = 0;
void* reader(void *arg);
void* writer(void *arg);
void read_data_base();
void use_data_read();
void think_up_data();
void write_data_base();
int main() {
pthread_mutex_init(&mutex, 0);
pthr... | 0 |
#include <pthread.h>
int g_buffer[5];
unsigned short in = 0;
unsigned short out = 0;
unsigned short produce_id = 0;
unsigned short consume_id = 0;
sem_t g_sem_full;
sem_t g_sem_empty;
pthread_mutex_t g_mutex;
pthread_t g_thread[2 + 2];
void *consume(void *arg){
int i;
int num = (int)ar... | 1 |
#include <pthread.h>
int input[MAX_NUMS];
int output[100];
int inC=0;
int no=0;
pthread_t tid,producer_thread[2],consumer_thread[3];
pthread_mutex_t Lock;
sem_t full,empty;
pthread_attr_t defattr;
void* producer(void* var){
int item,i;
for(i=0;i<MAX_NUMS;i++){
item=(rand()%100)+1;
sem... | 0 |
#include <pthread.h>
struct int_channel{
int queue[100];
int front;
int back;
int MAX_SIZE;
int size;
bool poisoned;
pthread_mutex_t lock;
pthread_cond_t write_ready;
pthread_cond_t read_ready;
};
int init_int_channel(struct int_channel *channel){
if(pthrea... | 1 |
#include <pthread.h>
const int THREAD_COUNT=100000;
pthread_mutex_t ex_mutex;
void *threadFunc(void *threadId)
{
int tid = (int)(threadId);
fprintf(stdout,"Performing task inside thread %d\\n",tid);
if(tid % 2 == 0)
{
pthread_mutex_lock(&ex_mutex);
if(tid % 50 == 0)
{
pthread_mutex_... | 0 |
#include <pthread.h>
int available_resources = 5;
pthread_mutex_t mutex;
sem_t empty;
sem_t full;
int increase_count(int count);
int decrease_count(int count);
void* producer(void *a);
void* consumer(void *a);
int main() {
int NUM_PRODUCER,NUM_CONSUMER, SLEEP;
srand(time(0));
NUM_CONSUME... | 1 |
#include <pthread.h>
int myglobal;
pthread_mutex_t mymutex=PTHREAD_MUTEX_INITIALIZER;
void *thread_function(void *arg) {
int i,j;
for ( i=0; i<20; i++ ) {
pthread_mutex_lock(&mymutex);
j=myglobal;
j=j+1;
printf(".");
fflush(stdout);
sleep(1);
myglobal=j;
pthread... | 0 |
#include <pthread.h>
static void *producerFunc(void *info);
static void *consumerFunc(void *info);
sem_t full;
sem_t empty;
pthread_mutex_t lock;
int pIndex = 0;
int cIndex = 0;
struct producerInfo {
int threadNumber;
int counter;
int toProduce;
int *buff;
int bufferSize;
};
struct con... | 1 |
#include <pthread.h>
int sum = 0;
pthread_cond_t slots = PTHREAD_COND_INITIALIZER;
pthread_cond_t items = PTHREAD_COND_INITIALIZER;
pthread_mutex_t slot_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t item_lock = PTHREAD_MUTEX_INITIALIZER;
int nslots = 8;
int producer_done = 0;
int ... | 0 |
#include <pthread.h>
pthread_t *threads;
int thread_count;
} thread_pool;
thread_pool *tids;
pthread_mutex_t lock;
void* doSomeThing(int *pId)
{
pthread_mutex_lock(&lock);
unsigned long i = 0;
const char progress[] = "|/-\\\\";
for (i = 0; i < 100; i += 10) {
pr... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
int num;
pthread_mutex_t m;
pthread_cond_t empty, full;
void * thread1(void * arg)
{
pthread_mutex_lock(&m);
while (num > 0)
pthread_cond_wait(&empty, &m);
num++;
pthread_mutex_unlock(&m);
pthread_cond_signal(&full);
}
... | 0 |
#include <pthread.h>
int fd_ir = -1;
unsigned char ir_buf[4] = { 0 };
unsigned char flag_ir_thd_exit;
pthread_mutex_t irbuf_mutex;
int IrDeviceCreate(void)
{
if(fd_ir > 0)
{
return -2;
}
if((fd_ir = open("/dev/ir", O_RDWR)) <= 0)
{
LIBHAL_ERROR("open ir devic... | 1 |
#include <pthread.h>
int *carpark;
int capacity;
int occupied;
int nextin;
int nextout;
int cars_in;
int cars_out;
pthread_mutex_t lock;
pthread_cond_t space;
pthread_cond_t car;
pthread_barrier_t bar;
} cp_t;
static void * car_in_handler(void *cp... | 0 |
#include <pthread.h>
{
int data;
struct _Node* next;
}Node,*Node_p,**Node_pp;
Node_p head=0;
static Node_p Alloc_Node(int x)
{
Node_p node=(Node_p)malloc(sizeof(node));
if(node==0)
{
perror("malloc");
exit(0);
}
node->data=x;
node->next=0;
return node;
}
static int IsEmpty(Node_p he... | 1 |
#include <pthread.h>
pthread_mutex_t job_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t job_queue_count;
struct node *next;
char job;
}N;
N* header;
N* tail;
N* current;
N* num;
}Q;
void initialize_job_queue(Q *job_queue)
{
job_queue->header = 0;
job_queue->... | 0 |
#include <pthread.h>
char *archivo;
char *ip;
int num_threads;
int num_ciclos;
char * port;
int *pthread_tim_wait;
int contador = 0;
pthread_mutex_t bloqueo;
void *llamada(void * param)
{
int ciclos;
struct timeval tinicio, tfinal;
int duration;
gettimeofday(&tinicio, 0);
for (ciclos = 0; ... | 1 |
#include <pthread.h>
void* TCPechodd(void*);
void* prstats(void*);
struct{
pthread_mutex_t st_mutex;
unsigned int st_concount;
unsigned int st_contotal;
unsigned long st_contime;
unsigned long st_bytecount;
} stats;
int TCPechoThread(const char *service, int len){
pth... | 0 |
#include <pthread.h>
int ind = 0;
int arr[50];
pthread_mutex_t mutexvar;
pthread_cond_t condvar;
void *myFuncA(void *data)
{
char t = *((char *)data);
int i;
for(i = 0; i < sizeof(arr)/sizeof(int); i++)
{
pthread_mutex_lock(&mutexvar);
if(ind >= sizeof(arr)/sizeof(int))
{
printf("\... | 1 |
#include <pthread.h>extern int __VERIFIER_nondet_int();
int idx=0;
int ctr1=1, ctr2=0;
int readerprogress1=0, readerprogress2=0;
pthread_mutex_t mutex;
void __VERIFIER_atomic_use1(int myidx) {
__VERIFIER_assume(myidx <= 0 && ctr1>0);
ctr1++;
}
void __VERIFIER_atomic_use2(int myidx) {
... | 0 |
#include <pthread.h>
void* register_read(void* data)
{
int clock_start = 0;
int new_instruction = 1;
CLOCK_ZERO_READ[0] = 1;
while (1)
{
if (STOP_THREAD == 1)
{
pipeline[0].instr.Itype = NO_OP;
pipeline[0].instr.Ctype = NO_OP;
temp_pipeline[0].instr.Itype = ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex_lock;
sem_t students_sem;
sem_t ta_sem;
int waiting_students = 0;
volatile int seats[2] = {0};
volatile int empty_chair;
volatile int next_stud;
int occupied=0;
void initialize()
{
sem_init(&ta_sem,1,0);
sem_init(&students_sem,1,0);
pthread_mu... | 0 |
#include <pthread.h>
int chopsticks[5];
pthread_mutex_t lock;
int try_chopstick(int chopstick_num){
int flag=0;
pthread_mutex_lock(&lock);
if(chopsticks[chopstick_num-1]==0){
chopsticks[chopstick_num-1]=1;
flag=1;
}
pthread_mutex_unlock(&lock);
return flag;
}
void release_chopsticks(in... | 1 |
#include <pthread.h>
int pbs_movejob_err(
int c,
char *jobid,
char *destin,
char *extend,
int *local_errno)
{
int rc;
struct batch_reply *reply;
int sock;
struct tcp_chan *chan = 0;
if ((jobid == (char *)0) || (*jobid == '\\0'))
return (PBSE_IVALREQ);
if (destin =... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.