X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/cac63707a2f233d0a979a67403336292eb2a3038..25d4b13f5b74c01ccf1da9cc2a0ffe934ea7da1a:/src/smpi/smpi_base.c

diff --git a/src/smpi/smpi_base.c b/src/smpi/smpi_base.c
index d8fd995a56..0fc8226a36 100644
--- a/src/smpi/smpi_base.c
+++ b/src/smpi/smpi_base.c
@@ -1,5 +1,12 @@
+/* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+  * under the terms of the license (GNU LGPL) which comes with this package. */
+
 #include "private.h"
 #include "xbt/time.h"
+#include "mc/mc.h"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_base, smpi,
                                 "Logging specific to SMPI (base)");
@@ -7,195 +14,720 @@ XBT_LOG_EXTERNAL_CATEGORY(smpi_base);
 XBT_LOG_EXTERNAL_CATEGORY(smpi_bench);
 XBT_LOG_EXTERNAL_CATEGORY(smpi_kernel);
 XBT_LOG_EXTERNAL_CATEGORY(smpi_mpi);
+XBT_LOG_EXTERNAL_CATEGORY(smpi_mpi_dt);
+XBT_LOG_EXTERNAL_CATEGORY(smpi_coll);
 XBT_LOG_EXTERNAL_CATEGORY(smpi_receiver);
 XBT_LOG_EXTERNAL_CATEGORY(smpi_sender);
 XBT_LOG_EXTERNAL_CATEGORY(smpi_util);
 
-smpi_mpi_global_t smpi_mpi_global = NULL;
+static int match_recv(void* a, void* b) {
+   MPI_Request ref = (MPI_Request)a;
+   MPI_Request req = (MPI_Request)b;
+
+   xbt_assert(ref, "Cannot match recv against null reference");
+   xbt_assert(req, "Cannot match recv against null request");
+   return (ref->src == MPI_ANY_SOURCE || req->src == ref->src)
+          && (ref->tag == MPI_ANY_TAG || req->tag == ref->tag);
+}
+
+static int match_send(void* a, void* b) {
+   MPI_Request ref = (MPI_Request)a;
+   MPI_Request req = (MPI_Request)b;
 
-void smpi_mpi_land_func(void *a, void *b, int *length,
-                        MPI_Datatype * datatype);
+   xbt_assert(ref, "Cannot match send against null reference");
+   xbt_assert(req, "Cannot match send against null request");
+   return (req->src == MPI_ANY_SOURCE || req->src == ref->src)
+          && (req->tag == MPI_ANY_TAG || req->tag == ref->tag);
+}
 
-void smpi_mpi_land_func(void *a, void *b, int *length,
-                        MPI_Datatype * datatype)
+static MPI_Request build_request(void *buf, int count,
+                                 MPI_Datatype datatype, int src, int dst,
+                                 int tag, MPI_Comm comm, unsigned flags)
 {
-  int i;
-  if (*datatype == smpi_mpi_global->mpi_int) {
-    int *x = a, *y = b;
-    for (i = 0; i < *length; i++) {
-      y[i] = x[i] && y[i];
-    }
-  }
+  MPI_Request request;
+
+  request = xbt_new(s_smpi_mpi_request_t, 1);
+  request->buf = buf;
+  // FIXME: this will have to be changed to support non-contiguous datatypes
+  request->size = smpi_datatype_size(datatype) * count;
+  request->src = src;
+  request->dst = dst;
+  request->tag = tag;
+  request->comm = comm;
+  request->action = NULL;
+  request->flags = flags;
+#ifdef HAVE_TRACING
+  request->send = 0;
+  request->recv = 0;
+#endif
+  return request;
 }
 
-void smpi_mpi_sum_func(void *a, void *b, int *length,
-                       MPI_Datatype * datatype);
+/* MPI Low level calls */
+MPI_Request smpi_mpi_send_init(void *buf, int count, MPI_Datatype datatype,
+                               int dst, int tag, MPI_Comm comm)
+{
+  MPI_Request request =
+      build_request(buf, count, datatype, smpi_comm_rank(comm), dst, tag,
+                    comm, PERSISTENT | SEND);
+
+  return request;
+}
 
-void smpi_mpi_sum_func(void *a, void *b, int *length, MPI_Datatype * datatype)
+MPI_Request smpi_mpi_recv_init(void *buf, int count, MPI_Datatype datatype,
+                               int src, int tag, MPI_Comm comm)
 {
-  int i;
-  if (*datatype == smpi_mpi_global->mpi_int) {
-    int *x = a, *y = b;
-    for (i = 0; i < *length; i++) {
-      y[i] = x[i] + y[i];
+  MPI_Request request =
+      build_request(buf, count, datatype, src, smpi_comm_rank(comm), tag,
+                    comm, PERSISTENT | RECV);
+
+  return request;
+}
+
+void smpi_mpi_start(MPI_Request request)
+{
+  smx_rdv_t mailbox;
+  int detached = 0;
+
+  xbt_assert(!request->action,
+              "Cannot (re)start a non-finished communication");
+  if(request->flags & RECV) {
+    print_request("New recv", request);
+    mailbox = smpi_process_mailbox();
+    // FIXME: SIMIX does not yet support non-contiguous datatypes
+    request->action = SIMIX_req_comm_irecv(mailbox, request->buf, &request->size, &match_recv, request);
+  } else {
+    print_request("New send", request);
+    mailbox = smpi_process_remote_mailbox(
+			  smpi_group_index(smpi_comm_group(request->comm), request->dst));
+    // FIXME: SIMIX does not yet support non-contiguous datatypes
+
+    if (request->size < 64*1024 ) { // eager mode => detached send (FIXME: this limit should be configurable)
+    	void *oldbuf = request->buf;
+    	detached = 1;
+    	request->buf = malloc(request->size);
+    	memcpy(request->buf,oldbuf,request->size);
+    	XBT_DEBUG("Send request %p is detached; buf %p copied into %p",request,oldbuf,request->buf);
+    } else {
+    	XBT_DEBUG("Send request %p is not detached (buf: %p)",request,request->buf);
     }
+    request->action = 
+		SIMIX_req_comm_isend(mailbox, request->size, -1.0,
+				    request->buf, request->size, &match_send, request,  
+				    // detach if msg size < eager/rdv switch limit
+				    detached);
+
+#ifdef HAVE_TRACING
+    SIMIX_req_set_category (request->action, TRACE_internal_smpi_get_category());
+#endif
   }
 }
 
-int smpi_mpi_comm_rank(smpi_mpi_communicator_t comm)
+void smpi_mpi_startall(int count, MPI_Request * requests)
 {
-  return comm->index_to_rank_map[smpi_host_index()];
+	  int i;
+
+  for(i = 0; i < count; i++) {
+    smpi_mpi_start(requests[i]);
+  }
 }
 
-void smpi_process_init()
+void smpi_mpi_request_free(MPI_Request * request)
 {
-  smx_host_t host;
-  int i;
-  smpi_host_data_t hdata;
+  xbt_free(*request);
+  *request = MPI_REQUEST_NULL;
+}
 
-  smpi_global->running_hosts_count++;
+MPI_Request smpi_isend_init(void *buf, int count, MPI_Datatype datatype,
+                            int dst, int tag, MPI_Comm comm)
+{
+  MPI_Request request =
+      build_request(buf, count, datatype, smpi_comm_rank(comm), dst, tag,
+                    comm, NON_PERSISTENT | SEND);
 
-  // initialize some local variables
-  host = SIMIX_host_self();
+  return request;
+}
 
-  hdata = xbt_new(s_smpi_host_data_t, 1);
-  SIMIX_host_set_data(host, hdata);
-  SIMIX_process_set_data(SIMIX_process_self(),hdata);
+MPI_Request smpi_mpi_isend(void *buf, int count, MPI_Datatype datatype,
+                           int dst, int tag, MPI_Comm comm)
+{
+  MPI_Request request =
+      smpi_isend_init(buf, count, datatype, dst, tag, comm);
 
-  for (i = 0; i < smpi_global->host_count && host != smpi_global->hosts[i]; i++);
+  smpi_mpi_start(request);
+  return request;
+}
 
-  hdata->index = i;
-  hdata->mutex = SIMIX_mutex_init();
-  hdata->cond = SIMIX_cond_init();
+MPI_Request smpi_irecv_init(void *buf, int count, MPI_Datatype datatype,
+                            int src, int tag, MPI_Comm comm)
+{
+  MPI_Request request =
+      build_request(buf, count, datatype, src, smpi_comm_rank(comm), tag,
+                    comm, NON_PERSISTENT | RECV);
 
-  hdata->pending_recv_request_queue = xbt_fifo_new();
+  return request;
+}
 
-  hdata->main = SIMIX_process_self();
-  hdata->sender = SIMIX_process_create("smpi_sender",
-          smpi_sender, hdata,
-          SIMIX_host_get_name(SIMIX_host_self()), 0, NULL,
-          /*props */ NULL);
-  hdata->receiver = SIMIX_process_create("smpi_receiver",
-          smpi_receiver, hdata,
-          SIMIX_host_get_name(SIMIX_host_self()), 0, NULL,
-          /*props */ NULL);
+MPI_Request smpi_mpi_irecv(void *buf, int count, MPI_Datatype datatype,
+                           int src, int tag, MPI_Comm comm)
+{
+  MPI_Request request =
+      smpi_irecv_init(buf, count, datatype, src, tag, comm);
 
-  smpi_global->main_processes[hdata->index] = SIMIX_process_self();
-  return;
+  smpi_mpi_start(request);
+  return request;
 }
 
-void smpi_process_finalize()
+void smpi_mpi_recv(void *buf, int count, MPI_Datatype datatype, int src,
+                   int tag, MPI_Comm comm, MPI_Status * status)
 {
-  int i;
-  smpi_host_data_t hdata =  SIMIX_host_get_data(SIMIX_host_self());
+  MPI_Request request;
 
-  i = --smpi_global->running_hosts_count;
+  request = smpi_mpi_irecv(buf, count, datatype, src, tag, comm);
+  smpi_mpi_wait(&request, status);
+}
 
-  SIMIX_mutex_destroy(smpi_host_mutex());
-  SIMIX_cond_destroy(smpi_host_cond());
-  xbt_fifo_free(hdata->pending_recv_request_queue);
+void smpi_mpi_send(void *buf, int count, MPI_Datatype datatype, int dst,
+                   int tag, MPI_Comm comm)
+{
+  MPI_Request request;
 
-  if (0 >= i) {
+  request = smpi_mpi_isend(buf, count, datatype, dst, tag, comm);
+  smpi_mpi_wait(&request, MPI_STATUS_IGNORE);
+}
 
-    // wake up senders/receivers
-	  /* MQ: (FIXME) Don't do so: it breaks since some hosts are already gone
-    for (i = 0; i < smpi_global->host_count; i++) {
-      smpi_host_data_t remote_hdata =  SIMIX_process_get_data(smpi_global->main_processes[i]);
+void smpi_mpi_sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+                       int dst, int sendtag, void *recvbuf, int recvcount,
+                       MPI_Datatype recvtype, int src, int recvtag,
+                       MPI_Comm comm, MPI_Status * status)
+{
+  MPI_Request requests[2];
+  MPI_Status stats[2];
+
+  requests[0] =
+      smpi_isend_init(sendbuf, sendcount, sendtype, dst, sendtag, comm);
+  requests[1] =
+      smpi_irecv_init(recvbuf, recvcount, recvtype, src, recvtag, comm);
+  smpi_mpi_startall(2, requests);
+  smpi_mpi_waitall(2, requests, stats);
+  if(status != MPI_STATUS_IGNORE) {
+    // Copy receive status
+    memcpy(status, &stats[1], sizeof(MPI_Status));
+  }
+}
 
-      if (SIMIX_process_is_suspended(remote_hdata->sender))
-        SIMIX_process_resume(remote_hdata->sender);
+int smpi_mpi_get_count(MPI_Status * status, MPI_Datatype datatype)
+{
+  return status->count / smpi_datatype_size(datatype);
+}
 
-      if (SIMIX_process_is_suspended(remote_hdata->receiver))
-        SIMIX_process_resume(remote_hdata->receiver);
-    }*/
+static void finish_wait(MPI_Request * request, MPI_Status * status)
+{
+  MPI_Request req = *request;
+
+  if(status != MPI_STATUS_IGNORE) {
+    status->MPI_SOURCE = req->src;
+    status->MPI_TAG = req->tag;
+    status->MPI_ERROR = MPI_SUCCESS;
+    // FIXME: really this should just contain the count of receive-type blocks,
+    // right?
+    status->count = req->size;
+  }
+  print_request("Finishing", req);
+  if(req->flags & NON_PERSISTENT) {
+    smpi_mpi_request_free(request);
+  } else {
+    req->action = NULL;
+  }
+}
 
-    SIMIX_mutex_destroy(smpi_mpi_global->mpi_comm_world->barrier_mutex);
-    SIMIX_cond_destroy(smpi_mpi_global->mpi_comm_world->barrier_cond);
-    xbt_free(smpi_mpi_global->mpi_comm_world);
+int smpi_mpi_test(MPI_Request * request, MPI_Status * status) {
+int flag;
+
+   if ((*request)->action == NULL)
+	flag = 1;
+   else 
+    flag = SIMIX_req_comm_test((*request)->action);
+   if(flag) {
+		    smpi_mpi_wait(request, status);
+	  }
+	  return flag;
+}
 
-    xbt_free(smpi_mpi_global->mpi_byte);
-    xbt_free(smpi_mpi_global->mpi_int);
-    xbt_free(smpi_mpi_global->mpi_double);
+int smpi_mpi_testany(int count, MPI_Request requests[], int *index,
+                     MPI_Status * status)
+{
+  xbt_dynar_t comms;
+  int i, flag, size;
+  int* map;
+
+  *index = MPI_UNDEFINED;
+  flag = 0;
+  if(count > 0) {
+    comms = xbt_dynar_new(sizeof(smx_action_t), NULL);
+    map = xbt_new(int, count);
+    size = 0;
+    for(i = 0; i < count; i++) {
+      if(requests[i]->action) {
+         xbt_dynar_push(comms, &requests[i]->action);
+         map[size] = i;
+         size++;
+      }
+    }
+    if(size > 0) {
+      i = SIMIX_req_comm_testany(comms);
+      // FIXME: MPI_UNDEFINED or does SIMIX have a return code?
+      if(i != MPI_UNDEFINED) {
+        *index = map[i];
+        smpi_mpi_wait(&requests[*index], status);
+        flag = 1;
+      }
+    }
+    xbt_free(map);
+    xbt_dynar_free(&comms);
+  }
+  return flag;
+}
 
-    xbt_free(smpi_mpi_global->mpi_land);
-    xbt_free(smpi_mpi_global->mpi_sum);
+void smpi_mpi_wait(MPI_Request * request, MPI_Status * status)
+{
+  print_request("Waiting", *request);
+  if ((*request)->action != NULL ) 
+ 	 SIMIX_req_comm_wait((*request)->action, -1.0);
+  finish_wait(request, status);
+}
 
-    xbt_free(smpi_mpi_global);
+int smpi_mpi_waitany(int count, MPI_Request requests[],
+                     MPI_Status * status)
+{
+  xbt_dynar_t comms;
+  int i, size, index;
+  int *map;
+
+  index = MPI_UNDEFINED;
+  if(count > 0) {
+    // Wait for a request to complete
+    comms = xbt_dynar_new(sizeof(smx_action_t), NULL);
+    map = xbt_new(int, count);
+    size = 0;
+    XBT_DEBUG("Wait for one of");
+    for(i = 0; i < count; i++) {
+      if((requests[i] != MPI_REQUEST_NULL) && (requests[i]->action != NULL)) {
+        print_request("   ", requests[i]);
+        xbt_dynar_push(comms, &requests[i]->action);
+        map[size] = i;
+        size++;
+      }
+    }
+    if(size > 0) {
+      i = SIMIX_req_comm_waitany(comms);
+      // FIXME: MPI_UNDEFINED or does SIMIX have a return code?
+      if (i != MPI_UNDEFINED) {
+        index = map[i];
+        finish_wait(&requests[index], status);
+      }
+    }
+    xbt_free(map);
+    xbt_dynar_free(&comms);
   }
+  return index;
 }
 
-int smpi_mpi_barrier(smpi_mpi_communicator_t comm)
+void smpi_mpi_waitall(int count, MPI_Request requests[],
+                      MPI_Status status[])
 {
-
-  SIMIX_mutex_lock(comm->barrier_mutex);
-  ++comm->barrier_count;
-  if (comm->barrier_count > comm->size) {       // only happens on second barrier...
-    comm->barrier_count = 0;
-  } else if (comm->barrier_count == comm->size) {
-    SIMIX_cond_broadcast(comm->barrier_cond);
+  int index, c;
+  MPI_Status stat;
+  MPI_Status *pstat = status == MPI_STATUS_IGNORE ? MPI_STATUS_IGNORE : &stat;
+
+  for(c = 0; c < count; c++) {
+    if(MC_IS_ENABLED) {
+      smpi_mpi_wait(&requests[c], pstat);
+      index = c;
+    } else {
+      index = smpi_mpi_waitany(count, requests, pstat);
+      if(index == MPI_UNDEFINED) {
+        break;
+      }
+    }
+    if(status != MPI_STATUS_IGNORE) {
+      memcpy(&status[index], pstat, sizeof(*pstat));
+    }
   }
-  while (comm->barrier_count < comm->size) {
-    SIMIX_cond_wait(comm->barrier_cond, comm->barrier_mutex);
+}
+
+int smpi_mpi_waitsome(int incount, MPI_Request requests[], int *indices,
+                      MPI_Status status[])
+{
+  int i, count, index;
+
+  count = 0;
+  for(i = 0; i < incount; i++) {
+     if(smpi_mpi_testany(incount, requests, &index, status)) {
+       indices[count] = index;
+       count++;
+     }
   }
-  SIMIX_mutex_unlock(comm->barrier_mutex);
+  return count;
+}
 
-  return MPI_SUCCESS;
+void smpi_mpi_bcast(void *buf, int count, MPI_Datatype datatype, int root,
+                    MPI_Comm comm)
+{
+  // arity=2: a binary tree, arity=4 seem to be a good setting (see P2P-MPI))
+  nary_tree_bcast(buf, count, datatype, root, comm, 4);
 }
 
-int smpi_mpi_isend(smpi_mpi_request_t request)
+void smpi_mpi_barrier(MPI_Comm comm)
 {
-	smpi_host_data_t hdata =  SIMIX_host_get_data(SIMIX_host_self());
-  int retval = MPI_SUCCESS;
+  // arity=2: a binary tree, arity=4 seem to be a good setting (see P2P-MPI))
+  nary_tree_barrier(comm, 4);
+}
 
-  if (NULL == request) {
-    retval = MPI_ERR_INTERN;
+void smpi_mpi_gather(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+                     void *recvbuf, int recvcount, MPI_Datatype recvtype,
+                     int root, MPI_Comm comm)
+{
+  int system_tag = 666;
+  int rank, size, src, index;
+  MPI_Aint lb = 0, recvext = 0;
+  MPI_Request *requests;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+  if(rank != root) {
+    // Send buffer to root
+    smpi_mpi_send(sendbuf, sendcount, sendtype, root, system_tag, comm);
   } else {
-    xbt_fifo_push(smpi_global->pending_send_request_queues[hdata->index], request);
+    // FIXME: check for errors
+    smpi_datatype_extent(recvtype, &lb, &recvext);
+    // Local copy from root
+    smpi_datatype_copy(sendbuf, sendcount, sendtype, 
+        (char *)recvbuf + root * recvcount * recvext, recvcount, recvtype);
+    // Receive buffers from senders
+    requests = xbt_new(MPI_Request, size - 1);
+    index = 0;
+    for(src = 0; src < size; src++) {
+      if(src != root) {
+        requests[index] = smpi_irecv_init((char *)recvbuf + src * recvcount * recvext, 
+                                          recvcount, recvtype, 
+                                          src, system_tag, comm);
+        index++;
+      }
+    }
+    // Wait for completion of irecv's.
+    smpi_mpi_startall(size - 1, requests);
+    smpi_mpi_waitall(size - 1, requests, MPI_STATUS_IGNORE);
+    xbt_free(requests);
+  }
+}
 
-    if (SIMIX_process_is_suspended(hdata->sender)) {
-      SIMIX_process_resume(hdata->sender);
+void smpi_mpi_gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+                      void *recvbuf, int *recvcounts, int *displs,
+                      MPI_Datatype recvtype, int root, MPI_Comm comm)
+{
+  int system_tag = 666;
+  int rank, size, src, index;
+  MPI_Aint lb = 0, recvext = 0;
+  MPI_Request *requests;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+  if(rank != root) {
+    // Send buffer to root
+    smpi_mpi_send(sendbuf, sendcount, sendtype, root, system_tag, comm);
+  } else {
+    // FIXME: check for errors
+    smpi_datatype_extent(recvtype, &lb, &recvext);
+    // Local copy from root
+    smpi_datatype_copy(sendbuf, sendcount, sendtype, 
+                       (char *)recvbuf + displs[root] * recvext, 
+                       recvcounts[root], recvtype);
+    // Receive buffers from senders
+    requests = xbt_new(MPI_Request, size - 1);
+    index = 0;
+    for(src = 0; src < size; src++) {
+      if(src != root) {
+        requests[index] =
+            smpi_irecv_init((char *)recvbuf + displs[src] * recvext, 
+                            recvcounts[src], recvtype, src, system_tag, comm);
+        index++;
+      }
     }
+    // Wait for completion of irecv's.
+    smpi_mpi_startall(size - 1, requests);
+    smpi_mpi_waitall(size - 1, requests, MPI_STATUS_IGNORE);
+    xbt_free(requests);
   }
+}
 
-  return retval;
+void smpi_mpi_allgather(void *sendbuf, int sendcount,
+                        MPI_Datatype sendtype, void *recvbuf,
+                        int recvcount, MPI_Datatype recvtype,
+                        MPI_Comm comm)
+{
+  int system_tag = 666;
+  int rank, size, other, index;
+  MPI_Aint lb = 0, recvext = 0;
+  MPI_Request *requests;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+  // FIXME: check for errors
+  smpi_datatype_extent(recvtype, &lb, &recvext);
+  // Local copy from self
+  smpi_datatype_copy(sendbuf, sendcount, sendtype, 
+                     (char *)recvbuf + rank * recvcount * recvext, recvcount, 
+                     recvtype);
+  // Send/Recv buffers to/from others;
+  requests = xbt_new(MPI_Request, 2 * (size - 1));
+  index = 0;
+  for(other = 0; other < size; other++) {
+    if(other != rank) {
+      requests[index] =
+          smpi_isend_init(sendbuf, sendcount, sendtype, other, system_tag,
+                          comm);
+      index++;
+      requests[index] = smpi_irecv_init((char *)recvbuf + other * recvcount * recvext, 
+                                        recvcount, recvtype, other, 
+                                        system_tag, comm);
+      index++;
+    }
+  }
+  // Wait for completion of all comms.
+  smpi_mpi_startall(2 * (size - 1), requests);
+  smpi_mpi_waitall(2 * (size - 1), requests, MPI_STATUS_IGNORE);
+  xbt_free(requests);
 }
 
-int smpi_mpi_irecv(smpi_mpi_request_t request)
+void smpi_mpi_allgatherv(void *sendbuf, int sendcount,
+                         MPI_Datatype sendtype, void *recvbuf,
+                         int *recvcounts, int *displs,
+                         MPI_Datatype recvtype, MPI_Comm comm)
 {
-  int retval = MPI_SUCCESS;
-  smpi_host_data_t hdata =  SIMIX_host_get_data(SIMIX_host_self());
+  int system_tag = 666;
+  int rank, size, other, index;
+  MPI_Aint lb = 0, recvext = 0;
+  MPI_Request *requests;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+  // FIXME: check for errors
+  smpi_datatype_extent(recvtype, &lb, &recvext);
+  // Local copy from self
+  smpi_datatype_copy(sendbuf, sendcount, sendtype, 
+                     (char *)recvbuf + displs[rank] * recvext, 
+                     recvcounts[rank], recvtype);
+  // Send buffers to others;
+  requests = xbt_new(MPI_Request, 2 * (size - 1));
+  index = 0;
+  for(other = 0; other < size; other++) {
+    if(other != rank) {
+      requests[index] =
+          smpi_isend_init(sendbuf, sendcount, sendtype, other, system_tag,
+                          comm);
+      index++;
+      requests[index] =
+          smpi_irecv_init((char *)recvbuf + displs[other] * recvext, recvcounts[other],
+                          recvtype, other, system_tag, comm);
+      index++;
+    }
+  }
+  // Wait for completion of all comms.
+  smpi_mpi_startall(2 * (size - 1), requests);
+  smpi_mpi_waitall(2 * (size - 1), requests, MPI_STATUS_IGNORE);
+  xbt_free(requests);
+}
 
-  if (NULL == request) {
-    retval = MPI_ERR_INTERN;
+void smpi_mpi_scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype,
+                      void *recvbuf, int recvcount, MPI_Datatype recvtype,
+                      int root, MPI_Comm comm)
+{
+  int system_tag = 666;
+  int rank, size, dst, index;
+  MPI_Aint lb = 0, sendext = 0;
+  MPI_Request *requests;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+  if(rank != root) {
+    // Recv buffer from root
+    smpi_mpi_recv(recvbuf, recvcount, recvtype, root, system_tag, comm,
+                  MPI_STATUS_IGNORE);
   } else {
-    xbt_fifo_push(hdata->pending_recv_request_queue, request);
-
-    if (SIMIX_process_is_suspended(hdata->receiver)) {
-      SIMIX_process_resume(hdata->receiver);
+    // FIXME: check for errors
+    smpi_datatype_extent(sendtype, &lb, &sendext);
+    // Local copy from root
+    smpi_datatype_copy((char *)sendbuf + root * sendcount * sendext,
+      sendcount, sendtype, recvbuf, recvcount, recvtype);
+    // Send buffers to receivers
+    requests = xbt_new(MPI_Request, size - 1);
+    index = 0;
+    for(dst = 0; dst < size; dst++) {
+      if(dst != root) {
+        requests[index] = smpi_isend_init((char *)sendbuf + dst * sendcount * sendext, 
+                                          sendcount, sendtype, dst,
+                                          system_tag, comm);
+        index++;
+      }
     }
+    // Wait for completion of isend's.
+    smpi_mpi_startall(size - 1, requests);
+    smpi_mpi_waitall(size - 1, requests, MPI_STATUS_IGNORE);
+    xbt_free(requests);
   }
-
-  return retval;
 }
 
-int smpi_mpi_wait(smpi_mpi_request_t request, smpi_mpi_status_t * status)
+void smpi_mpi_scatterv(void *sendbuf, int *sendcounts, int *displs,
+                       MPI_Datatype sendtype, void *recvbuf, int recvcount,
+                       MPI_Datatype recvtype, int root, MPI_Comm comm)
 {
-  int retval = MPI_SUCCESS;
+  int system_tag = 666;
+  int rank, size, dst, index;
+  MPI_Aint lb = 0, sendext = 0;
+  MPI_Request *requests;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+  if(rank != root) {
+    // Recv buffer from root
+    smpi_mpi_recv(recvbuf, recvcount, recvtype, root, system_tag, comm,
+                  MPI_STATUS_IGNORE);
+  } else {
+    // FIXME: check for errors
+    smpi_datatype_extent(sendtype, &lb, &sendext);
+    // Local copy from root
+    smpi_datatype_copy((char *)sendbuf + displs[root] * sendext, sendcounts[root], 
+                       sendtype, recvbuf, recvcount, recvtype);
+    // Send buffers to receivers
+    requests = xbt_new(MPI_Request, size - 1);
+    index = 0;
+    for(dst = 0; dst < size; dst++) {
+      if(dst != root) {
+        requests[index] =
+            smpi_isend_init((char *)sendbuf + displs[dst] * sendext, sendcounts[dst], 
+                            sendtype, dst, system_tag, comm);
+        index++;
+      }
+    }
+    // Wait for completion of isend's.
+    smpi_mpi_startall(size - 1, requests);
+    smpi_mpi_waitall(size - 1, requests, MPI_STATUS_IGNORE);
+    xbt_free(requests);
+  }
+}
 
-  if (NULL == request) {
-    retval = MPI_ERR_INTERN;
+void smpi_mpi_reduce(void *sendbuf, void *recvbuf, int count,
+                     MPI_Datatype datatype, MPI_Op op, int root,
+                     MPI_Comm comm)
+{
+  int system_tag = 666;
+  int rank, size, src, index;
+  MPI_Aint lb = 0, dataext = 0;
+  MPI_Request *requests;
+  void **tmpbufs;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+  if(rank != root) {
+    // Send buffer to root
+    smpi_mpi_send(sendbuf, count, datatype, root, system_tag, comm);
   } else {
-    SIMIX_mutex_lock(request->mutex);
-    while (!request->completed) {
-      SIMIX_cond_wait(request->cond, request->mutex);
+    // FIXME: check for errors
+    smpi_datatype_extent(datatype, &lb, &dataext);
+    // Local copy from root
+    smpi_datatype_copy(sendbuf, count, datatype, recvbuf, count, datatype);
+    // Receive buffers from senders
+    //TODO: make a MPI_barrier here ?
+    requests = xbt_new(MPI_Request, size - 1);
+    tmpbufs = xbt_new(void *, size - 1);
+    index = 0;
+    for(src = 0; src < size; src++) {
+      if(src != root) {
+        // FIXME: possibly overkill we we have contiguous/noncontiguous data
+        //  mapping...
+        tmpbufs[index] = xbt_malloc(count * dataext);
+        requests[index] =
+            smpi_irecv_init(tmpbufs[index], count, datatype, src,
+                            system_tag, comm);
+        index++;
+      }
+    }
+    // Wait for completion of irecv's.
+    smpi_mpi_startall(size - 1, requests);
+    for(src = 0; src < size - 1; src++) {
+      index = smpi_mpi_waitany(size - 1, requests, MPI_STATUS_IGNORE);
+      if(index == MPI_UNDEFINED) {
+        break;
+      }
+      smpi_op_apply(op, tmpbufs[index], recvbuf, &count, &datatype);
     }
-    if (NULL != status) {
-      status->MPI_SOURCE = request->src;
-      status->MPI_TAG = request->tag;
-      status->MPI_ERROR = MPI_SUCCESS;
+    for(index = 0; index < size - 1; index++) {
+      xbt_free(tmpbufs[index]);
     }
-    SIMIX_mutex_unlock(request->mutex);
+    xbt_free(tmpbufs);
+    xbt_free(requests);
   }
+}
+
+void smpi_mpi_allreduce(void *sendbuf, void *recvbuf, int count,
+                        MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
+{
+  smpi_mpi_reduce(sendbuf, recvbuf, count, datatype, op, 0, comm);
+  smpi_mpi_bcast(recvbuf, count, datatype, 0, comm);
+}
 
-  return retval;
+void smpi_mpi_scan(void *sendbuf, void *recvbuf, int count,
+                   MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
+{
+  int system_tag = 666;
+  int rank, size, other, index;
+  MPI_Aint lb = 0, dataext = 0;
+  MPI_Request *requests;
+  void **tmpbufs;
+
+  rank = smpi_comm_rank(comm);
+  size = smpi_comm_size(comm);
+
+  // FIXME: check for errors
+  smpi_datatype_extent(datatype, &lb, &dataext);
+
+  // Local copy from self
+  smpi_datatype_copy(sendbuf, count, datatype, recvbuf, count, datatype);
+
+  // Send/Recv buffers to/from others;
+  requests = xbt_new(MPI_Request, size - 1);
+  tmpbufs = xbt_new(void *, rank);
+  index = 0;
+  for(other = 0; other < rank; other++) {
+    // FIXME: possibly overkill we we have contiguous/noncontiguous data 
+    // mapping...
+    tmpbufs[index] = xbt_malloc(count * dataext);
+    requests[index] =
+        smpi_irecv_init(tmpbufs[index], count, datatype, other, system_tag,
+                        comm);
+    index++;
+  }
+  for(other = rank + 1; other < size; other++) {
+    requests[index] =
+        smpi_isend_init(sendbuf, count, datatype, other, system_tag, comm);
+    index++;
+  }
+  // Wait for completion of all comms.
+  smpi_mpi_startall(size - 1, requests);
+  for(other = 0; other < size - 1; other++) {
+    index = smpi_mpi_waitany(size - 1, requests, MPI_STATUS_IGNORE);
+    if(index == MPI_UNDEFINED) {
+      break;
+    }
+    if(index < rank) {
+      // #Request is below rank: it's a irecv
+      smpi_op_apply(op, tmpbufs[index], recvbuf, &count, &datatype);
+    }
+  }
+  for(index = 0; index < rank; index++) {
+    xbt_free(tmpbufs[index]);
+  }
+  xbt_free(tmpbufs);
+  xbt_free(requests);
 }