Correctly remove the itag if we fail the condition. And be pedantic with the code.

This commit was SVN r14335.

orte/mca/gpr/replica/transition_layer/gpr_replica_dict_tl.c

@@ -2,7 +2,7 @@
  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
  *                         University Research and Technology
  *                         Corporation.  All rights reserved.
- * Copyright (c) 2004-2005 The University of Tennessee and The University
+ * Copyright (c) 2004-2007 The University of Tennessee and The University
  *                         of Tennessee Research Foundation.  All rights
  *                         reserved.
  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, 
@@ -27,23 +27,24 @@
 
 #include "orte_config.h"
 
-#include "orte/class/orte_pointer_array.h"
+#include "opal/hash_string.h"
 #include "opal/util/output.h"
 #include "opal/util/trace.h"
 
+#include "orte/class/orte_pointer_array.h"
 #include "orte/mca/errmgr/errmgr.h"
-
+#include "orte/mca/gpr/replica/gpr_replica.h"
 #include "orte/mca/gpr/replica/functional_layer/gpr_replica_fn.h"
-
 #include "orte/mca/gpr/replica/transition_layer/gpr_replica_tl.h"
 
 int
 orte_gpr_replica_create_itag(orte_gpr_replica_itag_t *itag,
                              orte_gpr_replica_segment_t *seg, char *name)
 {
-    char **ptr, *new_dict;
+    orte_gpr_replica_dict_entry_t* new_dict;
-    orte_gpr_replica_itag_t j;
+    orte_std_cntr_t index;
-    orte_std_cntr_t i, len, len2, index;
+    uint32_t len, hash_key;
+    int rc;
 
     OPAL_TRACE(3);
 
@@ -56,29 +57,19 @@ orte_gpr_replica_create_itag(orte_gpr_replica_itag_t *itag,
         return ORTE_ERR_BAD_PARAM;
     }
 
-    len = (orte_std_cntr_t)strlen(name);
+    if( ORTE_ERR_NOT_FOUND != (rc = orte_gpr_replica_dict_lookup(itag, seg, name))) {
+        return rc;
+    }
 
-    /* check seg's dictionary to ensure uniqueness */
+    OPAL_HASH_STRLEN( name, hash_key, len );
-    ptr = (char**)(seg->dict)->addr;
-    for (i=0, j=0; j < seg->num_dict_entries &&
-                   i < (seg->dict)->size; i++) {
-        if (NULL != ptr[i]) {
-            j++;
-            len2 = (orte_std_cntr_t)strlen(ptr[i]);
-            if ((len == len2 && 0 == strncmp(ptr[i], name, len))) {
-                /* already present */
-                if (i < ORTE_GPR_REPLICA_ITAG_MAX) {
-                    *itag = (orte_gpr_replica_itag_t)i;
-                    return ORTE_SUCCESS;
-                }
-                /* otherwise, the itag violates the max value */
-                return ORTE_ERR_BAD_PARAM;
-            }
-        }
-    }
     
     /* okay, name is unique - create dictionary entry */
-    new_dict = strdup(name);
+    new_dict = (orte_gpr_replica_dict_entry_t*)malloc( sizeof(orte_gpr_replica_dict_entry_t) + len );
+    new_dict->hash_key = hash_key;
+    new_dict->length = len;
+    strncpy( new_dict->string, name, len );
+    new_dict->string[len] = '\0';
+
     if (0 > orte_pointer_array_add(&index, seg->dict, (void*)new_dict)) {
         free(new_dict);
         ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
@@ -93,7 +84,8 @@ orte_gpr_replica_create_itag(orte_gpr_replica_itag_t *itag,
     
     /* otherwise, the itag violates the max value */
     free(new_dict);
-    ptr[index] = NULL;
+    /* remove itag from segment dictionary */
+    orte_pointer_array_set_item(seg->dict, (orte_std_cntr_t)index, NULL);
     
     return ORTE_ERR_OUT_OF_RESOURCE;
 }
@@ -101,7 +93,7 @@ orte_gpr_replica_create_itag(orte_gpr_replica_itag_t *itag,
 
 int orte_gpr_replica_delete_itag(orte_gpr_replica_segment_t *seg, char *name)
 {
-    char **ptr;
+    orte_gpr_replica_dict_entry_t **ptr;
     orte_gpr_replica_itag_t itag;
     int rc;
 
@@ -129,7 +121,7 @@ int orte_gpr_replica_delete_itag(orte_gpr_replica_segment_t *seg, char *name)
     }
 
     /* free the dictionary element data */
-     ptr = (char**)((seg->dict)->addr);
+    ptr = (orte_gpr_replica_dict_entry_t**)(seg->dict->addr);
     if (NULL == ptr[itag]) {  /* dict element no longer valid */
         return ORTE_ERR_NOT_FOUND;
     }
@@ -149,10 +141,10 @@ int
 orte_gpr_replica_dict_lookup(orte_gpr_replica_itag_t *itag,
                              orte_gpr_replica_segment_t *seg, char *name)
 {
-    char **ptr;
+    orte_gpr_replica_dict_entry_t **ptr;
     orte_std_cntr_t i;
     orte_gpr_replica_itag_t j;
-    orte_std_cntr_t len, len2;
+    uint32_t hash_key, len;
     
     OPAL_TRACE(3);
 
@@ -170,16 +162,16 @@ orte_gpr_replica_dict_lookup(orte_gpr_replica_itag_t *itag,
         return ORTE_SUCCESS;
     }
 
-    len = (orte_std_cntr_t)strlen(name);
+    OPAL_HASH_STRLEN( name, hash_key, len );
 
-    /* want specified token-itag pair in that segment's dictionary */
+    ptr = (orte_gpr_replica_dict_entry_t**)(seg->dict)->addr;
-    ptr = (char**)((seg->dict)->addr);
     for (i=0, j=0; j < seg->num_dict_entries &&
                    i < (seg->dict)->size; i++) {
-        if (NULL != ptr[i]) {
+        if (NULL == ptr[i]) continue;
         j++;
-            len2 = (orte_std_cntr_t)strlen(ptr[i]);
+        if( (len == ptr[i]->length) && (hash_key == ptr[i]->hash_key)
-	        if (len == len2 && 0 == strncmp(ptr[i], name, len)) {
+            && (0 == strncmp(ptr[i]->string, name, len)) ) {
+            /* already present */
             if (i < ORTE_GPR_REPLICA_ITAG_MAX) {
                 *itag = (orte_gpr_replica_itag_t)i;
                 return ORTE_SUCCESS;
@@ -188,7 +180,6 @@ orte_gpr_replica_dict_lookup(orte_gpr_replica_itag_t *itag,
             return ORTE_ERR_BAD_PARAM;
         }
     }
-	}
 
     return ORTE_ERR_NOT_FOUND; /* couldn't find the specified entry */
 }
@@ -197,7 +188,7 @@ orte_gpr_replica_dict_lookup(orte_gpr_replica_itag_t *itag,
 int orte_gpr_replica_dict_reverse_lookup(char **name,
         orte_gpr_replica_segment_t *seg, orte_gpr_replica_itag_t itag)
 {
-    char **ptr;
+    orte_gpr_replica_dict_entry_t **ptr;
     orte_gpr_replica_segment_t **segptr;
 
     OPAL_TRACE(3);
@@ -227,11 +218,11 @@ int orte_gpr_replica_dict_reverse_lookup(char **name,
      * note again that itag is the index into this segment's
      * dictionary array
      */
-    ptr = (char**)((seg->dict)->addr);
+    ptr = (orte_gpr_replica_dict_entry_t**)((seg->dict)->addr);
     if (NULL == ptr[itag]) { /* this entry is no longer valid! */
         return ORTE_ERR_NOT_FOUND;
     }
-    *name = strdup(ptr[itag]);
+    *name = strdup(ptr[itag]->string);
     
     return ORTE_SUCCESS;
 }
@@ -278,7 +269,7 @@ orte_gpr_replica_get_itag_list(orte_gpr_replica_itag_t **itaglist,
     namptr = names;
 
     for( i = 0; i < (*num_names); i++ ) {  /* traverse array of names - ignore any NULL's */
-        if (NULL != names[i]) {
+        if (NULL == names[i]) continue; 
         if (ORTE_SUCCESS != (rc = orte_gpr_replica_create_itag(&((*itaglist)[i]), seg, names[i]))) {
             ORTE_ERROR_LOG(rc);
             free(*itaglist);
@@ -286,7 +277,6 @@ orte_gpr_replica_get_itag_list(orte_gpr_replica_itag_t **itaglist,
             return rc;
         }
     }
-    }
     return ORTE_SUCCESS;
 }