From 6efa7aa73ef36cb0c299e34b5457ab0e4ebf88e3 Mon Sep 17 00:00:00 2001 From: "E. Scott Daniels" Date: Mon, 15 Jul 2019 10:31:42 -0400 Subject: [PATCH] Prevent unneeded usleep after send retries If retries were enabled, an extra usleep for 1mu-sec was being unnecessarily executed after the last retry attempt. Doc related to retries modifided in main rmr_nng module. Signed-off-by: E. Scott Daniels Change-Id: If8032a86bba5df63231c6dd5e50f262c64875c13 --- CHANGES | 3 +++ CMakeLists.txt | 2 +- src/rmr/nng/src/rmr_nng.c | 16 ++++++++-------- src/rmr/nng/src/sr_nng_static.c | 6 ++++-- 4 files changed, 16 insertions(+), 11 deletions(-) diff --git a/CHANGES b/CHANGES index e39544c..dc94525 100644 --- a/CHANGES +++ b/CHANGES @@ -1,6 +1,9 @@ Change Summaries +2019 July 15; Version 1.0.39 + Prevent unnecessary usleep in retry loop. + 2019 July 12; Version 1.0.38 Added new message types to RIC_message_types.h. diff --git a/CMakeLists.txt b/CMakeLists.txt index 445f0a2..ef4f17f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,7 +31,7 @@ cmake_minimum_required( VERSION 3.5 ) set( major_version "1" ) # should be automatically populated from git tag later, but until CI process sets a tag we use this set( minor_version "0" ) -set( patch_level "38" ) +set( patch_level "39" ) set( install_root "${CMAKE_INSTALL_PREFIX}" ) set( install_lib "lib" ) diff --git a/src/rmr/nng/src/rmr_nng.c b/src/rmr/nng/src/rmr_nng.c index cf5e429..7e0b37e 100644 --- a/src/rmr/nng/src/rmr_nng.c +++ b/src/rmr/nng/src/rmr_nng.c @@ -524,17 +524,15 @@ extern rmr_mbuf_t* rmr_rcv_specific( void* vctx, rmr_mbuf_t* msg, char* expect, return NULL; } -// CAUTION: these are not supported as they must be set differently (between create and open) in NNG. -// until those details are worked out, these generate a warning. /* - Set send timeout. The value time is assumed to be microseconds. The timeout is the - rough maximum amount of time that RMr will block on a send attempt when the underlying + Set send timeout. The value time is assumed to be milliseconds. The timeout is the + _rough_ maximum amount of time that RMr will block on a send attempt when the underlying mechnism indicates eagain or etimeedout. All other error conditions are reported without this delay. Setting a timeout of 0 causes no retries to be attempted in - RMr code. Setting a timeout of 1 causes RMr to spin up to 10K retries before returning, - but without issuing a sleep. If timeout is > 1, then RMr will issue a sleep (1us) - after every 10K send attempts until the time value is reached. Retries are abandoned - if NNG returns anything other than NNG_AGAIN or NNG_TIMEDOUT. + RMr code. Setting a timeout of 1 causes RMr to spin up to 1K retries before returning, + but _without_ issuing a sleep. If timeout is > 1, then RMr will issue a sleep (1us) + after every 1K send attempts until the "time" value is reached. Retries are abandoned + if NNG returns anything other than NNG_EAGAIN or NNG_ETIMEDOUT. The default, if this function is not used, is 1; meaning that RMr will retry, but will not enter a sleep. In all cases the caller should check the status in the message returned @@ -559,6 +557,8 @@ extern int rmr_set_stimeout( void* vctx, int time ) { /* Set receive timeout -- not supported in nng implementation + + CAUTION: this is not supported as they must be set differently (between create and open) in NNG. */ extern int rmr_set_rtimeout( void* vctx, int time ) { fprintf( stderr, "[WRN] Current implementation of RMR ontop of NNG does not support setting a receive timeout\n" ); diff --git a/src/rmr/nng/src/sr_nng_static.c b/src/rmr/nng/src/sr_nng_static.c index b7fa3f2..79e6793 100644 --- a/src/rmr/nng/src/sr_nng_static.c +++ b/src/rmr/nng/src/sr_nng_static.c @@ -514,7 +514,7 @@ static rmr_mbuf_t* send_msg( uta_ctx_t* ctx, rmr_mbuf_t* msg, nng_socket nn_sock int state; uta_mhdr_t* hdr; int nng_flags = NNG_FLAG_NONBLOCK; // if we need to set any nng flags (zc buffer) add it to this - int spin_retries = 1000; // if eagain/timeout we'll spin this many times before giving up the CPU + int spin_retries = 1000; // if eagain/timeout we'll spin, at max, this many times before giving up the CPU int tr_len; // trace len in sending message so we alloc new message with same trace size // future: ensure that application did not overrun the XID buffer; last byte must be 0 @@ -539,7 +539,9 @@ static rmr_mbuf_t* send_msg( uta_ctx_t* ctx, rmr_mbuf_t* msg, nng_socket nn_sock if( retries > 0 && (state == NNG_EAGAIN || state == NNG_ETIMEDOUT) ) { if( --spin_retries <= 0 ) { // don't give up the processor if we don't have to retries--; - usleep( 1 ); // sigh, give up the cpu and hope it's just 1 miscrosec + if( retries > 0 ) { // only if we'll loop through again + usleep( 1 ); // sigh, give up the cpu and hope it's just 1 miscrosec + } spin_retries = 1000; } } else { -- 2.16.6