text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#include <pthread.h>
struct my_struct {
int fd;
int stop;
char *read_buf;
char *write_buf;
pthread_mutex_t RW_mutex;
};
void *read_function(void *arg)
{
int i, len;
struct my_struct *myData = (struct my_struct *)arg;
myData->read_buf = malloc(256);
for(i=0;;i++)
{
pthrea... | 1 |
#include <pthread.h>
int p;
int n;
int* list;
int counter = 0;
pthread_mutex_t mutex;
pthread_cond_t cond_var;
void *Sort(void* rank);
void Odd_even_iter(int phase, int partner, long my_rank);
void Merge(int first, int last);
int main(int argc, char** argv)
{
long thread;
pthrea... | 0 |
#include <pthread.h>
pthread_t *th_A , *th_B;
pthread_mutex_t mutex , mutex2;
int nThread = 1000;
int id;
char type;
} ThreadData;
ThreadData *dataA , *dataB;
sem_t *printA , *printB;
int cnt_3 = 0;
int statB = 0;
int statA = 0;
int lock = 0;
void * procA ( void *arg ){
ThreadData *d = ( T... | 1 |
#include <pthread.h>
int buffer[30];
int fill_ptr = 0;
int use_ptr = 0;
int count = 0;
void put(int value) {
buffer[fill_ptr] = value;
fill_ptr = (fill_ptr + 1) % 30;
count++;
}
int get() {
int tmp = buffer[use_ptr];
use_ptr = (use_ptr + 1) % 30;
count--;
return tmp;
}
pthread... | 0 |
#include <pthread.h>
void *sendPhyDL(void* threadid){
char package[100];
int error;
pthread_mutex_unlock(&mutex1);
while(1){
pthread_mutex_lock(&mutex0);
printf("Mensagem: ");
__fpurge(stdin);
scanf("%s", package);
__fpurge(stdin);
... | 1 |
#include <pthread.h>
struct {
pthread_mutex_t mutex;
int buff[10];
int nitems;
} shared = {
PTHREAD_MUTEX_INITIALIZER
};
void* produce(void* arg) {
for (;;) {
pthread_mutex_lock(&shared.mutex);
if (shared.nitems >= 100000000) {
pthread_mutex_unl... | 0 |
#include <pthread.h>
struct requestinfo {
int type;
int wantipv6;
pthread_t threadhandle;
pthread_mutex_t threadeventmutex;
int threadeventobject;
char* requestvalue;
char* result;
};
void* resolvethread(void* data) {
struct requestinfo* i = data;
if (i->type == 1) {
i->re... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
struct in_addr dest_ip;
unsigned short int min_port;
unsigned short int max_port;
}port_segment;
int do_scan(struct sockaddr_in serv_addr)
{
int fd;
int result;
fd = socket(AF_INET,SOCK_STREAM,0);
if (fd < 0){
perror("Socket Error"); return... | 0 |
#include <pthread.h>
static volatile uint32_t Gen_IO_CSR_Reg = 0;
static volatile uint32_t Gen_IO_Buff_Reg = 0;
static volatile uint32_t Gen_IO_Size_Reg = 0;
static volatile uint32_t Gen_IO_Count_Reg = 0;
static volatile int IO_Q_Halt_Thread = 0;
static pthread_t IO_Q_Thread;
static pthread_cond... | 1 |
#include <pthread.h>void* philoDiner(void *arg);
pthread_mutex_t chops [1000];
int phioFed = 0;
int numPhilo = 0;
int numNom = 0;
int main(int argc, char *argv[]) {
pthread_t thread[1000];
int thread_id[1000];
int id = 0;
int result;
int isLocked = 0;
numPhilo = atoi(a... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int shared_data = 5;
void *thread_function (void *arg)
{
pthread_mutex_lock(&mutex) ;
while ( shared_data > 0)
{
--shared_data ;
printf("Thread - Decreasing shared_data... Value:%d\\n",shared_data);
sleep(1);
}
... | 1 |
#include <pthread.h>
void (*add_func)();
} function_pointers;
pthread_mutex_t * mutex;
pthread_cond_t * work_sig;
pthread_cond_t * mon_sig;
int * shared_data;
int * work_available;
int * stop_work;
function_pointers * pointers;
int index;
} worker_data;
... | 0 |
#include <pthread.h>
int fichier;
int nombre;
int first;
float valeur;
pthread_mutex_t mutex;
}DONNEE;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
void* min(void* arg){
DONNEE* f = (DONNEE*)arg;
char* tbuf = malloc(sizeof(char));
pthread_mutex_lock(&f->mutex);
int i=0;
read(f-... | 1 |
#include <pthread.h>
static void * thread_compteur(void * inutile);
static void * thread_signaux(void * inutile);
static int compteur = 0;
static pthread_mutex_t mutex_compteur = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond_compteur = PTHREAD_COND_INITIALIZER;
static pthread_t thr_signa... | 0 |
#include <pthread.h>
sem_t empty,full;
pthread_mutex_t m;
int buff[5];
void *producer(void *arg)
{
printf("\\nProducer thread created");
sleep(5);
int item,i=0;
while(1)
{
sem_wait(&empty);
item=random()%10;
pthread_mutex_lock(&m);
buff[i++]=item;
printf("\\n%d item is inserted at %d... | 1 |
#include <pthread.h>
static int volatile global1;
static int volatile global2;
static pthread_mutex_t mux = PTHREAD_MUTEX_INITIALIZER;
static void *
thr_main(void *ign)
{
while (!force_quit) {
int v1;
int v2;
STOP_ANALYSIS();
pthread_mutex_lock(&mux);
v1 = global1;
pthread_mutex_un... | 0 |
#include <pthread.h>
int flag;
int edge;
pthread_mutex_t lock;
struct square *next;
struct square *prev;
} square;
int generator;
int license;
} carParam;
struct square trafficCircle[5][5];
int run = 1;
pthread_t carGenerators[4];
struct carParam arr1[200];
struct carParam arr2[200];
struc... | 1 |
#include <pthread.h>
extern unsigned volatile int *lock;
FILE *fileout_sha;
FILE *fileout_rijndaelenc;
FILE *fileout_rijndaeldec;
FILE *fileout_blowfishenc;
FILE *fileout_blowfishdec;
FILE *filein_sha;
FILE *filein_rijndaelenc;
FILE *filein_rijndaeldec;
FILE *filein_blowfishenc;
FILE *filei... | 0 |
#include <pthread.h>
int globl = 0;
int count = 0;
pthread_mutex_t lock;
int thread_rand(pthread_mutex_t* arg) {
pthread_mutex_lock(arg);
globl += (int) (10 * ((double) rand()) / 32767);
--count;
if(count == 0) {
pthread_mutex_unlock(&lock);
}
pthread_mutex_unlock(... | 1 |
#include <pthread.h>
struct ap_hash_head_t *aphead = 0;
unsigned int conflict_count = 0;
unsigned int ap_innet_cnt = 0;
unsigned int ap_reg_cnt = 0;
static unsigned int
__elfhash(char* str, unsigned int len)
{
unsigned int hash = 0;
unsigned int x = 0;
unsigned int i = 0;
for(i = 0; i < l... | 0 |
#include <pthread.h>
int buf[10];
size_t len;
pthread_mutex_t mutex;
pthread_cond_t can_produce;
pthread_cond_t can_consume;
} buffer_t;
int isPrime(int n){
int i;
if(n % 2 == 0){
return 0;
}
for(i = 3; i <= sqrt(n); i = i + 2){
if(n % i == 0){... | 1 |
#include <pthread.h>
pthread_mutex_t verroux = PTHREAD_MUTEX_INITIALIZER;
int nbzone=4;
int peutlancerT2=0;
pthread_cond_t condition;
int tabf[4]={0,1,2,3};
int tabZAT[3]={-1,-1,-1};
void* actionT1(void* p)
{
printf("lancement T1 \\n");
int i;
int j;
for(i=0;i<nbzone;... | 0 |
#include <pthread.h>
static pthread_mutex_t IO_Q_Lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t IO_Q_Cond = PTHREAD_COND_INITIALIZER;
static volatile int IO_Q_Halt_Thread = 0;
static pthread_t IO_Q_Thread;
static int32_t Status;
static int32_t Command;
static int32_t Address;
static in... | 1 |
#include <pthread.h>
enum IOCTL_CMD
{
IOCTL_UNKOWN = 0x100,
IOCTL_GET_ENV_INFO,
IOCTL_WAIT_VE,
IOCTL_RESET_VE,
IOCTL_ENABLE_VE,
IOCTL_DISABLE_VE,
IOCTL_SET_VE_FREQ,
IOCTL_CONFIG_AVS2 = 0x200,
IOCTL_GETVALUE_AVS2 ,
IOCTL_PAUSE_AVS2 ,
IOCTL_START_AVS2 ,
IOCTL_RESET_AVS2 ,
IOCTL_ADJ... | 0 |
#include <pthread.h>
extern char **environ;
static pthread_mutex_t env_mutex;
static pthread_once_t init_done = PTHREAD_ONCE_INIT;
static void thread_init(void);
int getenv_r(const char *name, char *buf, int buflen);
int putenv_r(const char *s);
int putenv_r(const char *s)
{
pthread_once(&ini... | 1 |
#include <pthread.h>
pthread_mutex_t mutexes[3];
pthread_cond_t conditionVars[3];
int permits[3];
pthread_t tids[3];
int data = 0;
void * Philosopher(void * arg){
int i;
i = (int)arg;
pthread_mutex_lock(&mutexes[i%3]);
while (permits[i%3] == 0) {
printf("P%d : tryget F%d\\n", i, ... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int final_result = 0;
struct thread_data{
int startidx;
int maxidx;
};
void *line (void *threadarg) {
int sx, sy, err, dx, dy, e2, x_pixel, y_pixel;
int sight;
int result=0;
int x0, y0;
struct thread_data*... | 1 |
#include <pthread.h>
static pthread_mutex_t POS_Optics_Write_Lock = PTHREAD_MUTEX_INITIALIZER;
static int POS_Optical_state_Percent;
void Init_Optics(void)
{
pthread_mutex_unlock(&POS_Optics_Write_Lock);
POS_Optical_state_Percent=0;
}
void Set_Optics_Setting(int rawdata)
{
... | 0 |
#include <pthread.h>
enum state {THINKING,HUNGRY,EATING};
enum state philState[10];
float millis;
clock_t start,end;
int timer[10];
int N;
void* philospher(void *num);
void pickup_forks(int);
void return_forks(int);
void philosopher_test(int);
pthread_mutex_t mutex;
pthread_cond_t cond_va... | 1 |
#include <pthread.h>
void *functionC();
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
int counter = 0;
main()
{
int rc1, rc2;
pthread_t thread1, thread2;
if( (rc1=pthread_create( &thread1, 0, &functionC, 0)) )
{
printf("Thread creation failed: %d\\n", rc1);
}
if(... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
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) {
... | 1 |
#include <pthread.h>
void aq_init(struct aq_info* paq)
{
paq->front_sig = 0;
paq->rear_sig = 0;
paq->aq_cur_size = 0;
pthread_mutex_init(&paq->tmp_mutex,0);
paq->aq_turn_num = aq_buf_max - 1;
paq->aq_full = -10000;
paq->aq_empty = -10001;
paq->aq_push_ok = -10002;
return... | 0 |
#include <pthread.h>
int RANGE = 2;
long global_row;
pthread_mutex_t global_row_lock;
pthread_barrier_t barrier;
void *elimination(void* threadid) {
int norm, row, col, row_end;
float multiplier;
pthread_t self;
long tid;
tid = (long)threadid;
for (nor = 0; norm < N - 1;... | 1 |
#include <pthread.h>
char proto[4];
char IPserveur[33];
char IPclient[33];
int dport;
char md5sum[32];
uint16_t opentime;
} args_iptables_struct;
static struct aes_data_t* _spa = 0;
pthread_mutex_t lock1;
pthread_mutex_t lock2;
void *changeiptables(void* args)
{
pthread_mutex_loc... | 0 |
#include <pthread.h>
pthread_mutex_t max_connect_mutex = PTHREAD_MUTEX_INITIALIZER;
unsigned int uiConnectCount = 0;
void *thread(void *arg)
{
FILE * fp;
int i = 0;
int ret;
int fd = (int)arg;
char cmd_buf[128];
char pipe_buf[512];
pthread_mutex_lock(&max_connect_mutex);
uiConnectCount... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
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 __V... | 0 |
#include <pthread.h>
sem_t mysem[10000];
pthread_mutex_t mylock;
struct shared
{
int threadId;
long counter[10000];
char msg[10];
};
void* mythread_entry(void *args)
{
struct shared *SharedCounter = (struct shared*)args;
int i=0;
int resource_to_use = SharedCounter->... | 1 |
#include <pthread.h>
static int keep_ticks;
static void *tickTurn(void *ptr);
void messageCB(char *message);
void print_turnInfo();
static struct turn_info turnInfo;
static struct listenConfig listenConfig;
static pthread_t turnListenThread;
static char rcv_message[100];
pthread_mutex_t tu... | 0 |
#include <pthread.h>
static const unsigned OS_TICKS_PER_SEC = 100;
{
OS_NO_ERR = 0,
OS_ERR_EVENT_TYPE = 1,
OS_ERR_PEVENT_NULL = 4,
OS_ERR_TIMEOUT = 10,
OS_ERR_PEND_ABORT = 14,
OS_ERR_PRIO_EXIST = 40,
OS_ERR_PRIO = 41,
OS_ERR_PRIO_INVALID = 42,
OS_ERR_SEM_OVF = 50,
OS_ERR_TASK_DEL =... | 1 |
#include <pthread.h>
void error_handler_initialize() {
pthread_mutex_init(&elock_main, 0);
pthread_cond_init(&econd_main, 0);
eflag_main = 0;
pthread_mutex_init(&elock_i2c, 0);
pthread_cond_init(&econd_i2c, 0);
eflag_i2c = 0;
}
void esignal_main() {
pthread_mutex_lock(&elock_main);
efl... | 0 |
#include <pthread.h>
pthread_mutex_t semaforo1,semaforo2;
int recurso;
int numeroLectores;
void * escritor(void * limite);
void * lector(void * limite);
int main(){
srand(time(0));
pthread_t * hilos;
hilos=(pthread_t *)malloc(sizeof(hilos)*4);
recurso=5;
numeroLectores=0;
pthread_mutex_i... | 1 |
#include <pthread.h>
{
FILE* fsync;
FILE* frestart;
int synced;
int count;
int quit;
pthread_mutex_t mutex;
pthread_t thread[32];
} cloud_state_t;
cloud_state_t* gstate = 0;
static void cloud_state_quit(int signo)
{
assert(gstate);
if(signo != SIGINT)
{
return;
}
pthread_mutex... | 0 |
#include <pthread.h>
long circleCount = 0;
pthread_t *threads;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *monteCarloPi(void *thread_ID) {
long i;
int a = (int) thread_ID;
long incircle_thread = 0;
unsigned int rand_state = rand();
for (i = 0; i < 10000000/5; i++) {
double x... | 1 |
#include <pthread.h>
static pthread_mutex_t g_cp8_emu_mtx = PTHREAD_MUTEX_INITIALIZER;
struct cp8_emu_tasks_ctx {
const char *name;
cp8_emu_task task;
};
static struct termios g_oldattr;
static int cp8_help(void);
static int cp8_version(void);
void cp8_emu_init(struct cp8_ctx *... | 0 |
#include <pthread.h>
struct msg
{
struct msg *next;
int num;
};
struct msg *head;
struct msg *mp;
pthread_cond_t has_product=PTHREAD_COND_INITIALIZER;
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
void *consumer(void *p)
{
for(;;)
{
pthread_mutex_lock(&lock);
... | 1 |
#include <pthread.h>
struct mt {
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
struct mt * mm;
void test(struct mt * mm)
{
for (int i=0;i<10;i++){
printf("PID：%d \\n",getpid());
pthread_mutex_lock(&mm->mutex);
mm->num += 1;
printf("PID：%d num = :%d\\n",getpid(),mm->n... | 0 |
#include <pthread.h>
int count = 0;
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void* inc_count(void *arg)
{
int i;
int my_id = *((int*) arg);
for (i=0; i<10; i++) {
pthread_mutex_lock(&count_mutex);
count++;
if (count == 12) {
... | 1 |
#include <pthread.h>
void *customerMaker();
void *barberShop();
void *waitingRoom();
void checkQueue();
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t wait_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t sleep_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t barberS... | 0 |
#include <pthread.h>
int _mosquitto_handle_pingreq(struct mosquitto *mosq)
{
assert(mosq);
_mosquitto_log_printf(mosq, MOSQ_LOG_DEBUG, "Client %s received PINGREQ", mosq->id);
return _mosquitto_send_pingresp(mosq);
}
int _mosquitto_handle_pingresp(struct mosquitto *mosq)
{
assert(mosq... | 1 |
#include <pthread.h>
pthread_mutex_t llave;
double sum = 0.0;
struct parametros {
int inicio; ;
int fin ;
int nh;
double *vector;
};
void *do_work( void *arg );
int main(int argc, char *argv[]){
double *vector;
vector = malloc(sizeof(double*)*1000000000);
... | 0 |
#include <pthread.h>
struct sensorBlockTime sensorBlockArr[(32* (TURNS + 1)) + ((TURNS + 1) * 2)];
struct executionTimeSensor sensorExecutionArr[(32* (TURNS + 1)) + ((TURNS + 1) * 2)];
struct d arr[(32* (TURNS + 1)) + ((TURNS + 1) * 2)];
void *sensor(void* val) {
struct timespec start;
struct... | 1 |
#include <pthread.h>
struct to_info{
void (*to_fn)(void *);
void *to_arg;
struct timespec to_wait;
};
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_se... | 0 |
#include <pthread.h>
void
print_buffer(byte *data, uint len, byte *counter, pthread_mutex_t *lock)
{
uint i;
char *buf;
buf = malloc((len * 2 ) + 1 );
for (i = 0; i < len; i++)
sprintf(buf + (i*2), "%02x", data[i] + *counter);
pthread_mutex_lock(lock);
prin... | 1 |
#include <pthread.h>
sem_t ta_ready, have_stud, queue[3];
pthread_mutex_t chairs;
int nstuds, queue_head, queue_tail = -1;
static void *ta_thread(void *param)
{
for (;;) {
printf("[TA] Checking for students\\n");
sem_wait(&have_stud);
printf("[TA] Found one\\n");
... | 0 |
#include <pthread.h>
int b[10];
int cont = 0;
pthread_cond_t prod_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t cons_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mp = PTHREAD_MUTEX_INITIALIZER;
int prod_pos = 0;
int cons_pos = 0;
void * produtor(void * arg){
while(1){
printf... | 1 |
#include <pthread.h>
struct padded_int {
int value;
char padding[32000 - sizeof(int)];
};
struct padded_int * privateCount;
int * test_array;
int i, length, t;
int totalCount = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void * count3s(void * arg){
int id = *((int *) arg); i... | 0 |
#include <pthread.h>
struct psuma {
uint16_t v1;
uint16_t v2;
uint32_t res;
};
void *suma (void *);
void *ver_cone (void *);
int leer_mensaje ( int , char * , int );
int cone;
pthread_mutex_t m;
pthread_cond_t c;
int main() {
int lon;
int sd;
int sd_cli;
struct s... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t avail;
pthread_cond_t ready;
int data_ready;
long data;
pthread_t thread;
struct stage_tag* next;
} stage_t;
pthread_mutex_t mutex;
stage_t* head;
stage_t* tail;
int stages;
int active;
} pi... | 0 |
#include <pthread.h>
pthread_key_t threadIdxxKey = 0;
pthread_key_t blockIdxxKey = 0;
pthread_key_t blockDimxKey = 0;
pthread_key_t gridDimxKey = 0;
pthread_mutex_t atom_add_mutex;
pthread_mutex_t thread_id_mutex;
pthread_mutex_t barrier_mutex;
pthread_mutex_t thread_gate_mutex;
void lock_atom_a... | 1 |
#include <pthread.h>
char buf[100];
int fd;
pthread_mutex_t lock;
void* writeit()
{
pthread_mutex_lock(&lock);
printf("Enter data to send to server.\\n");
fgets(buf,100,stdin);
int wret=write(fd,buf,100);
if(wret<0)
{
printf("Failed to Write.\\n");
close(fd);
pthread_mutex_unlock(&lock)... | 0 |
#include <pthread.h>
extern void __VERIFIER_error() ;
int __VERIFIER_nondet_int(void);
void ldv_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
pthread_t t1, t2;
pthread_mutex_t mutex;
int pdev;
void ath9k_flush(void) {
pthread_mutex_lock(&mutex);
pdev = ... | 1 |
#include <pthread.h>
extern pthread_mutex_t global_data_mutex;
static int prevRainA = 0;
static int prevRainB = 0;
static int prevTime = 0;
static time_t reset_time = 0;
int open_rain_device(char * device_str)
{
int fd = -1;
assert(-1 == global_config.rain_fd);
if (0 != global_config.rai... | 0 |
#include <pthread.h>
pthread_mutex_t insertMutex;
pthread_mutex_t mutex;
pthread_cond_t mutex_cond = PTHREAD_COND_INITIALIZER;
int active = 0;
int activeDeletes = 0;
char *item;
struct list *next;
}Node;
Node *begin = 0;
Node *end = 0;
int searchThreads = 0;
int insertThreads = 0;
int de... | 1 |
#include <pthread.h>
int value;
pthread_cond_t* cond;
pthread_mutex_t mtx;
int status;
} SimpleChannel;
SimpleChannel createChannel(){
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
SimpleChannel ch = {
0,
0,
mtx,
0
};
... | 0 |
#include <pthread.h>
int thread_flag;
pthread_cond_t thread_flag_cv ;
pthread_mutex_t thread_flag_mutex ;
void initialize_flag ()
{
pthread_mutex_init (&thread_flag_mutex, 0);
pthread_cond_init (&thread_flag_cv, 0);
thread_flag = 0;
}
void* thread_function (void* thread_arg)
{
while (1... | 1 |
#include <pthread.h>
extern pthread_mutex_t mutex;
static bool accept_anyways(unsigned cur_eval, unsigned neigh_eval,
double temperature);
static unsigned update_temperature(unsigned t, unsigned TEMP_INITIAL,
unsigned T_MAX, unsigne... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
int count=0;
char msg_buf[64];
void SetMsg_Func(void);
void PrintMsg_Func(void);
int main()
{
int ret;
pthread_t set_thread;
count = 4;
pthread_mutex_init(&mutex,0);
ret = pthread_create(&set_thread,0, (void *)&SetMsg_Func, 0);
if (ret !... | 1 |
#include <pthread.h>
int shmid;
int matsize;
int *pint;
char thisStart[10];
char thisWalkno[10];
char thisMatsize[10];
char thisShmkey[10];
}arguments;
arguments tid_arg;
void *tidchild(void *child);
main(int argc, char *argv[])
{
int i, j, k, m, n, shmkey, offset;
int status = 0;
char... | 0 |
#include <pthread.h>
int A[6][6];
int B[6][6];
int qtd = 0;
pthread_cond_t condVar;
pthread_mutex_t monitorLock;
int id;
int iter;
} thread_arg;
void preenche(int A[6][6], int m, int n){
int i,j;
for (i = 0; i < m; i++)
for (j = 0; j < n; j++)
A[i][j] = i + j + i*j;
}
voi... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
int buffer;
int estado = 0;
void produtor(int id)
{
int i=0;
int item;
int aguardar;
printf("Inicio produtor %d \\n",id);
while (i < 10)
{
item = i + (id*1000);
pthread_mutex_lock(&mutex);
... | 0 |
#include <pthread.h>
pthread_mutex_t m;
pthread_cond_t cond;
char str[100];
bool str_available;
void* producer(void* arg ) {
while (1) {
fgets(str, sizeof str, stdin);
pthread_mutex_lock(&m);
str_available = 1;
pthread_cond_signal(&cond);
pthread_mutex_... | 1 |
#include <pthread.h>
int k = 0;
pthread_cond_t cond;
pthread_mutex_t mutex;
void* writing()
{
time_t rawtime;
struct tm *timeinfo;
int file;
int num_str = 1;
char str[100];
while(1)
{
pthread_mutex_lock(&mutex);
time(&rawtime);
timeinfo = localtime(&rawtime);
file = open("tim... | 0 |
#include <pthread.h>
int one=0,two=0,more=0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void* f( void *p)
{
while(one<5 || two<5 || more<5)
{
int n = 1 + rand()%999;
printf("Valoare: %d \\n",n);
if(n/10==0)
{
pthread_mutex_lock(&m);
... | 1 |
#include <pthread.h>
static void set_realtime(void)
{
struct sched_param p;
int ret;
p.sched_priority = 1;
ret = sched_setscheduler(0, SCHED_FIFO, &p);
if (ret == -1) {
fprintf(stderr, "Failed to set scheduler to SCHED_FIFO\\n");
}
}
static void high_priority(void)
{
int ret;
ret = n... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer[10] = {0,0,0,0,0,0,0,0,0,0};
void *producer(void *ptr)
{
int i=0;
pthread_mutex_lock(&the_mutex);
while(buffer[i]!=0 && i<10)
{
pthread_cond_wait(&condp, &the_mutex);
i++;
}
for(i=0; i<10; i++)
... | 1 |
#include <pthread.h>
void read_from_usb_thread(void *p) {
struct device_data* dev = (struct device_data*)p;
unsigned int ret = 0, i;
unsigned char buff[4] = {0, 0, 0, 0};
unsigned long rfu_sleep_time = THREAD_SLEEP_TIME;
while(1) {
if(pCMDValue.exit_time>0 && pCMDValue.exit_time<time(0))... | 0 |
#include <pthread.h>
char *line;
int pid;
FILE *fp;
pthread_t thread;
} Command;
int n = 0;
Command *commands = 0;
bool stop = 0;
bool shutdown_pending = 0;
pthread_mutex_t mutex;
sigset_t block_mask;
int _run_command(Command *cmd) {
int filedes[2];
if (pipe(f... | 1 |
#include <pthread.h>
int last_threadID;
int successes;
int count = 1;
pthread_mutex_t lock;
void *function(void *threadid)
{
int tid = (int)threadid;
pthread_mutex_lock(&lock);
int difference = tid-last_threadID;
if(difference != 1) {
}
else {
printf... | 0 |
#include <pthread.h>
long n = 1000000000;
pthread_mutex_t mutex;
long thread_count;
double sum = 0;
void* Thread_sum(void* rank)
{
long my_rank = (long)rank;
double factor;
long my_n = n / thread_count;
long my_first_i = my_n * my_rank;
long my_last_i = my_n * (my_rank + ... | 1 |
#include <pthread.h>
static int cb_cnt, finished, target;
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
static void
signal_finished(void)
{
pthread_mutex_lock(&lock);
finished = 1;
pthread_cond_signal(&cv);
pthread_mutex_unlock(... | 0 |
#include <pthread.h>
int quitflag;
sigset_t mask;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t waitloc = PTHREAD_COND_INITIALIZER;
void *thr_fn(void *arg)
{
int err, signo;
for(;;) {
err = sigwait(&mask, &signo);
if (err != 0)
err_exit(err... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
void fun(int signum)
{
printf("解锁一次......\\n");
if (pthread_mutex_unlock(&mutex) != 0)
{
printf("解锁失败...\\n");
}
}
int main(void)
{
int ret = -1;
int i = 0;
ret = pthread_mutex_init(&mutex, 0);
if (0 != ret)
... | 0 |
#include <pthread.h>
void die( const char* format, ... ) {
va_list args;
__builtin_va_start((args));
vfprintf( stderr, format, args );
fprintf( stderr, "\\n" );
;
assert( 0 );
exit( 1 );
}
void true_or_die( int is_ok, const char* format, ... ) {
if( !is_ok ) ... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
long long *create_vector1(int);
long long *create_vector2(int);
void do_work(void);
void produto_interno(int, int);
int threads, vector_size, val;
long long prod_int, *vector_a, *vector_b;
int round_div(int dividend, in... | 0 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;
char var[20];
void* child1(void *p)
{
int k=0;
pthread_mutex_lock(&m1);
printf("\\nENTER U MESSAGE:");
gets(var);
k=strlen(var);
printf("\\nUR MESSAGE HAS BEEN SENT BY CHILD... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_write = PTHREAD_COND_INITIALIZER;
bool done = 0;
int reading_to = 1;
int writing_from = 1;
char buffer_1[16*1024*1024];
char buffer_2[16*1024*1024];
... | 0 |
#include <pthread.h>
int thread_flag,ret;
pthread_cond_t flag1,flag2;
pthread_mutex_t mut,mutx;
pthread_t print_wait;
void initialize_flag ()
{
pthread_mutex_init (&mut, 0);
pthread_cond_init (&flag1, 0);
pthread_mutex_init (&mutx, 0);
pthread_cond_init (&flag2, 0);
thread_flag = 0;
... | 1 |
#include <pthread.h>
struct list_node_s
{
int data;
struct list_node_s* next;
};
int Member(int value);
int Insert(int value);
int Delete(int value);
void extractArgs(int argc,char* argv[]);
void populatelinkedlist();
void initializearray();
void shufflearray();
void* doOperations(void* id);... | 0 |
#include <pthread.h>
struct foo {
int f_count;
pthread_mutex_t f_lock;
};
struct foo *
foo_alloc(void)
{
struct foo *fp;
if ((fp = malloc(sizeof(struct foo))) != 0) {
fp->f_count = 1;
if (pthread_mutex_init(&fp->f_lock, 0) != 0) {
free(fp);
return 0;
}
}
... | 1 |
#include <pthread.h>
void create_threads(int records_num);
void *start_thread(void *records_num) ;
void join_threads();
int find_text(char *text);
void cancel_threads_async();
int read_data(int records_num) ;
void destructor(void *data) ;
int read_records(char **data) ;
int id;
cha... | 0 |
#include <pthread.h>
struct input {
int num;
int cT;
};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int curThread = 0;
int timecount = 0;
void *createThread(void *input) {
struct input *in = input;
int actual = in->cT;
printf("Hello from thread No. %d!\\n", actual);
int tcoun... | 1 |
#include <pthread.h>
pthread_mutex_t mutex;
pthread_cond_t cond;
void *thread1(void *arg)
{
pthread_cleanup_push(pthread_mutex_unlock,&mutex);
while(1)
{
printf("thread1 is running\\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond,&mutex);
... | 0 |
#include <pthread.h>
pthread_mutex_t mux;
unsigned int counter;
void * thread_code(void *arg){
unsigned int start;
unsigned int end;
unsigned int priv_count = 0;
int thread_indx =(int) arg;
if (thread_indx == 0){
start = 0;
}else{
start = 4294967295U/4 * thread_indx +1;
}
if (th... | 1 |
#include <pthread.h>
char name[2];
int data;
pthread_t thread;
pthread_mutex_t lock;
pthread_cond_t cond;
long int waits;
} PROC;
void _exec_and_wait(void* args) {
static struct timespec time_to_wait = {0, 0};
PROC *proc = (PROC*) args;
while(proc->data < 10) {... | 0 |
#include <pthread.h>
int q[4];
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 < 4)
... | 1 |
#include <pthread.h>
unsigned int generate_CRC32(unsigned char * data_buf, unsigned int len, unsigned int oldcrc32)
{
unsigned int t;
while (len > 0) {
t = (oldcrc32 ^ *data_buf) & 0xff;
oldcrc32 = (oldcrc32 >> 8) ^ crc_32_file_tab[t];
len--;
data_buf++;
... | 0 |
#include <pthread.h>
struct list_node_s{
int data;
struct list_node_s* next;
};
int Member(int value, struct list_node_s* head_p){
struct list_node_s* curr_p = head_p;
while(curr_p != 0 && curr_p->data < value)
curr_p = curr_p->next;
if(curr_p == 0 || curr_p->data > value)
... | 1 |
#include <pthread.h>
static int terminate_env_thread = 0;
static void env_thread_finish(struct ezcfg_socket_agent *agent)
{
pthread_mutex_lock(&(agent->env_thread_mutex));
pthread_mutex_lock(&(agent->sub_agent_thread_list_mutex));
if (agent->sub_agent_thread_list != 0) {
ezcfg_... | 0 |
#include <pthread.h>
static int n = 0;
void* controller_thread(void *arg) {
fprintf(stderr, "Controller thread %u start.\\n", (unsigned int)pthread_self());
pthread_mutex_lock(&q_mutex);
while(1) {
fprintf(stderr, "Controller: check queue.\\n");
struct queue *p = q_head, *prev_q = q_head;
... | 1 |
#include <pthread.h>
pthread_mutex_t flaglock;
pthread_cond_t mycond;
int flag = 1;
void *hello(void *p)
{
while(1)
{
pthread_mutex_lock(&flaglock);
while(1 != flag)
{
pthread_cond_wait(&mycond, &flaglock);
}
pthread_mutex_unlock(&flaglock);
printf("hello\\n");
pthread_mute... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.