static void *do_recv_wait(void *args)
{
NNTI_result_t rc;
selfsend_args *ssa;
double wait_time=0.0;
NNTI_alloc(&trans_hdl, NNTI_REQUEST_BUFFER_SIZE, 1, NNTI_RECV_DST, &recv_mr);
NNTI_create_work_request(&recv_mr, &recv_wr);
/* client is waiting for us to initialize */
pthread_barrier_wait(&barrier3);
wait_time=trios_get_time_ms();
/* the client sends a message here */
NNTI_wait(&recv_wr, RECV_TIMEOUT, &recv_status);
wait_time=trios_get_time_ms()-wait_time;
// if wait time varies from the timeout by more than 100ms, then fail.
if ((wait_time < (RECV_TIMEOUT-100)) || (wait_time > (RECV_TIMEOUT+100))) {
fprintf(stdout, "Time to complete NNTI_wait: expected=%lums ; actual=%lums\n", (uint64_t)RECV_TIMEOUT, (uint64_t)wait_time);
success=false;
}
pthread_barrier_wait(&barrier2);
wait_time=trios_get_time_ms();
/* the client sends a message here */
NNTI_wait(&recv_wr, -1, &recv_status);
wait_time=trios_get_time_ms()-wait_time;
ssa=(selfsend_args *)recv_status.start;
if (ssa->chksum != calc_checksum((const char *)&ssa->data, sizeof(data_t))) {
fprintf(stdout, "checksum failure in the receive thread");
success=false;
}
pthread_barrier_wait(&barrier3);
NNTI_destroy_work_request(&recv_wr);
NNTI_free(&recv_mr);
return(NULL);
}
/**
* @brief Test the timer.
*
* An easy way to test the timer is to time the sleep function
* for a fixed amount of time. If the timer results a time that
* matches the sleep time within a reasonable error, the timer works.
*
* @return 0 on success, 1 on error.
*/
int trios_timer_test()
{
int rc = 0;
static const uint64_t sleep_us = 1000000; /* 1 second */
/* TODO: what should be the acceptable error (1/2 sec?) */
static const uint64_t error_ms = 500;
uint64_t error_ns = error_ms * 1000000;
uint64_t error_us = error_ms * 1000;
double error_sec = (double)error_ms/1000.0;
uint64_t start_ns=0, t_ns=0;
uint64_t start_us, t_us;
uint64_t start_ms, t_ms;
double start_sec, t_sec;
log_debug(timer_debug_level, "this is a timer test. expect a 1 second delay. starting...");
/* run to initialize timer */
start_ns = trios_get_time_ns();
if (usleep(sleep_us)) {
log_error(timer_debug_level, "Failed calling usleep()");
return 1;
}
/* run to get measurements */
start_ns = trios_get_time_ns();
start_us = trios_get_time_us();
start_ms = trios_get_time_ms();
start_sec = trios_get_time();
/* sleep one seconds */
usleep(sleep_us);
t_ns = trios_get_time_ns() - start_ns;
t_us = trios_get_time_us() - start_us;
t_ms = trios_get_time_ms() - start_ms;
t_sec = trios_get_time() - start_sec;
printf("slept for %llu seconds:\n", sleep_us);
printf("\tns = %llu\n", t_ns);
printf("\tus = %llu\n", t_us);
printf("\tms = %llu\n", t_ms);
printf("\tsec = %f\n", t_sec);
/* Make sure our values have a reasonable error */
if (labs(t_ns - (sleep_us * 1e3)) > error_ns) {
uint64_t actual_err = labs(t_ns - (sleep_us *1e3));
log_error(timer_debug_level,
"trios_timer failed ns timer test: err = %llu ns"
" > acceptable err = %llu",
actual_err, error_ns);
rc = 1;
}
if (labs(t_us - sleep_us) > error_us) {
uint64_t actual_err = labs(t_us - sleep_us);
log_error(timer_debug_level,
"trios_timer failed usec timer test: err = %llu usec"
" > acceptable err = %llu",
actual_err, error_us);
rc |= 1;
}
if (labs(t_ms - (sleep_us / 1e3)) > error_ms) {
uint64_t actual_err = labs(t_ms - (sleep_us / 1e3));
log_error(timer_debug_level,
"trios_timer failed ns timer test: err = %llu ms"
" > acceptable err = %llu",
actual_err, error_ms);
rc |= 1;
}
if (fabs(t_sec - ((double)sleep_us / 1e6)) > error_sec) {
double actual_err = fabs(t_sec - ((double)sleep_us/1e6));
log_error(timer_debug_level,
"trios_timer failed sec timer test: err = %g sec "
" > acceptable err = %g",
actual_err, error_sec);
rc |= 1;
}
log_debug(timer_debug_level, "timer test complete");
return rc;
}
void make_progress(bool is_idle)
{
log_debug(injection_debug_level, "current_time(%llu) is_idle(%llu)", (uint64_t)trios_get_time_ms(), (uint64_t)is_idle);
return;
}
