Ejemplo n.º 1
0
void wake_child(int itsid, int broadcast_flag)
{
	double starttime;

	pthread_mutex_lock(&child_mutex);
	while (child_waiting[itsid] == 0) {
		pthread_mutex_unlock(&child_mutex);
		sched_yield();
		pthread_mutex_lock(&child_mutex);
	}
	pthread_mutex_unlock(&child_mutex);
	if (broadcast_flag) {
		starttime = d_gettimeofday();
		if (pthread_cond_broadcast(&condlist[itsid]) != 0) {
			perror("pthread_cond_broadcast");
			exit(-1);
		}
	} else {
		starttime = d_gettimeofday();
		if (pthread_cond_signal(&condlist[itsid]) != 0) {
			perror("pthread_cond_signal");
			exit(-1);
		}
	}
	for (;;) {
		pthread_mutex_lock(&child_mutex);
		if (child_waiting[itsid] == 2) {
			break;
		}
		pthread_mutex_unlock(&child_mutex);
		poll(NULL, 0, 10);
	}
	latency = (unsigned long)((endtime - starttime) * 1000000.);
	pthread_mutex_unlock(&child_mutex);
}
Ejemplo n.º 2
0
void *
childfunc(void *arg)
{
	int myid = (intptr_t)arg;
	pthread_cond_t *cp;
	volatile int *cw;

	cp = &condlist[myid];
	cw = &child_waiting[myid];
	while (*cw == 0) {
		pthread_mutex_lock(&child_mutex);
		*cw = 1;
		if (pthread_cond_wait(cp, &child_mutex) != 0) {
			perror("pthread_cond_wait");
			exit(-1);
		}
		endtime = d_gettimeofday();
		*cw = 2;
		pthread_mutex_unlock(&child_mutex);
		while (*cw == 2) {
			poll(NULL, 0, 10);
		}
	}
	pthread_exit(NULL);
}
Ejemplo n.º 3
0
void *
childfunc(void *arg)
{
	pthread_cond_t *cp = (pthread_cond_t *)arg;

	while (child_waiting == 0) {
		pthread_mutex_lock(&child_mutex);
		child_waiting = 1;
		if (pthread_cond_wait(cp, &child_mutex) != 0) {
			perror("pthread_cond_wait");
			exit(-1);
		}
		endtime = d_gettimeofday();
		child_waiting = 2;
		pthread_mutex_unlock(&child_mutex);
		while (child_waiting == 2) {
			poll(NULL, 0, 10);
		}
	}
	pthread_exit(NULL);
}
Ejemplo n.º 4
0
void
test_signal(int broadcast_flag, int iter)
{
	pthread_attr_t attr;
	pthread_t childid;
	pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
	int i;
	int prio;
	struct sched_param schparm;
	double starttime;

	prio = sched_get_priority_max(SCHED_FIFO);
	if (prio == -1) {
		perror("sched_get_priority_max");
		exit(-1);
	}
	schparm.sched_priority = prio;
	if (sched_setscheduler(getpid(), SCHED_FIFO, &schparm) != 0) {
		perror("sched_setscheduler");
		exit(-1);
	}

	if (pthread_attr_init(&attr) != 0) {
		perror("pthread_attr_init");
		exit(-1);
	}
	if (pthread_attr_setschedpolicy(&attr, SCHED_FIFO) != 0) {
		perror("pthread_attr_setschedpolicy");
		exit(-1);
	}
	if (pthread_attr_setschedparam(&attr, &schparm) != 0) {
		perror("pthread_attr_setschedparam");
		exit(-1);
	}
	if (pthread_create(&childid, &attr, childfunc, (void *)&cond) != 0) {
		perror("pthread_create");
		exit(-1);
	}
	for (i = 0; i < iter; i++) {
		pthread_mutex_lock(&child_mutex);
		child_waiting = 0;
		while (child_waiting == 0) {
			pthread_mutex_unlock(&child_mutex);
			sched_yield();
			pthread_mutex_lock(&child_mutex);
		}
		pthread_mutex_unlock(&child_mutex);
		if (broadcast_flag) {
			starttime = d_gettimeofday();
			if (pthread_cond_broadcast(&cond) != 0) {
				perror("pthread_cond_broadcast");
				exit(-1);
			}
		} else {
			starttime = d_gettimeofday();
			if (pthread_cond_signal(&cond) != 0) {
				perror("pthread_cond_signal");
				exit(-1);
			}
		}
		for (;;) {
			pthread_mutex_lock(&child_mutex);
			if (child_waiting == 2) {
				break;
			}
			pthread_mutex_unlock(&child_mutex);
			poll(NULL, 0, 10);
		}
		printf("%s() latency: %d microseconds\n",
		       (broadcast_flag
				? "pthread_cond_broadcast"
				: "pthread_cond_signal"),
		       (int)((endtime - starttime) * 1000000.));
		pthread_mutex_unlock(&child_mutex);
	}
	pthread_mutex_lock(&child_mutex);
	child_waiting = 3;
	pthread_mutex_unlock(&child_mutex);
	if (pthread_join(childid, NULL) != 0) {
		perror("pthread_join");
		exit(-1);
	}
}
Ejemplo n.º 5
0
void* run(void* arg)
{
	unsigned long i;
	char iamreader;
	int key; long t = (long) arg; long nbn;//same cache line for the best rand!
	double start, end;
	node_t **hd;
	lock_t *lck;

	set_affinity(t);

	/************ init *****************/
	thd_ins = 0;
	thd_del = 0;
	thd_sea = 0;
	nbmallocs = 0;
	nbretry = 0;
	nbrelink = 0;
	nbreprev = 0;
	nbfl = 0;
	thread=t;
	thd_nbupdaters=nbupdaters;
	setsignals();
	iamreader = t >= nbupdaters ? 1 : 0;
	if(!iamreader)	prealloc();
	mysrand(t^time(NULL));
	/************** init done **************/

	/************** barrier ****************/
	atomic_xadd4(&ready, 1);
	while(!go) memory_barrier();

	/******************* START ****************/
	start = d_gettimeofday();
#ifdef RCU
	rcu_register_thread();
#endif

	i=0;
	do{
		key = myrand()%nbkeys;
		//key = rand_r(&thd_seed)%nbthreads;
		//key = (t+key)%nbkeys;
		//key = random() % nbkeys;
		//if(i%100000) printf("%d %d\n", thread, key);

		get_buckets(key, &hd, &lck);
		if(iamreader)
		{
			thd_sea += search(key, hd, lck);
			if(i>= NB_TEST) break;
		}
		else
		{
			if(i%2)
				thd_ins += insert(key, hd, lck);
			else
				thd_del += delete(key, hd, lck);
			if(done) {
				//printf("writer stopped\n");
				break;
			}
		}
		//if(!(i%10000)) 
			//printf("%d loop %d\n", t, i);
#ifdef RCU_QSBR
#if ((defined RCU_QSBR_ACCELERATE) || (defined RCU_Q10))
#ifdef RCU_Q10
		if(!(i%10)) 
#else
		if(!(i%100)) 
#endif
#endif
			rcu_quiescent_state();
#endif
	}while(++i);

#ifdef RCU
	//if(!iamreader) rcu_barrier();
	//printf("iamreader %d, ops %d\n", iamreader, i);
	rcu_unregister_thread();
#endif

	end = d_gettimeofday(); 
	/******************* END ****************/

	
	//number of ops done
	thd_ops[t] = i;
	
	//printf("nbmallocs %g\n", nbmallocs);
	thd_mallocs[t] = nbmallocs;
	thd_retry[t] = nbretry;
	thd_relink[t] = nbrelink;
	thd_reprev[t] = nbreprev;

	//if(t==0) printf("%lu | nbblocked %g\n", t, nbblockeds);
#ifdef RCU
	thd_blockeds[t] = atomic_read_ptr(&rcublockeds);
#else
	thd_blockeds[t] = nbblockeds;
#endif

	//average time per ops
	avg_time[t] = (((end - start))/i);

	//total time
	thd_time[t] = (end - start);

	suc_ins[t] = thd_ins;
	suc_sea[t] = thd_sea;
	suc_del[t] = thd_del;

	return NULL;
}