+/* 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"
XBT_LOG_EXTERNAL_CATEGORY(smpi_sender);
XBT_LOG_EXTERNAL_CATEGORY(smpi_util);
-#define EAGER_LIMIT 65536
-
void smpi_process_init(int* argc, char*** argv) {
int index;
smpi_process_data_t data;
DEBUG1("<%d> Process left the game", index);
}
-/* MPI Low level calls */
-MPI_Request smpi_mpi_isend(void* buf, int count, MPI_Datatype datatype, int dst, int tag, MPI_Comm comm) {
+static MPI_Request build_request(void* buf, int count, MPI_Datatype datatype, int src, int dst, int tag, MPI_Comm comm, unsigned flags) {
MPI_Request request;
- size_t size = smpi_datatype_size(datatype) * count;
- if (size > EAGER_LIMIT) {
- /* Warning: this (zero-length synchronous) call will come back here with size == 0 */
- smpi_mpi_send (NULL, 0, MPI_BYTE, dst, tag, comm);
- }
request = xbt_new(s_smpi_mpi_request_t, 1);
- request->comm = comm;
- request->src = smpi_comm_rank(comm);
+ request->buf = buf;
+ request->size = smpi_datatype_size(datatype) * count;
+ request->src = src;
request->dst = dst;
request->tag = tag;
- request->size = size;
+ request->comm = comm;
+ request->rdv = NULL;
+ request->pair = NULL;
request->complete = 0;
- request->data = request;
- smpi_process_post_send(comm, request);
- request->pair = SIMIX_network_isend(request->rdv, request->size, -1.0, buf, request->size, NULL);
+ request->match = MPI_REQUEST_NULL;
+ request->flags = flags;
+#ifdef HAVE_TRACING
+ request->send = 0;
+ request->recv = 0;
+#endif
return request;
}
-MPI_Request smpi_mpi_irecv(void* buf, int count, MPI_Datatype datatype, int src, int tag, MPI_Comm comm) {
- MPI_Request request;
- size_t size = smpi_datatype_size(datatype) * count;
+/* 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;
+}
+
+MPI_Request smpi_mpi_recv_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, PERSISTENT | RECV);
+
+ return request;
+}
- if (size > EAGER_LIMIT) {
- /* Warning: this (zero-length synchronous) call will come back here with size == 0 */
- smpi_mpi_recv (NULL, 0, MPI_BYTE, src, tag, comm, MPI_STATUS_IGNORE);
+void smpi_mpi_start(MPI_Request request) {
+ xbt_assert0(request->complete == 0, "Cannot start a non-finished communication");
+ if((request->flags & RECV) == RECV) {
+ smpi_process_post_recv(request);
+ print_request("New recv", request);
+ request->pair = SIMIX_network_irecv(request->rdv, request->buf, &request->size);
+ } else {
+ smpi_process_post_send(request->comm, request); // FIXME
+ print_request("New send", request);
+ request->pair = SIMIX_network_isend(request->rdv, request->size, -1.0, request->buf, request->size, NULL);
}
- request = xbt_new(s_smpi_mpi_request_t, 1);
- request->comm = comm;
- request->src = src;
- request->dst = smpi_comm_rank(comm);
- request->tag = tag;
- request->size = size;
- request->complete = 0;
- request->data = MPI_REQUEST_NULL;
- smpi_process_post_recv(request);
- request->pair = SIMIX_network_irecv(request->rdv, buf, &request->size);
+}
+
+void smpi_mpi_startall(int count, MPI_Request* requests) {
+ int i;
+
+ for(i = 0; i < count; i++) {
+ smpi_mpi_start(requests[i]);
+ }
+}
+
+void smpi_mpi_request_free(MPI_Request* request) {
+ xbt_free(*request);
+ *request = MPI_REQUEST_NULL;
+}
+
+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);
+
+ return request;
+}
+
+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);
+
+ smpi_mpi_start(request);
+ return request;
+}
+
+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);
+
+ return request;
+}
+
+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_mpi_start(request);
return request;
}
MPI_Request requests[2];
MPI_Status stats[2];
- requests[0] = smpi_mpi_isend(sendbuf, sendcount, sendtype, dst, sendtag, comm);
- requests[1] = smpi_mpi_irecv(recvbuf, recvcount, recvtype, src, recvtag, comm);
+ 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
}
static void finish_wait(MPI_Request* request, MPI_Status* status) {
- MPI_Request data = (*request)->data;
-
- xbt_assert0(data != MPI_REQUEST_NULL, "Erroneous situation");
if(status != MPI_STATUS_IGNORE) {
status->MPI_SOURCE = (*request)->src;
status->MPI_TAG = (*request)->tag;
status->MPI_ERROR = MPI_SUCCESS;
- status->_count = (*request)->size; // size in bytes
- status->_cancelled = 0; // FIXME: cancellation of requests not handled yet
}
- DEBUG3("finishing wait for %p [data = %p, complete = %d]", *request, data, data->complete);
- // data == *request if sender is first to finish its wait
- // data != *request if receiver is first to finish its wait
- if(data->complete == 0) {
- // first arrives here
- data->complete = 1;
- if(data != *request) {
- // receveiver cleans its part
- xbt_free(*request);
- }
- } else {
- // second arrives here
- if(data != *request) {
- // receiver cleans everything
- xbt_free(data);
- }
+ print_request("finishing wait", *request);
+ if((*request)->complete == 1) {
SIMIX_rdv_destroy((*request)->rdv);
- xbt_free(*request);
+ } else {
+ (*request)->match->complete = 1;
+ (*request)->match->match = MPI_REQUEST_NULL;
+ }
+ if(((*request)->flags & NON_PERSISTENT) == NON_PERSISTENT) {
+ smpi_mpi_request_free(request);
+ } else {
+ (*request)->rdv = NULL;
+ (*request)->pair = NULL;
}
- *request = MPI_REQUEST_NULL;
}
int smpi_mpi_test(MPI_Request* request, MPI_Status* status) {
- MPI_Request data = (*request)->data;
- int flag = data && data->complete == 1;
+ int flag = (*request)->complete;
if(flag) {
- SIMIX_communication_destroy((*request)->pair);
- finish_wait(request, status);
+ smpi_mpi_wait(request, status);
}
return flag;
}
int smpi_mpi_testany(int count, MPI_Request requests[], int* index, MPI_Status* status) {
- MPI_Request data;
int i, flag;
*index = MPI_UNDEFINED;
flag = 0;
for(i = 0; i < count; i++) {
- if(requests[i] != MPI_REQUEST_NULL) {
- data = requests[i]->data;
- if(data != MPI_REQUEST_NULL && data->complete == 1) {
- SIMIX_communication_destroy(requests[i]->pair);
- finish_wait(&requests[i], status);
- *index = i;
- flag = 1;
- break;
- }
+ if(requests[i] != MPI_REQUEST_NULL && requests[i]->complete) {
+ smpi_mpi_wait(&requests[i], status);
+ *index = i;
+ flag = 1;
+ break;
}
}
return flag;
}
-
-void smpi_mpi_get_count(MPI_Status *status, MPI_Datatype datatype, int *count) {
- int size = smpi_datatype_size(datatype);
- *count = (int)(status->_count / size);
- if ( (int)((*count) * size) != status->_count )
- *count = MPI_UNDEFINED;
-}
-
-
void smpi_mpi_wait(MPI_Request* request, MPI_Status* status) {
- MPI_Request data = (*request)->data;
-
- DEBUG6("wait for request %p (%p: %p) [src = %d, dst = %d, tag = %d]",
- *request, (*request)->pair, data, (*request)->src, (*request)->dst, (*request)->tag);
- // data is null if receiver waits before sender enters the rdv
- if(data == MPI_REQUEST_NULL || data->complete == 0) {
- SIMIX_network_wait((*request)->pair, -1.0);
- } else {
- SIMIX_communication_destroy((*request)->pair);
- }
+ print_request("wait", *request);
+ SIMIX_network_wait((*request)->pair, -1.0);
finish_wait(request, status);
}
int smpi_mpi_waitany(int count, MPI_Request requests[], MPI_Status* status) {
xbt_dynar_t comms;
- MPI_Request data;
int i, size, index;
int* map;
if(count > 0) {
// First check for already completed requests
for(i = 0; i < count; i++) {
- if(requests[i] != MPI_REQUEST_NULL) {
- data = requests[i]->data;
- if(data != MPI_REQUEST_NULL && data->complete == 1) {
- index = i;
- SIMIX_communication_destroy(requests[index]->pair); // always succeeds (but cleans the simix layer)
- break;
- }
+ if(requests[i] != MPI_REQUEST_NULL && requests[i]->complete) {
+ index = i;
+ smpi_mpi_wait(&requests[index], status);
+ break;
}
}
if(index == MPI_UNDEFINED) {
DEBUG0("Wait for one of");
for(i = 0; i < count; i++) {
if(requests[i] != MPI_REQUEST_NULL && requests[i]->complete == 0) {
- DEBUG4(" request %p [src = %d, dst = %d, tag = %d]",
- requests[i], requests[i]->src, requests[i]->dst, requests[i]->tag);
+ print_request(" ", requests[i]);
xbt_dynar_push(comms, &requests[i]->pair);
map[size] = i;
size++;
if(size > 0) {
index = SIMIX_network_waitany(comms);
index = map[index];
+ finish_wait(&requests[index], status);
}
xbt_free(map);
- xbt_dynar_free_container(&comms);
- }
- if(index != MPI_UNDEFINED) {
- finish_wait(&requests[index], status);
+ xbt_dynar_free(&comms);
}
}
return index;
if(status != MPI_STATUS_IGNORE) {
memcpy(&status[index], &stat, sizeof(stat));
}
+ // FIXME: check this -v
// Move the last request to the found position
requests[index] = requests[count - 1];
requests[count - 1] = MPI_REQUEST_NULL;
}
int smpi_mpi_waitsome(int incount, MPI_Request requests[], int* indices, MPI_Status status[]) {
- MPI_Request data;
int i, count;
count = 0;
for(i = 0; i < incount; i++) {
- if(requests[i] != MPI_REQUEST_NULL) {
- data = requests[i]->data;
- if(data != MPI_REQUEST_NULL && data->complete == 1) {
- SIMIX_communication_destroy(requests[i]->pair);
- finish_wait(&requests[i], status != MPI_STATUS_IGNORE ? &status[i] : MPI_STATUS_IGNORE);
- indices[count] = i;
- count++;
- }
+ if(requests[i] != MPI_REQUEST_NULL && requests[i]->complete) {
+ smpi_mpi_wait(&requests[i], status != MPI_STATUS_IGNORE ? &status[i] : MPI_STATUS_IGNORE);
+ indices[count] = i;
+ count++;
}
}
return count;
index = 0;
for(src = 0; src < size; src++) {
if(src != root) {
- requests[index] = smpi_mpi_irecv(&((char*)recvbuf)[src * recvcount * recvsize], recvcount, recvtype, src, system_tag, comm);
+ requests[index] = smpi_irecv_init(&((char*)recvbuf)[src * recvcount * recvsize], 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);
}
index = 0;
for(src = 0; src < size; src++) {
if(src != root) {
- requests[index] = smpi_mpi_irecv(&((char*)recvbuf)[displs[src]], recvcounts[src], recvtype, src, system_tag, comm);
+ requests[index] = smpi_irecv_init(&((char*)recvbuf)[displs[src]], 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);
}
index = 0;
for(other = 0; other < size; other++) {
if(other != rank) {
- requests[index] = smpi_mpi_isend(sendbuf, sendcount, sendtype, other, system_tag, comm);
+ requests[index] = smpi_isend_init(sendbuf, sendcount, sendtype, other, system_tag, comm);
index++;
- requests[index] = smpi_mpi_irecv(&((char*)recvbuf)[other * recvcount * recvsize], recvcount, recvtype, other, system_tag, comm);
+ requests[index] = smpi_irecv_init(&((char*)recvbuf)[other * recvcount * recvsize], 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);
}
index = 0;
for(other = 0; other < size; other++) {
if(other != rank) {
- requests[index] = smpi_mpi_isend(sendbuf, sendcount, sendtype, other, system_tag, comm);
+ requests[index] = smpi_isend_init(sendbuf, sendcount, sendtype, other, system_tag, comm);
index++;
- requests[index] = smpi_mpi_irecv(&((char*)recvbuf)[displs[other]], recvcounts[other], recvtype, other, system_tag, comm);
+ requests[index] = smpi_irecv_init(&((char*)recvbuf)[displs[other]], 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);
}
index = 0;
for(dst = 0; dst < size; dst++) {
if(dst != root) {
- requests[index] = smpi_mpi_isend(&((char*)sendbuf)[dst * sendcount * sendsize], sendcount, sendtype, dst, system_tag, comm);
+ requests[index] = smpi_isend_init(&((char*)sendbuf)[dst * sendcount * sendsize], 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);
}
index = 0;
for(dst = 0; dst < size; dst++) {
if(dst != root) {
- requests[index] = smpi_mpi_isend(&((char*)sendbuf)[displs[dst]], sendcounts[dst], sendtype, dst, system_tag, comm);
+ requests[index] = smpi_isend_init(&((char*)sendbuf)[displs[dst]], 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);
}
for(src = 0; src < size; src++) {
if(src != root) {
tmpbufs[index] = xbt_malloc(count * datasize);
- requests[index] = smpi_mpi_irecv(tmpbufs[index], count, datatype, src, system_tag, comm);
+ 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) {
index = 0;
for(other = 0; other < rank; other++) {
tmpbufs[index] = xbt_malloc(count * datasize);
- requests[index] = smpi_mpi_irecv(tmpbufs[index], count, datatype, other, system_tag, comm);
+ requests[index] = smpi_irecv_init(tmpbufs[index], count, datatype, other, system_tag, comm);
index++;
}
for(other = rank + 1; other < size; other++) {
- requests[index] = smpi_mpi_isend(sendbuf, count, datatype, other, system_tag, comm);
+ 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 < total; other++) {
index = smpi_mpi_waitany(size - 1, requests, MPI_STATUS_IGNORE);
if(index == MPI_UNDEFINED) {
