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; }