RIC:1060: Change in PTL

[ric-plt/lib/rmr.git] / src / rmr / common / src / rt_generic_static.c

diff --git a/src/rmr/common/src/rt_generic_static.c b/src/rmr/common/src/rt_generic_static.c
index c2fd5f8..5baf79a 100644 (file)
--- a/src/rmr/common/src/rt_generic_static.c
+++ b/src/rmr/common/src/rt_generic_static.c
@@ -46,6 +46,8 @@
 #include <unistd.h>
 #include <netdb.h>
 #include <pthread.h>
+#include <immintrin.h>
+#include <stdbool.h>
 
 #include <RIC_message_types.h>         // needed for route manager messages
 
@@ -369,12 +371,18 @@ static void alarm_if_drops( uta_ctx_t* uctx, uta_ctx_t* pctx ) {
 }
 
 // ---- utility -----------------------------------------------------------------------------------
+
+int isspace_with_fence(int c) {
+       _mm_lfence();
+       return isspace( c );
+}
+
 /*
        Little diddy to trim whitespace and trailing comments. Like shell, trailing comments
        must be at the start of a word (i.e. must be immediatly preceeded by whitespace).
 */
 static char* clip( char* buf ) {
-       char*   tok;
+       char*   tok=NULL;
 
        while( *buf && isspace( *buf ) ) {                                                      // skip leading whitespace
                buf++;
@@ -390,7 +398,7 @@ static char* clip( char* buf ) {
                }
        }
 
-       for( tok = buf + (strlen( buf ) - 1); tok > buf && isspace( *tok ); tok-- );    // trim trailing spaces too
+       for( tok = buf + (strlen( buf ) - 1); tok > buf && isspace_with_fence( *tok ); tok-- ); // trim trailing spaces too
        *(tok+1) = 0;
 
        return buf;
@@ -448,25 +456,19 @@ static char* ensure_nlterm( char* buf ) {
        is no active table (first load), so we have to account for that (no locking).
 */
 static void roll_tables( uta_ctx_t* ctx ) {
-
+       pthread_mutex_lock( ctx->rtgate );                              // must hold lock to move to active
        if( ctx->new_rtable == NULL || ctx->new_rtable->error ) {
                rmr_vlog( RMR_VL_WARN, "new route table NOT rolled in: nil pointer or error indicated\n" );
                ctx->old_rtable = ctx->new_rtable;
-               ctx->new_rtable = NULL;
-               return;
-       }
-
-       if( ctx->rtable != NULL ) {                                                     // initially there isn't one, so must check!
-               pthread_mutex_lock( ctx->rtgate );                              // must hold lock to move to active
+       }else if( ctx->rtable != NULL ) {                                                       // initially there isn't one, so must check!
                ctx->old_rtable = ctx->rtable;                                  // currently active becomes old and allowed to 'drain'
                ctx->rtable = ctx->new_rtable;                                  // one we've been adding to becomes active
-               pthread_mutex_unlock( ctx->rtgate );
        } else {
                ctx->old_rtable = NULL;                                         // ensure there isn't an old reference
                ctx->rtable = ctx->new_rtable;                          // make new the active one
        }
-
        ctx->new_rtable = NULL;
+       pthread_mutex_unlock( ctx->rtgate );
 }
 
 /*
@@ -952,7 +954,7 @@ static void parse_rt_rec( uta_ctx_t* ctx,  uta_ctx_t* pctx, char* buf, int vleve
        int     grp;                                                    // group number
        rtable_ent_t const*     rte;                    // route table entry added
        char*   tokens[128];
-       char*   tok;                                            // pointer into a token or string
+       char*   tok=NULL;                                               // pointer into a token or string
        char    wbuf[1024];
 
        if( ! buf ) {
@@ -967,7 +969,7 @@ static void parse_rt_rec( uta_ctx_t* ctx,  uta_ctx_t* pctx, char* buf, int vleve
        while( *buf && isspace( *buf ) ) {                                                      // skip leading whitespace
                buf++;
        }
-       for( tok = buf + (strlen( buf ) - 1); tok > buf && isspace( *tok ); tok-- );    // trim trailing spaces too
+       for( tok = buf + (strlen( buf ) - 1); tok > buf && isspace_with_fence( *tok ); tok-- ); // trim trailing spaces too
        *(tok+1) = 0;
 
        memset( tokens, 0, sizeof( tokens ) );
@@ -1361,10 +1363,7 @@ static route_table_t* uta_rt_init( uta_ctx_t* ctx ) {
                return NULL;
        }
 
-       rt->gate = ctx->rtgate;                                         // single mutex needed for all route tables
        rt->ephash = ctx->ephash;                                       // all route tables share a common endpoint hash
-       pthread_mutex_init( rt->gate, NULL );
-
        return rt;
 }
 
@@ -1501,22 +1500,27 @@ static route_table_t* uta_rt_clone( uta_ctx_t* ctx, route_table_t* srt, route_ta
        do not need to run that portion of the table to deref like we do for the RTEs.
 */
 static route_table_t* prep_new_rt( uta_ctx_t* ctx, int all ) {
-       int counter = 0;
+       //int counter = 0;
        route_table_t*  rt;
 
        if( ctx == NULL ) {
                return NULL;
        }
 
+       pthread_mutex_lock( ctx->rtgate );
        if( (rt = ctx->old_rtable) != NULL ) {
                ctx->old_rtable = NULL;
-               while( rt->ref_count > 0 ) {                    // wait for all who are using to stop
-                       if( counter++ > 1000 ) {
-                               rmr_vlog( RMR_VL_WARN, "rt_prep_newrt:  internal mishap, ref count on table seems wedged" );
-                               break;
-                       }
 
+               while(  rt->ref_count > 0 ) {                           // wait for all who are using to stop
+                       //if( counter++ > 1000 ) {
+                       //      rmr_vlog( RMR_VL_WARN, "rt_prep_newrt:  internal mishap, ref count on table seems wedged" );
+                       //      break;
+                       //}
+
+                       pthread_mutex_unlock( ctx->rtgate );
                        usleep( 1000 );                                         // small sleep to yield the processer if that is needed
+                       pthread_mutex_lock( ctx->rtgate );
+
                }
 
                if( rt->hash != NULL ) {
@@ -1528,6 +1532,7 @@ static route_table_t* prep_new_rt( uta_ctx_t* ctx, int all ) {
        } else {
                rt = NULL;
        }
+       pthread_mutex_unlock( ctx->rtgate );
 
        rt = uta_rt_clone( ctx, ctx->rtable, rt, all );         // also sets the ephash pointer
        if( rt != NULL ) {                                                                      // very small chance for nil, but not zero, so test
@@ -1679,4 +1684,5 @@ static inline void release_rt( uta_ctx_t* ctx, route_table_t* rt ) {
        }
        pthread_mutex_unlock( ctx->rtgate );
 }
+
 #endif