text stringlengths 192 6.24k | label int64 0 1 |
|---|---|
#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;
pthread_mutex_t mutex;
int pdev;
void *thread1(void *arg) {
pthread_mutex_lock(&mutex);
pdev = 6;... | 1 |
#include <pthread.h>
static int sockets[MAX_CONNECTION];
static pthread_mutex_t verrou_connexion = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t verrou_ecriture = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t verrou_deconnexion = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t verrou_... | 0 |
#include <pthread.h>
void rpcap_init()
{
_ports_used = 0;
_nb_port_used = 0;
_rpcap_port_min = _rpcap_port_max = -1;
pthread_mutex_init(&_mutex_port_req, 0);
}
int rpcap_get_port()
{
int i;
int ret = -1;
pthread_mutex_lock(&_mutex_port_req);
ret = _rpcap_port_min;
do {
for (i... | 1 |
#include <pthread.h>
int niter = 100000,i, count=0,total_threads;
pthread_mutex_t pthread;
void *calculatePiValue(void* rank) {
long my_rank = (long) rank;
double x,y,z;
int sz = niter/total_threads;
int start_i = my_rank*sz;
int end_i = start_i + sz - 1;
pthread_mutex_loc... | 0 |
#include <pthread.h>
int **matrix;
int max_col = 0;
uint64_t time_par;
struct thread_data{
int col_pos;
int start;
int end;
};
struct thread_data thread_data_array[4];
pthread_t threads[4];
pthread_mutex_t mutexcomp;
void printmatrix(int **matrix);
void *findMAX(void *arg);
void... | 1 |
#include <pthread.h>
int sd;
pthread_mutex_t sendlock;
void _dispatch_packet(struct tcp_header*, size_t, uint32_t, uint32_t);
int init_tcp_rw() {
sd = socket(PF_INET, SOCK_RAW, IPPROTO_TCP);
if (sd < 0) {
printf("Could not initialize socket\\n");
return 1;
}
... | 0 |
#include <pthread.h>
{
double *a;
double *b;
double sum;
int veclen;
} DOTDATA;
DOTDATA dotstr;
pthread_t callThd[4];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
int i, start, end, len ;
long offset;
double mysum, *x, *y;
offset = (long)arg;
l... | 1 |
#include <pthread.h>
char bwc_buffer[BUFFER_LENGTH];
char bwss_buffer[BUFFER_LENGTH];
pthread_t bwss_thread;
pthread_t bwc_thread;
char *bwss_port;
char *bwc_port;
int bwc_socket;
int bwss_socket;
int ready;
pthread_mutex_t mutex;
pthread_cond_t cond;
void *connect_client(void *pcl);
void *b... | 0 |
#include <pthread.h>
int main(int argc, char* argv[])
{
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
int* x;
char* ptr;
int rt;
int ret;
pthread_mutexattr_init(&mutexattr);
pthread_mutexattr_setpshared(&mutexattr, PTHREAD_PROCESS_SHARED);
pthread... | 1 |
#include <pthread.h>
double elapsedTimesInThreads[ 16 ];
int threadCounter = 0;
pthread_mutex_t mutex;
void* threadFunction( void* rank );
int main( void )
{
pthread_mutex_init( &mutex, 0 );
pthread_t* threadHandles = ( pthread_t* )malloc( 16 * sizeof( pthread_t ) );
for( long threadIndex =... | 0 |
#include <pthread.h>
pthread_mutex_t aarrived, barrived;
pthread_cond_t lock;
int islocked = 0;
void main() {
pthread_cond_init(&lock, 0);
pthread_mutex_init(&aarrived, 0);
pthread_mutex_init(&barrived, 0);
pthread_t threada, threadb;
void *threadAFunction(), *threadBFunc... | 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)
... | 0 |
#include <pthread.h>
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int var = 1;
void *thread_a(void *arg);
void *thread_b(void *arg);
int main(){
int shmid = shmget(IPC_PRIVATE, sizeof(int), S_IRUSR | S_IWUSR);
if (shmid==-... | 1 |
#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... | 0 |
#include <pthread.h>
int pid_map[(350 -300 +1)];
pthread_mutex_t mutex;
int allocate_map(void)
{
int i;
pthread_mutex_init(&mutex,0);
pthread_mutex_lock(&mutex);
for(i =0;i<(350 -300 +1); i++)
pid_map[i] = 0;
pthread_mutex_unlock(&mutex);
return 1;
}
int allocate_pid(v... | 1 |
#include <pthread.h>
extern pthread_mutex_t timer_queue_mutex;
extern void tsSendPeriodicTau(unsigned char ueId);
void *timer_thread_main(void *data)
{
int i;
int j;
timer_queue_msg *tqm;
while (1)
{
pthread_mutex_lock(&timer_queue_mutex);
for (i = 0; i < TIMER_QU... | 0 |
#include <pthread.h>
pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex3 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex4 = PTHREAD_MUTEX_INITIALIZER;
static int sequence1 = 0;
static int sequence2 = 0;
int func... | 1 |
#include <pthread.h>
void event_listener_init(struct event_listener* el)
{
pthread_mutex_init(&el->lock, 0);
el->el_cancel = 0;
el->epoll_fd = epoll_create(EPOLL_SIZE);
el->ev_num = 0;
el->ev_cur = 0;
el->ev_reg = 0;
el->ac_num = 0;
el->ac_cur = 0;
el->ac_end = 0;
event_storage_init(&... | 0 |
#include <pthread.h>
extern char **environ;
static pthread_key_t key;
static pthread_once_t once_done = PTHREAD_ONCE_INIT;
static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void thread_init(void)
{
pthread_key_create(&key, free);
}
char *getenv_l(const char *name)
{
int i, len... | 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>
int i_fd = -1, i_w = -1;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cnd;
void* threadfunc(void *arg) {
struct pollfd pf = {
.fd = i_fd,
.events = POLLIN
};
while (1) {
pf.revents = 0;
if (poll(&pf, 1, 1000) < 0)
continue;
... | 1 |
#include <pthread.h>
pthread_t philosophers[5];
pthread_attr_t philosophers_attr[5];
pthread_mutex_t mutex[5];
pthread_cond_t cond_var[5];
pthread_mutex_t printing_mutex;
int idx[5] = {0,1,2,3,4};
int forks[5];
void* runner(void *param);
void pickup_forks(int philo_num);
void return_forks(i... | 0 |
#include <pthread.h>
struct Pattern{
char *url;
char *user;
char *password;
};
static struct Pattern patterns[100];
static int pcount;
static int hash_index;
static void process_function();
static void process_function_actual(int job_type);
static int process_judege(struct Job *jo... | 1 |
#include <pthread.h>
pthread_mutex_t lock;
int array[10];
int n_elementos=0;
void * productor();
void * consumidor();
int main(int argc, char ** argv){
srand(time(0));
int i;
pthread_mutex_init(&lock, 0);
pthread_t pid[2];
for(i=0;i<10;i++){
array[i] = rand()%5;
n_element... | 0 |
#include <pthread.h>
char *socket_path = "go.sock";
int socket;
char buf[4096];
int len;
} msg_t;
pthread_cond_t send_c;
pthread_cond_t recv_c;
pthread_mutex_t m;
msg_t *msg;
} channel_t;
channel_t workers;
channel_t reply;
} conn_t;
conn_t *conn;
int socket;
} server_t;
void ch_ini... | 1 |
#include <pthread.h>
void man(int *);
pthread_mutex_t mutex[6];
int main(){
pthread_t man1, man2, man3, man4, man5;
int a = 1, b = 2, c = 3, d = 4, e = 5;
pthread_create(&man1, 0, (void *)man, &a);
pthread_create(&man2, 0, (void *)man, &b);
pthread_create(&man3, 0, (void *)man, &c);
pthre... | 0 |
#include <pthread.h>
static int error(int cod,const char*const msg)
{
if (cod<0)
{
perror(msg);
exit(1);
}
return cod;
}
{
pthread_mutex_t guard;
volatile unsigned val;
} Shared;
Shared theShared;
static void* increment(void* data)
{
unsigned long count=(1ul<<20);
... | 1 |
#include <pthread.h>
void* child_fn ( void* arg )
{
pthread_mutex_unlock( (pthread_mutex_t*)arg );
return 0;
}
void nearly_main ( void )
{
pthread_t child;
pthread_mutex_t mx1, mx2;
int bogus[100], i;
for (i = 0; i < 100; i++) bogus[i] = 0xFFFFFFFF;
pthread_mutex_init( ... | 0 |
#include <pthread.h>
static double var_raw_analog_data[7];
static pthread_mutex_t Raw_Analog_Write_Lock = PTHREAD_MUTEX_INITIALIZER;
void Init_Raw_Analog(void)
{
int ii;
pthread_mutex_unlock(&Raw_Analog_Write_Lock);
for(ii=0; ii < 6;ii++){
var_raw_analog_data[ii]=-1;
}
}
double Get_... | 1 |
#include <pthread.h>
int item_in_array[10], item_out_array[100];
int item_in_count = 0, item_out_count = 0;
int no = 0;
pthread_t ptid, ctid[3], disp_tid;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t full, empty;
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = tem... | 0 |
#include <pthread.h>
void* pthTextRW_run(void *argv){
int sock_fd;
int flag;
int ret;
int option;
int *retval;
char *buff;
struct sockaddr_in udpaddr;
struct sockaddr_in client;
key_path = "./folder/.key";
retval = 0;
buff = 0;
sock_fd = socket(AF_INET,SOCK_DGRAM,0);
if(sock_f... | 1 |
#include <pthread.h>
struct list_head {
struct list_head *next ;
struct list_head *prev ;
};
struct s {
int datum ;
struct list_head list ;
};
struct cache {
struct list_head slot[10] ;
pthread_mutex_t slots_mutex[10] ;
};
struct cache c ;
static inline void INIT_LIST_HEAD(struct ... | 0 |
#include <pthread.h>
pthread_t tid;
pthread_cond_t cond_lock = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_lock = PTHREAD_MUTEX_INITIALIZER;
void *first_thread(void *arg) {
printf("%s start to lock the mutex.\\n", __func__);
pthread_mutex_lock(&mutex_lock);
printf("%s start to wa... | 1 |
#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 sockaddr_in servidor;
... | 0 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int condition;
int count;
pthread_t thread;
int consume( void ){
while ( count < 10 ){
printf( "Consume wait\\n" );
pthread_mutex_lock( &mutex );
while( condition == 0 )
... | 1 |
#include <pthread.h>
struct tramp_heap_page;
struct tramp_heap_data
{
struct tramp_heap_page *prev, *next;
unsigned int inuse;
unsigned int inuse_mask[((TRAMP_COUNT + (CHAR_BIT * sizeof(int)) - 1) / (CHAR_BIT * sizeof(int)))];
};
struct tramp_heap_page
{
char code[PAGE_SIZE];
stru... | 0 |
#include <pthread.h>
pthread_mutex_t mutex;
void *lowprio(void *null)
{
int i;
printf("\\n %s: \\n",__func__);
printf("LOWPRIO : contending for mutex lock \\n");
if(pthread_mutex_lock(&mutex)==0)
{
printf("LOWPRIO : lock acquired\\n");
printf("LOWPRIO : executing critical op ......\\... | 1 |
#include <pthread.h>
pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
int shared = 133;
void *ta (void *arg)
{
int local = 17;
(void) arg;
printf ("ta: running\\n");
if (0) local += shared; if (0) shared = local;
pthread_mutex_lock (&m1);
if (0) local += shared; if (0) shared... | 0 |
#include <pthread.h>
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t count_threshold_cv = PTHREAD_COND_INITIALIZER;
void *inc_count(void *t)
{
int i;
long my_id = (long)t;
for (i=0; i<10; i++)
{
pthread_mutex... | 1 |
#include <pthread.h>
pthread_t tid[3];
pthread_mutex_t m;
struct node
{
int data;
struct node *link;
};
struct node *header, *ptr, *temp;
int count=0;
void insert_front();
void insert_end();
void insert_any();
void display();
void delete();
void createthread();
void main()
{
int... | 0 |
#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)
err = pthread_create(&tid, &att... | 1 |
#include <pthread.h>
struct employee {
int number;
int id;
char first_name[32];
char last_name[32];
char department[32];
int root_number;
};
struct employee employees[] = {
{ 1, 12345678, "astro", "Bluse", "Accounting", 101 },
{ 2, 87654321, "Shrek", "Charl", "Programmer", 102 },
};
st... | 0 |
#include <pthread.h>
int * gArray;
int globalSum = 0;
pthread_mutex_t lock;
void * sumArray(void * ip)
{
int * i = (int *) ip;
int threadArraySliceSize = 400 / 8;
int startIndex = *i * threadArraySliceSize;
int endIndex = (*i + 1) * threadArraySliceSize;
int sumSlice = 0;
int ... | 1 |
#include <pthread.h>
pthread_cond_t cond_t = PTHREAD_COND_INITIALIZER;
pthread_mutex_t mutex_t;
void emit(void) {
for (int i = 0; i < 3; ++i) {
printf("sleep %d s\\n", i);
sleep(1);
}
pthread_mutex_lock(&mutex_t);
pthread_cond_signal(&cond_t);
puts("emmit")... | 0 |
#include <pthread.h>
int ** bigmatrix;
int r = 5;
int c = 5;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int ready = 0;
int ** AllocMatrix(int r, int c)
{
int ** a;
int i;
a = (int**) malloc(sizeof(int *) * r);
assert(a != 0);
f... | 1 |
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *thread1(void*);
void *thread2(void*);
void send_num(int);
int i = 1;
int main(void) {
int mk = 0;
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a, 0, thread2, (v... | 0 |
#include <pthread.h>
int numT;
char * aldodir;
char * imagedir;
char aldoFileNames[10][15];
long imageID;
struct _finddata_t imageData;
int *** aldos;
int numAldos = 0;
int allAldoRows[100];
int allAldoCols[100];
pthread_mutex_t mutex_nextFile = PTHREAD_MUTEX_INITIALIZER;
int main( int... | 1 |
#include <pthread.h>
pthread_t tidTable[1000];
pthread_mutex_t mutex_one;
pthread_cond_t cond_one;
long index = 0;
int iNumThread;
void thinking(){
srandom(time(0));
usleep(random()%500);
}
void pickUpChopsticks(long threadX){
printf("%ld is trying to pick the chopsticks\\n",threadX);... | 0 |
#include <pthread.h>
double a;
double b;
int n;
double approx;
pthread_mutex_t mutex;
double static NEG_1_TO_POS_1 = 0.66666666666667;
double static ZERO_TO_POS_10 = 333.333;
double f(double a) {
return a * a;
}
void* trap_loop(void *rank) {
int *rank_int_ptr = (int*) rank;
int my_r... | 1 |
#include <pthread.h>
void clearSampleTableEnt(int i)
{
sampleTable[i].id = i;
sampleTable[i].audioIdx = -1;
sampleTable[i].mixIdx = -1;
sampleTable[i].playbackState = STOPPED;
sampleTable[i].overlay = 0;
sampleTable[i].numOverlays = 0;
sampleTable[i].loop = FALSE;
sampleTabl... | 0 |
#include <pthread.h>
static pthread_cond_t condvar;
static bool child_ready;
static pthread_mutex_t lock;
static int num_received;
static void
handler(int sig, siginfo_t *info, void *ucxt)
{
print("in handler %d\\n", sig);
if (sig == 42) {
num_received++;
if (num_receiv... | 1 |
#include <pthread.h>
struct list_node_s {
int data;
struct list_node_s* next;
};
struct list_node_s* head_p = 0;
pthread_mutex_t mutex;
int noOfOperationsPerThread;
int noOfDeletePerThread;
int noOfInsertPerThread;
int noOfMemberPerThread;
int Delete(int value);
int Insert(int value);
... | 0 |
#include <pthread.h>
pthread_mutex_t print_lock;
pthread_mutex_t thread_count_lock;
int count_threads;
int count_finished;
pthread_mutex_t count_in_use_lock;
int count_in_use;
pthread_cond_t cond_cooled_down;
int on_cool_down;
void print_state()
{
pthread_mutex_lock(&print_lock);
... | 1 |
#include <pthread.h>
struct job {
struct job *next;
};
struct job *job_queue;
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_count, 0, 0);
}
void process_job(struct job *j)
{
printf... | 0 |
#include <pthread.h>
int q[5];
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 < 5)
... | 1 |
#include <pthread.h>
static time_t runtime_cache_timeout_secs = 10;
struct hybris_prop_value
{
char *key;
char *value;
time_t last_update;
};
static struct hybris_prop_value * prop_array = 0;
static int num_prop = 0;
static int num_alloc = 0;
static pthread_mutex_t array_mutex = PTH... | 0 |
#include <pthread.h>
struct Vertex {
char* string;
struct Vertex* next;
};
int counter;
pthread_cond_t cond_counter;
pthread_mutex_t mut_counter;
struct Vertex* head;
struct Vertex* tail;
char is_drop;
} Queue;
struct Param {
char get_or_put;
int ID;
Q... | 1 |
#include <pthread.h>
int n = 20;
pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
void *printyou(void *unused)
{
int c = n;
while (c--) {
usleep(10000);
printf("你");
}
return 0;
}
void *printme(void *unused)
{
int c = n;
while (c--) {
usleep(10000);
printf("我");
}
r... | 0 |
#include <pthread.h>
pthread_t g_thread[2];
pthread_mutex_t g_mutex;
__uint64_t g_count;
pid_t gettid()
{
return syscall(SYS_gettid);
}
void *run_amuck(void *arg)
{
int i, j;
printf("Thread %lu started.\\n", (unsigned long)gettid());
for (i = 0; i < 10000; i++) {
... | 1 |
#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)
... | 0 |
#include <pthread.h>
enum {THINKING,EATING,SLEEPING,SLEEPY,HUNGRY} state[5];
int N=5;
sem_t sleepsem;
sem_t pick[5];
pthread_mutex_t lock;
int duration=300;
void take_bed(int i) {
int value;
state[i]=SLEEPY;
sem_wait(&sleepsem);
sem_getvalue(&sleepsem,&value);
printf... | 1 |
#include <pthread.h>
struct timeval startwtime, endwtime;
double seq_time;
double *x;
double *z;
double error;
double p;
double delta;
double temp_add;
int repeats;
int nodes;
int threads;
pthread_mutex_t lock= PTHREAD_MUTEX_INITIALIZER;
pthread_t *threads_array;
... | 0 |
#include <pthread.h>
pthread_mutex_t the_mutex;
pthread_cond_t condc, condp;
int buffer = 0;
void* producer(void *ptr) {
int i;
for (i = 1; i <= 10000000000; i++) {
pthread_mutex_lock(&the_mutex);
while (buffer != 0)
pthread_cond_wait(&condp, &the_mutex);
buffer = i;
... | 1 |
#include <pthread.h>
int queue[10];
int front =-1;
int tail=0;
int pro_num=0;
int left_num=10;
pthread_mutex_t mymutex;
pthread_cond_t produce,consumer;
static void* pro_func(void*);
static void* con_func(void*);
int main(int argc,char *argv[])
{
srand(getpid());
pthread_t tid1,tid2;
pt... | 0 |
#include <pthread.h>
pthread_mutex_t tenedor[5];
void pensar(int i){
printf("Filosofo %d pensando...\\n",i);
usleep(random() % 50000);
}
void comer(int i){
printf("Filosofo %d comiendo...\\n",i);
usleep(random() % 50000);
}
void tomar_tenedores_zurdo(int i) {
pthread_mutex_lock(&(tenedo... | 1 |
#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)
... | 0 |
#include <pthread.h>
struct Params
{
long startPos;
long endPos;
};
pthread_mutex_t readFlag;
pthread_mutex_t writeFlag;
pthread_mutex_t copyFlag;
pthread_mutex_t changeFlag;
char *progName, *inFile, *outFile;
volatile unsigned short int threadCount = 0;
unsigned short int threadLimit;
... | 1 |
#include <pthread.h>
int Graph[101][101];
int dist[101][101];
pthread_mutex_t mutex,wrt;
int readCount;
int n;
void * handle_i(void *args)
{
int i = ((int *)(args))[0];
int k = ((int *)(args))[1];
int j,dist_i_k,dist_k_j,dist_i_j;
for(j=1;j<=n;++j)
{
pthread_mutex_lock(&mutex);
r... | 0 |
#include <pthread.h>
struct Buffer {
char *buf;
int in;
int out;
int count;
int size;
pthread_cond_t empty;
pthread_cond_t full;
pthread_mutex_t m;
};
void put(struct Buffer *b, char c) {
pthread_mutex_lock(&b->m);
printf("put\\n");
while (b->count==b->size) {
printf(... | 1 |
#include <pthread.h>
int voti[2];
char film[2][40];
char vincitore[40];
int pareri;
pthread_mutex_t m;
} sondaggio;
sem_t mb;
sem_t sb;
int arrivati;
} barriera;
pthread_mutex_t mf;
char vincitore[40];
} film_stream;
sondaggio S;
barriera B;
film_stream F;
void init(sond... | 0 |
#include <pthread.h>
int buffer[1024];
int count=0;
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
pthread_mutex_t mutex3;
void *threadFun1(void *arg)
{
int i;
while(1)
{
pthread_mutex_lock(&mutex1);
printf("Thread 1\\n");
count++;
if((count%2)==1)
{
pthread_mutex_unlock(&mu... | 1 |
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int glo_val1 = 1, glo_val2 = 2;
void *ssu_thread1(void *arg);
void *ssu_thread2(void *arg);
int main(void) {
pthread_t tid1, tid2;
pthread_create(&tid1, 0, ssu_thread1, ... | 0 |
#include <pthread.h>
struct timeval search_start;
struct timeval search_target_end;
unsigned int white_time_left;
unsigned int white_time_inc;
unsigned int black_time_left;
unsigned int black_time_inc;
bool think_infinite;
bool v_is_thinking;
bool stop_status;
pthread_mutex_t lock;
void set_i... | 1 |
#include <pthread.h>
pthread_t stu_thread[2];
pthread_mutex_t mutex_lock;
pthread_cond_t cond_ready;
int number = 0;
void * studentA()
{
int i = 0;
for(i = 0; i < 5; i++)
{
pthread_mutex_lock(&mutex_lock);
number++;
printf("studentA has finished the work one ... | 0 |
#include <pthread.h>
pthread_t pthreads[4];
pthread_mutex_t locks[4];
char *topics[3] = {"life","death","world hunger"};
void *philosopher(void *arg){
int philonum = *((int *)arg);
int left_fork;
int right_fork;
left_fork=philonum;
if(philonum==4 -1)
right_fork = 0;
... | 1 |
#include <pthread.h>
void *countWords(void *);
int wordCount = 0;
pthread_mutex_t mutex;
char data[81920];
struct bufferPartition
{
int start;
int end;
};
int main(int argc, char *argv[])
{
clock_t t1,t2;
int bytesRead = 1;
struct bufferPartition partitions[1];
pthrea... | 0 |
#include <pthread.h>
void *producer(void *param);
void *consumer(void *param);
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
sem_t buf_full;
sem_t buf_empty;
sem_t complete;
int times;
int con_count;
int num_consumed = 0;
int buffer[1];
void *produce (void *param)
{
unsigned int s... | 1 |
#include <pthread.h>
int prod_pos;
int cons_pos;
sem_t full;
sem_t empty;
pthread_mutex_t mutex;
int buff_filled;
char **buffer;
} prod_cons_t;
void *insere_buffer(prod_cons_t *prod_cons) {
do {
char *buffer = (char *)malloc(1024*sizeof(char));
... | 0 |
#include <pthread.h>
int MYTHREADS = 2;
double sumArray[8];
int count = 0;
int n = 1048576;
int nArray[1048576];
struct params {
pthread_mutex_t mutex;
pthread_cond_t done;
int id;
};
void* threadWork(void* arg) {
int id;
pthread_mutex_lock(&(*(params_t*)(arg)).mutex);
id = (*(pa... | 1 |
#include <pthread.h>
pthread_attr_t attr;
pthread_t threads[25];
pthread_mutex_t threads_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t wait_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t rand_lock = PTHREAD_MUTEX_INITIALIZER;
sem_t death_lock;
pthread_mutex_t count_lock = PTHREAD_MUTEX_IN... | 0 |
#include <pthread.h>
pthread_cond_t cv_suspend;
pthread_mutex_t mx_suspend;
pthread_t thr_sleepy;
void* thread_sleepy(void*);
int main()
{
pthread_condattr_t attr_cv_suspend;
pthread_condattr_init(&attr_cv_suspend);
pthread_condattr_setpshared(&attr_cv_suspend, PTHREAD_PROCES... | 1 |
#include <pthread.h>
struct servent_data _servent_data;
void
setservent(int f)
{
pthread_mutex_lock(&_servent_mutex);
setservent_r(f, &_servent_data);
pthread_mutex_unlock(&_servent_mutex);
}
void
endservent(void)
{
pthread_mutex_lock(&_servent_mutex);
endservent_r(&_servent_data);
pth... | 0 |
#include <pthread.h>
char pass[4 +1];
char *senha_passada_arg;
char *senha_compartilhada[50];
int buffer[50];
int inicio = 0, final = 0, cont = 0;
pthread_mutex_t bloqueio;
pthread_cond_t nao_vazio, nao_cheio;
void calcula_hash_senha(const char *senha, char *hash);
void incrementa_senh... | 1 |
#include <pthread.h>extern void __VERIFIER_error() ;
void __VERIFIER_assert(int expression) { if (!expression) { ERROR: __VERIFIER_error();}; return; }
char *v;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
void *thread1(void * arg)
{
v = malloc(sizeof(char));
return 0;
}
void *thread2(... | 0 |
#include <pthread.h>
const int MAX_THREADS = 1024;
void* Thread_sum(void* rank);
void Get_args(int argc, char* argv[]);
void Usage(char* prog_name);
double Serial_pi(long long n);
long thread_count;
long long n;
double sum, sum_serial;
pthread_mutex_t mutex;
int main(int argc, char* argv[]) {
... | 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 *
timeout_helper(void *arg)
{
struct to_info *tip;
tip = (struct to_info *)arg;
nanosleep(&tip->to_wait, 0);
(*tip->to_f... | 0 |
#include <pthread.h>
struct thread_data
{
int thread_id;
int my_turn_num[100];
};
pthread_t threads[2 - 1];
struct thread_data thread_data_array[2];
int cur_t = 0;
pthread_cond_t condition[2 - 1];
pthread_mutex_t mutex[2 - 1];
pthread_attr_t attr;
int ready[2 -1];
void *Get_times(void *thre... | 1 |
#include <pthread.h>
static char s_msgbuf[256];
pthread_mutex_t s_msgbufMutex = PTHREAD_MUTEX_INITIALIZER;
void print_msg(enum LoggerLevel level, const char* prefix, const void* buf, int len)
{
if (LogIsEnabled(level)) {
char* p = s_msgbuf;
int bufLeft = sizeof(s_ms... | 0 |
#include <pthread.h>
int element[(20)];
int head;
int tail;
int amount;
} QType;
pthread_mutex_t m;
int __VERIFIER_nondet_int(void);
int stored_elements[(20)];
_Bool enqueue_flag, dequeue_flag;
QType queue;
int init(QType *q)
{
q->head=0;
q->tail=0;
q->amount=0;
}
int empty(... | 1 |
#include <pthread.h>
{
int thread_no;
int *data;
pthread_mutex_t *mutex;
} thread_arg_t;
void *thread_func(void *arg)
{
thread_arg_t* targ = (thread_arg_t *)arg;
int i,result;
for(i=0;i<10;i++){
pthread_mutex_lock(targ->mutex);
result = targ->data[i] + 1;
sched_yiel... | 0 |
#include <pthread.h>
int done;
pthread_cond_t *multiple;
pthread_mutex_t *print_lock;
int print;
int simulations;
int inside_circ;
pthread_mutex_t *inside_circ_lock;
int total_sims_done;
pthread_mutex_t *total_sims_done_lock;
pthread_mutex_t *rand_lock;
void *print_pi(void *arg)
{
whil... | 1 |
#include <pthread.h>
struct node {
long tid;
int primenumber;
struct node *next;
}*head,*var;
int number=0;
char filename[20];
int isLooked[100000000];
FILE *file;
void createList(long td,int n){
struct node *temp;
temp=head;
var=(struct node *)malloc(sizeof (struct no... | 0 |
#include <pthread.h>
pthread_cond_t is_zero;
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);
}
pthread_mutex_unlock... | 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_r(const char *name)
{
int i, ... | 0 |
#include <pthread.h>
struct Bloom* createBloom(int size_memory){
struct Bloom* bfilter = (struct Bloom*)malloc(sizeof(struct Bloom));
bfilter-> bit = (uint64_t*)malloc(sizeof(uint64_t)*size_memory);
bfilter->mutexArr = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t)*size_memory);
... | 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) {
... | 0 |
#include <pthread.h>
int ncount;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* do_loop(void *data)
{
int i;
for (i = 0; i < 10; i++)
{
pthread_mutex_lock(&mutex);
printf("loop1 : %d\\n", ncount);
ncount ++;
if(i == 10)
return;
... | 1 |
#include <pthread.h>
int file_idx;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
char **args;
int N;
void clean(int signal);
void *convert_file(void *file_name);
int main (int argc, char ** argv) {
struct sigaction action;
action.sa_handler = &clean;
sigaction(SIGINT, &action,... | 0 |
#include <pthread.h>
struct Settings
{
int output_result;
unsigned long long N;
int M;
};
struct Settings read_settings(int argc, char** argv)
{
struct Settings settings;
if (argc < 3)
{
printf("wrong arguments count\\n");
exit(-1);
}
if (strcmp(argv[1], "-p") == 0)
{
settings.ou... | 1 |
#include <pthread.h>
pthread_mutex_t alarm_mutex;
volatile int spawnflag;
void uplink_alarm_handle(int sig) {
pthread_mutex_lock(&alarm_mutex);
spawnflag++;
pthread_mutex_unlock(&alarm_mutex);
}
void uplink_alarm_init(unsigned long delta) {
spawnflag = 0;
pthread_mutex_init(&alarm_mut... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.