static inline void
s_final(void) {
lagopus_bbq_destroy(&s_idle_tsk_q, true);
lagopus_bbq_destroy(&s_urgent_tsk_q, true);
lagopus_hashmap_destroy(&s_tsk_tbl, true);
lagopus_cond_destroy(&s_sched_cnd);
lagopus_mutex_destroy(&s_lck);
lagopus_mutex_destroy(&s_sched_lck);
}
static inline void
s_destroy_all(void) {
if (is_child == true) {
s_stop_all();
(void)lagopus_mutex_lock(&stop_lock);
{
size_t i;
test_thread_t tt;
/*
* Wait the threads done and delete it.
*/
if (tts != NULL) {
for (i = 0; i < n_created_thds; i++) {
tt = &(tts[i]);
(void)lagopus_thread_wait((lagopus_thread_t *)&tt, -1LL);
(void)lagopus_thread_destroy((lagopus_thread_t *)&tt);
}
free((void *)tts);
tts = NULL;
}
if (polls != NULL) {
for (i = 0; i < n_created_polls; i++) {
lagopus_qmuxer_poll_destroy(&(polls[i]));
}
free((void *)polls);
polls = NULL;
}
if (bbqs != NULL) {
for (i = 0; i < n_created_bbqs; i++) {
lagopus_bbq_destroy(&(bbqs[i]), true);
}
free((void *)bbqs);
bbqs = NULL;
}
if (qmx != NULL) {
lagopus_qmuxer_destroy(&qmx);
qmx = NULL;
}
if (start_lock != NULL) {
lagopus_mutex_destroy(&start_lock);
start_lock = NULL;
}
}
(void)lagopus_mutex_unlock(&stop_lock);
if (stop_lock != NULL) {
lagopus_mutex_destroy(&stop_lock);
stop_lock = NULL;
}
}
}
static int
do_run(size_t nthds, ssize_t nputs) {
int ret = 1;
lagopus_result_t r;
size_t i;
size_t j;
char thdname[16];
lagopus_mutex_t start_lock = NULL;
test_thread_record *tts = NULL;
size_t n_created_thds = 0;
lagopus_bbq_t *bbqs = NULL;
size_t n_created_bbqs = 0;
lagopus_qmuxer_poll_t *polls = NULL;
size_t n_created_polls = 0;
lagopus_qmuxer_t qmx = NULL;
size_t n_need_watch = 0;
size_t n_valid_polls = 0;
ssize_t qsz;
test_thread_t tt;
lagopus_bbq_t bbq;
lagopus_chrono_t put_date;
lagopus_chrono_t t_begin;
lagopus_chrono_t t_end;
lagopus_chrono_t p_begin;
lagopus_chrono_t p_t;
ssize_t n_gets = 0;
lagopus_chrono_t p_min = LLONG_MAX;
lagopus_chrono_t p_max = LLONG_MIN;
double p_sum = 0.0;
double p_sum2 = 0.0;
double p_avg;
double p_sd;
lagopus_chrono_t t_total = 0;
double t_avg;
if ((r = lagopus_mutex_create(&start_lock)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
/*
* Create the qmuxer.
*/
if ((r = lagopus_qmuxer_create(&qmx)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
/*
* Then create queues.
*/
bbqs = (lagopus_bbq_t *)malloc(sizeof(lagopus_bbq_t) * nthds);
if (bbqs == NULL) {
goto done;
}
for (i = 0; i < nthds; i++) {
if ((r = lagopus_bbq_create(&(bbqs[i]), lagopus_chrono_t,
1000LL * 1000LL,
NULL)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
n_created_bbqs++;
}
if (n_created_bbqs == 0) {
goto done;
}
/*
* Then create poll objects for the each queue.
*/
polls = (lagopus_qmuxer_poll_t *)malloc(sizeof(lagopus_qmuxer_poll_t) *
n_created_bbqs);
if (polls == NULL) {
goto done;
}
for (i = 0; i < n_created_bbqs; i++) {
if ((r = lagopus_qmuxer_poll_create(&(polls[i]),
bbqs[i],
LAGOPUS_QMUXER_POLL_READABLE)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
n_created_polls++;
}
if (n_created_polls == 0) {
goto done;
}
/*
* Then create threads for the each poll objects/queues.
*/
tts = (test_thread_record *)malloc(sizeof(test_thread_record) *
n_created_polls);
if (tts == NULL) {
goto done;
}
for (i = 0; i < n_created_polls; i++) {
snprintf(thdname, sizeof(thdname), "putter " PFSZS(4, u), i);
tt = &(tts[i]);
if (test_thread_create(&tt, start_lock, bbqs[i], nputs,
(const char *)thdname) != true) {
goto done;
}
n_created_thds++;
}
if (n_created_thds == 0) {
goto done;
}
/*
* Let the initiation begin.
*/
/*
* Ready, note that all the created threads do this lock.
*/
(void)lagopus_mutex_lock(&start_lock);
/*
* Steady,
*/
for (i = 0; i < n_created_thds; i++) {
tt = &(tts[i]);
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
(void)lagopus_mutex_unlock(&start_lock);
goto done;
}
}
fprintf(stdout, "Test for " PFSZ(u) " threads " PFSZ(u)
" events/thdread start.\n", n_created_thds, (size_t)nputs);
/*
* Go.
*/
(void)lagopus_mutex_unlock(&start_lock);
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_begin);
while (true) {
/*
* Like the select(2)/poll(2), initialize poll objects before
* checking events.
*/
n_need_watch = 0;
n_valid_polls = 0;
for (i = 0; i < n_created_thds; i++) {
/*
* Check if the poll has a valid queue.
*/
bbq = NULL;
if ((r = lagopus_qmuxer_poll_get_queue(&(polls[i]), &bbq)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
break;
}
if (bbq != NULL) {
n_valid_polls++;
}
/*
* Reset the poll status.
*/
if ((r = lagopus_qmuxer_poll_reset(&(polls[i]))) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
break;
}
n_need_watch++;
}
/*
* If there are no valid queues, exit.
*/
if (n_valid_polls == 0) {
break;
}
/*
* Wait for an event.
*
* Note that we better set timeout, not waiting forever.
*/
r = lagopus_qmuxer_poll(&qmx, (lagopus_qmuxer_poll_t *const)polls,
n_need_watch,
100LL * 1000LL * 1000LL);
if (r > 0) {
/*
* Check which poll got an event. Actually, check all the queues
* in this sample.
*/
WHAT_TIME_IS_IT_NOW_IN_NSEC(p_begin);
for (i = 0; i < n_created_thds; i++) {
if ((qsz = lagopus_bbq_size(&(bbqs[i]))) > 0) {
//qsz = (qsz <= 10000LL) ? qsz : 10000LL;
lagopus_msg_debug(1, "Got " PFSZS(8, u) " events from the Q"
PFSZS(03, u) ".\n",
(size_t)qsz, (size_t)i);
for (j = 0; j < (size_t)qsz; j++) {
if ((r = lagopus_bbq_get(&(bbqs[i]), &put_date,
lagopus_chrono_t, -1LL)) ==
LAGOPUS_RESULT_OK) {
/*
* In this sample, -1LL is kinda 'EOF'. Check if we got
* the EOF.
*/
if (put_date == -1LL) {
/*
* The queue is kinda 'closed'. From now on we don't
* check this queue anymore. To specify this:
*/
lagopus_msg_debug(1, "Got an EOF from the Q" PFSZS(04, u)
".\n", i);
goto nullify;
}
p_t = p_begin - put_date;
if (p_t < p_min) {
p_min = p_t;
}
if (p_t > p_max) {
p_max = p_t;
}
p_sum += (double)p_t;
p_sum2 += ((double)p_t * (double)p_t);
n_gets++;
} else {
/*
* Something wrong for the queue. But we must not exit
* here. Keep on checking other queues. In order to do
* this, set NULL as the queue into the poll object for
* the queue.
*/
lagopus_perror(r);
nullify:
if ((r = lagopus_qmuxer_poll_set_queue(&(polls[i]), NULL)) !=
LAGOPUS_RESULT_OK) {
/*
* There is nothing we can do now.
*/
lagopus_perror(r);
goto done;
}
}
}
}
}
} else if (r == LAGOPUS_RESULT_TIMEDOUT) {
lagopus_msg_debug(1, "Timedout. continue.\n");
continue;
} else {
lagopus_perror(r);
lagopus_msg_debug(1, "Break the loop due to error(s).\n");
goto done;
}
}
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_end);
fprintf(stdout, "Done.\n");
fprintf(stdout, "Total # of the events:\t" PFSZS(22, u) "\n\n", n_gets);
p_avg = p_sum / (double)n_gets;
p_sd = (p_sum2 -
2.0 * p_avg * p_sum +
p_avg * p_avg * (double)n_gets) / (double)(n_gets - 1);
p_sd = sqrt(p_sd);
fprintf(stdout, "Queue stats:\n");
fprintf(stdout, "wait time min =\t" PFSZS(22, d) " nsec.\n", p_min);
fprintf(stdout, "wait time max =\t" PFSZS(22, d) " nsec.\n", p_max);
fprintf(stdout, "wait time avg =\t%25.2f nsec.\n", p_avg);
fprintf(stdout, "wait time sd =\t%25.2f.\n\n", p_sd);
t_total = t_end - t_begin;
t_avg = (double)t_total / (double)n_gets;
fprintf(stdout, "Throughput:\n");
fprintf(stdout, "total time:\t" PFSZS(22, d) " msec.\n",
(size_t)(t_total / 1000LL / 1000LL));
fprintf(stdout, "total avg:\t%25.2f nsec/event.\n", t_avg);
ret = 0;
done:
if (bbqs != NULL) {
for (i = 0; i < n_created_bbqs; i++) {
lagopus_bbq_destroy(&(bbqs[i]), true);
}
free((void *)bbqs);
}
if (polls != NULL) {
for (i = 0; i < n_created_polls; i++) {
lagopus_qmuxer_poll_destroy(&(polls[i]));
}
free((void *)polls);
}
if (tts != NULL) {
for (i = 0; i < n_created_thds; i++) {
tt = &(tts[i]);
lagopus_thread_destroy((lagopus_thread_t *)&tt);
}
free((void *)tts);
}
if (qmx != NULL) {
lagopus_qmuxer_destroy(&qmx);
}
if (start_lock != NULL) {
lagopus_mutex_destroy(&start_lock);
}
return ret;
}