changed process list to hashtable

This commit was SVN r3318.

src/mca/ptl/tcp/src/ptl_tcp.h

@@ -45,7 +45,7 @@ struct mca_ptl_tcp_component_t {
     int   tcp_rcvbuf;                      /**< socket rcvbuf size */
     ompi_free_list_t tcp_send_frags;       /**< free list of tcp send fragments */
     ompi_free_list_t tcp_recv_frags;       /**< free list of tcp recv fragments */
-    ompi_list_t tcp_procs;                 /**< list of tcp proc structures */
+    ompi_hash_table_t tcp_procs;           /**< hash table of tcp proc structures */
     ompi_list_t tcp_pending_acks;          /**< list of pending acks - retry as sends complete */
     ompi_list_t tcp_events;                /**< list of pending events */
     struct mca_ptl_tcp_proc_t* tcp_local;  /**< the tcp proc instance corresponding to the local process */

src/mca/ptl/tcp/src/ptl_tcp_component.c

@@ -152,11 +152,12 @@ int mca_ptl_tcp_component_open(void)
 
     /* initialize objects */
     OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_lock, ompi_mutex_t);
-    OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_procs, ompi_list_t);
+    OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_procs, ompi_hash_table_t);
     OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_pending_acks, ompi_list_t);
     OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_events, ompi_list_t);
     OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_send_frags, ompi_free_list_t);
     OBJ_CONSTRUCT(&mca_ptl_tcp_component.tcp_recv_frags, ompi_free_list_t);
+    ompi_hash_table_init(&mca_ptl_tcp_component.tcp_procs, 256);
 
     /* register TCP module parameters */
     mca_ptl_tcp_component.tcp_if_include =

src/mca/ptl/tcp/src/ptl_tcp_peer.c

@@ -240,8 +240,8 @@ static int mca_ptl_tcp_peer_send_connect_ack(mca_ptl_base_peer_t* ptl_peer)
 {
     /* send process identifier to remote peer */
     mca_ptl_tcp_proc_t* ptl_proc = mca_ptl_tcp_proc_local();
-    if(mca_ptl_tcp_peer_send_blocking(ptl_peer, &ptl_proc->proc_guid, sizeof(ptl_proc->proc_guid)) != 
+    if(mca_ptl_tcp_peer_send_blocking(ptl_peer, &ptl_proc->proc_name, sizeof(ptl_proc->proc_name)) != 
-          sizeof(ptl_proc->proc_guid)) {
+          sizeof(ptl_proc->proc_name)) {
         return OMPI_ERR_UNREACH;
     }
     return OMPI_SUCCESS;
@@ -396,7 +396,7 @@ static int mca_ptl_tcp_peer_recv_connect_ack(mca_ptl_base_peer_t* ptl_peer)
     }
 
     /* compare this to the expected values */
-    if(memcmp(&ptl_proc->proc_guid, &guid, sizeof(ompi_process_name_t)) != 0) {
+    if(memcmp(&ptl_proc->proc_name, &guid, sizeof(ompi_process_name_t)) != 0) {
         ompi_output(0, "mca_ptl_tcp_peer_connect: received unexpected process identifier");
         mca_ptl_tcp_peer_close(ptl_peer);
         return OMPI_ERR_UNREACH;

src/mca/ptl/tcp/src/ptl_tcp_proc.c

@@ -7,7 +7,7 @@
 #include <string.h>
 
 #include "include/sys/atomic.h"
-#include "class/ompi_hash_table.h"
+#include "class/ompi_proc_table.h"
 #include "mca/base/mca_base_module_exchange.h"
 #include "ptl_tcp.h"
 #include "ptl_tcp_addr.h"
@@ -17,14 +17,13 @@
 
 static void mca_ptl_tcp_proc_construct(mca_ptl_tcp_proc_t* proc);
 static void mca_ptl_tcp_proc_destruct(mca_ptl_tcp_proc_t* proc);
-static mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_lookup_ompi(ompi_proc_t* ompi_proc);
 
-ompi_class_t  mca_ptl_tcp_proc_t_class = {
+OBJ_CLASS_INSTANCE(
-    "mca_ptl_tcp_proc_t",
+    mca_ptl_tcp_proc_t,
-    OBJ_CLASS(ompi_list_item_t),
+    ompi_list_item_t,
-    (ompi_construct_t)mca_ptl_tcp_proc_construct,
+    mca_ptl_tcp_proc_construct,
-    (ompi_destruct_t)mca_ptl_tcp_proc_destruct
+    mca_ptl_tcp_proc_destruct
-};
+);
  
 
 /**
@@ -39,11 +38,6 @@ void mca_ptl_tcp_proc_construct(mca_ptl_tcp_proc_t* proc)
     proc->proc_peers = 0;
     proc->proc_peer_count = 0;
     OBJ_CONSTRUCT(&proc->proc_lock, ompi_mutex_t);
-
-    /* add to list of all proc instance */
-    OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
-    ompi_list_append(&mca_ptl_tcp_component.tcp_procs, &proc->super);
-    OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
 }
 
 
@@ -55,7 +49,7 @@ void mca_ptl_tcp_proc_destruct(mca_ptl_tcp_proc_t* proc)
 {
     /* remove from list of all proc instances */
     OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
-    ompi_list_remove_item(&mca_ptl_tcp_component.tcp_procs, &proc->super);
+    ompi_hash_table_remove_proc(&mca_ptl_tcp_component.tcp_procs, &proc->proc_name);
     OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
 
     /* release resources */
@@ -75,15 +69,28 @@ mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_create(ompi_proc_t* ompi_proc)
 {
     int rc;
     size_t size;
-    mca_ptl_tcp_proc_t* ptl_proc = mca_ptl_tcp_proc_lookup_ompi(ompi_proc);
+    mca_ptl_tcp_proc_t* ptl_proc;
-    if(ptl_proc != NULL)
+
+    OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
+    ptl_proc = (mca_ptl_tcp_proc_t*)ompi_hash_table_get_proc(
+         &mca_ptl_tcp_component.tcp_procs, &ompi_proc->proc_name);
+    if(NULL != ptl_proc) {
+        OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
         return ptl_proc;
+     }
 
     ptl_proc = OBJ_NEW(mca_ptl_tcp_proc_t);
+    if(NULL == ptl_proc)
+        return NULL;
     ptl_proc->proc_ompi = ompi_proc;
+    ptl_proc->proc_name = ompi_proc->proc_name;
 
-    /* build a unique identifier (of arbitrary size) to represent the proc */
+    /* add to hash table of all proc instance */
-    ptl_proc->proc_guid = ompi_proc->proc_name;
+    ompi_hash_table_set_proc(
+        &mca_ptl_tcp_component.tcp_procs, 
+        &ptl_proc->proc_name, 
+         ptl_proc);
+    OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
 
     /* lookup tcp parameters exported by this proc */
     rc = mca_base_modex_recv(
@@ -114,26 +121,6 @@ mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_create(ompi_proc_t* ompi_proc)
     return ptl_proc;
 }
 
-/*
- * Look for an existing TCP process instances based on the associated
- * ompi_proc_t instance.
- */
-static mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_lookup_ompi(ompi_proc_t* ompi_proc)
-{
-    mca_ptl_tcp_proc_t* tcp_proc;
-    OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
-    for(tcp_proc  = (mca_ptl_tcp_proc_t*)ompi_list_get_first(&mca_ptl_tcp_component.tcp_procs);
-        tcp_proc != (mca_ptl_tcp_proc_t*)ompi_list_get_end(&mca_ptl_tcp_component.tcp_procs);
-        tcp_proc  = (mca_ptl_tcp_proc_t*)ompi_list_get_next(tcp_proc)) {
-        if(tcp_proc->proc_ompi == ompi_proc) {
-            OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
-            return tcp_proc;
-        }
-    }
-    OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
-    return NULL;
-}
-
 
 /*
  * Look for an existing TCP process instance based on the globally unique 
@@ -141,19 +128,12 @@ static mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_lookup_ompi(ompi_proc_t* ompi_proc)
  */
 mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_lookup(const ompi_process_name_t *name)
 {
-    mca_ptl_tcp_proc_t* tcp_proc;
+    mca_ptl_tcp_proc_t* proc;
-    ompi_process_name_t guid = *name;
     OMPI_THREAD_LOCK(&mca_ptl_tcp_component.tcp_lock);
-    for(tcp_proc  = (mca_ptl_tcp_proc_t*)ompi_list_get_first(&mca_ptl_tcp_component.tcp_procs);
+    proc = (mca_ptl_tcp_proc_t*)ompi_hash_table_get_proc(
-        tcp_proc != (mca_ptl_tcp_proc_t*)ompi_list_get_end(&mca_ptl_tcp_component.tcp_procs);
+         &mca_ptl_tcp_component.tcp_procs, name);
-        tcp_proc  = (mca_ptl_tcp_proc_t*)ompi_list_get_next(tcp_proc)) {
-        if(memcmp(&tcp_proc->proc_guid, &guid, sizeof(guid)) == 0) {
     OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
-            return tcp_proc;
+    return proc;
-        }
-    }
-    OMPI_THREAD_UNLOCK(&mca_ptl_tcp_component.tcp_lock);
-    return NULL;
 }
 
 

src/mca/ptl/tcp/src/ptl_tcp_proc.h

@@ -25,7 +25,6 @@
 extern "C" {
 #endif
 
-extern ompi_class_t mca_ptl_tcp_proc_t_class;
 
 
 /**
@@ -36,7 +35,7 @@ extern ompi_class_t mca_ptl_tcp_proc_t_class;
 struct mca_ptl_tcp_proc_t {
     ompi_list_item_t super;                  /**< allow proc to be placed on a list */
     ompi_proc_t *proc_ompi;                  /**< pointer to corresponding ompi_proc_t */
-    ompi_process_name_t proc_guid;           /**< globally unique identifier for the process */
+    ompi_process_name_t proc_name;           /**< globally unique identifier for the process */
     struct mca_ptl_tcp_addr_t *proc_addrs;   /**< array of addresses published by peer */
     size_t proc_addr_count;                  /**< number of addresses published by peer */
     struct mca_ptl_base_peer_t **proc_peers; /**< array of peers that have been created to access this proc */
@@ -46,6 +45,9 @@ struct mca_ptl_tcp_proc_t {
 typedef struct mca_ptl_tcp_proc_t mca_ptl_tcp_proc_t;
 
 
+OBJ_CLASS_DECLARATION(mca_ptl_tcp_proc_t);
+
+
 mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_create(ompi_proc_t* ompi_proc);
 mca_ptl_tcp_proc_t* mca_ptl_tcp_proc_lookup(const ompi_process_name_t*);