modify preconnect to use a rotating ring algorithm, OOB connections are

brought up lazily so we want to be a bit less agressive. 

This commit was SVN r12906.

ompi/runtime/ompi_mpi_preconnect.c

@@ -29,35 +29,55 @@ int ompi_init_do_preconnect(void)
 {
     int comm_size = ompi_comm_size(MPI_COMM_WORLD);
     int my_rank =  ompi_comm_rank(MPI_COMM_WORLD);
-    int i, j, ret;
-    struct ompi_request_t **requests; 
-
-    requests = (ompi_request_t**)malloc(comm_size * sizeof(struct ompi_request_t *));
-    if (NULL == requests) {
-        return OMPI_ERR_OUT_OF_RESOURCE;
-    }
-
-    for (i = j = 0; i < comm_size; ++i) {
-        if (i == my_rank) {
-            continue;
-        } else if (my_rank < i) {
-            ret = MCA_PML_CALL(isend(MPI_BOTTOM, 0, MPI_BYTE,
-                                     i, 1,
-                                     MCA_PML_BASE_SEND_STANDARD,
-                                     MPI_COMM_WORLD,
-                                     &requests[j++]));
+    int i, ret;
+    int next,prev;
+    struct ompi_request_t * requests[2];
+    ret = OMPI_SUCCESS;
+    if(comm_size == 2) {
+        if(my_rank){ 
+            ret = MCA_PML_CALL(send(MPI_BOTTOM, 0, MPI_BYTE,
+                                    0, 1,
+                                    MCA_PML_BASE_SEND_COMPLETE,
+                                     MPI_COMM_WORLD));
+            if(OMPI_SUCCESS != ret) {
+                return ret;
+            }
         } else {
-            ret = MCA_PML_CALL(irecv(MPI_BOTTOM,0, MPI_BYTE, i, 
-                                     1, MPI_COMM_WORLD, 
-                                     &requests[j++]));
-        }
-        if (OMPI_SUCCESS != ret) {
-            return ret;
+            ret = MCA_PML_CALL(recv(MPI_BOTTOM,0, MPI_BYTE, 1, 
+                                    1, MPI_COMM_WORLD, 
+                                    MPI_STATUS_IGNORE));
+            if(OMPI_SUCCESS != ret) {
+                return ret;
+            }
+        }   
+    } else { 
+        for (i = 1; i <= comm_size/2; ++i) {
+            next = (my_rank + i) % comm_size;
+            prev = (my_rank - i + comm_size) % comm_size;
+            ret = MCA_PML_CALL(irecv(MPI_BOTTOM,0, MPI_BYTE,
+                                     prev, 1,
+                                     MPI_COMM_WORLD, 
+                                     &requests[0]));
+            if(OMPI_SUCCESS != ret) {
+                return ret;
+            }
+            ret = MCA_PML_CALL(isend(MPI_BOTTOM, 0, MPI_BYTE,
+                                     next, 1,
+                                     MCA_PML_BASE_SEND_STANDARD,
+                                     MPI_COMM_WORLD, 
+                                     &requests[1]));
+            if (OMPI_SUCCESS != ret) {
+                return ret;
+            }
+            ret = ompi_request_wait_all(2, requests, MPI_STATUSES_IGNORE);
+            if (OMPI_SUCCESS != ret) {
+                return ret;
+            }
+            
         }
+        
     }
-    ret = ompi_request_wait_all(j, requests, MPI_STATUSES_IGNORE);
-    free(requests);
-
+    
     return ret;
 }