Use DBL_MAX for values of type double.

[simgrid.git] / src / smpi / colls / alltoall-rdb.c

diff --git a/src/smpi/colls/alltoall-rdb.c b/src/smpi/colls/alltoall-rdb.c
index 5abbbc9..9c0b9cc 100644 (file)
--- a/src/smpi/colls/alltoall-rdb.c
+++ b/src/smpi/colls/alltoall-rdb.c
@@ -1,4 +1,4 @@
-#include "colls.h"
+#include "colls_private.h"
 
 /*****************************************************************************
 
@@ -24,8 +24,7 @@
 int smpi_coll_tuned_alltoall_rdb(void *send_buff, int send_count,
                                  MPI_Datatype send_type,
                                  void *recv_buff, int recv_count,
-                                 MPI_Datatype recv_type,
-                                 MPI_Comm comm)
+                                 MPI_Datatype recv_type, MPI_Comm comm)
 {
   /* MPI variables */
   MPI_Status status;
@@ -33,34 +32,29 @@ int smpi_coll_tuned_alltoall_rdb(void *send_buff, int send_count,
 
   int dst_tree_root, rank_tree_root, send_offset, recv_offset;
   int rank, num_procs, j, k, dst, curr_size, max_size;
-  int last_recv_count, tmp_mask, tree_root, num_procs_completed;
-  int tag = 1, mask = 1, success = 1, failure = 0, i = 0;
+  int last_recv_count = 0, tmp_mask, tree_root, num_procs_completed;
+  int tag = COLL_TAG_ALLTOALL, mask = 1, i = 0;
 
   char *tmp_buff;
   char *send_ptr = (char *) send_buff;
   char *recv_ptr = (char *) recv_buff;
 
-  MPI_Comm_size(comm, &num_procs);
-  MPI_Comm_rank(comm, &rank);
-  MPI_Type_extent(send_type, &send_increment);
-  MPI_Type_extent(recv_type, &recv_increment);
-  MPI_Type_extent(recv_type, &extent);
+  num_procs = smpi_comm_size(comm);
+  rank = smpi_comm_rank(comm);
+  send_increment = smpi_datatype_get_extent(send_type);
+  recv_increment = smpi_datatype_get_extent(recv_type);
+  extent = smpi_datatype_get_extent(recv_type);
 
   send_increment *= (send_count * num_procs);
   recv_increment *= (recv_count * num_procs);
 
   max_size = num_procs * recv_increment;
 
-  tmp_buff = (char *) malloc(max_size);
-  if (!tmp_buff) {
-    printf("alltoall-rdb:56: cannot allocate memory\n");
-    MPI_Finalize();
-    exit(failure);
-  }
+  tmp_buff = (char *) xbt_malloc(max_size);
 
   curr_size = send_count * num_procs;
 
-  MPI_Sendrecv(send_ptr, curr_size, send_type, rank, tag,
+  smpi_mpi_sendrecv(send_ptr, curr_size, send_type, rank, tag,
                tmp_buff + (rank * recv_increment),
                curr_size, recv_type, rank, tag, comm, &status);
 
@@ -74,11 +68,11 @@ int smpi_coll_tuned_alltoall_rdb(void *send_buff, int send_count,
     recv_offset = dst_tree_root * recv_increment;
 
     if (dst < num_procs) {
-      MPI_Sendrecv(tmp_buff + send_offset, curr_size, send_type, dst, tag,
+      smpi_mpi_sendrecv(tmp_buff + send_offset, curr_size, send_type, dst, tag,
                    tmp_buff + recv_offset, mask * recv_count * num_procs,
                    recv_type, dst, tag, comm, &status);
 
-      MPI_Get_count(&status, recv_type, &last_recv_count);
+      last_recv_count = smpi_mpi_get_count(&status, recv_type);
       curr_size += last_recv_count;
     }
 
@@ -116,7 +110,7 @@ int smpi_coll_tuned_alltoall_rdb(void *send_buff, int send_count,
         if ((dst > rank)
             && (rank < tree_root + num_procs_completed)
             && (dst >= tree_root + num_procs_completed)) {
-          MPI_Send(tmp_buff + dst_tree_root * send_increment,
+          smpi_mpi_send(tmp_buff + dst_tree_root * send_increment,
                    last_recv_count, send_type, dst, tag, comm);
 
         }
@@ -127,11 +121,11 @@ int smpi_coll_tuned_alltoall_rdb(void *send_buff, int send_count,
         else if ((dst < rank)
                  && (dst < tree_root + num_procs_completed)
                  && (rank >= tree_root + num_procs_completed)) {
-          MPI_Recv(tmp_buff + dst_tree_root * send_increment,
+          smpi_mpi_recv(tmp_buff + dst_tree_root * send_increment,
                    mask * num_procs * send_count, send_type, dst,
                    tag, comm, &status);
 
-          MPI_Get_count(&status, send_type, &last_recv_count);
+          last_recv_count = smpi_mpi_get_count(&status, send_type);
           curr_size += last_recv_count;
         }
 
@@ -145,10 +139,10 @@ int smpi_coll_tuned_alltoall_rdb(void *send_buff, int send_count,
   }
 
   for (i = 0; i < num_procs; i++)
-    MPI_Sendrecv(tmp_buff + (rank + i * num_procs) * send_count * extent,
+    smpi_mpi_sendrecv(tmp_buff + (rank + i * num_procs) * send_count * extent,
                  send_count, send_type, rank, tag,
                  recv_ptr + (i * recv_count * extent),
                  recv_count, recv_type, rank, tag, comm, &status);
   free(tmp_buff);
-  return success;
+  return MPI_SUCCESS;
 }