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 <daniels@research.att.com>
Change-Id: If8032a86bba5df63231c6dd5e50f262c64875c13

diff --git a/CHANGES b/CHANGES
index e39544c..dc94525 100644 (file)
--- 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 (file)
--- 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 (file)
--- 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 (file)
--- 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 {