// state vars
- int host_count;
+ int process_count;
xbt_mallocator_t request_mallocator;
xbt_mallocator_t message_mallocator;
xbt_fifo_t pending_recv_request_queue;
xbt_fifo_t pending_send_request_queue;
xbt_fifo_t received_message_queue;
-} s_smpi_host_data_t;
-typedef struct smpi_host_data_t *smpi_host_data_t;
+} s_smpi_process_data_t;
+typedef struct smpi_host_data_t *smpi_process_data_t;
// function prototypes
void smpi_process_init(int *argc,char ***argv);
void smpi_global_init(void);
void smpi_global_destroy(void);
-int smpi_host_index(void);
-smx_mutex_t smpi_host_mutex(void);
-smx_cond_t smpi_host_cond(void);
+int smpi_process_index(void);
+smx_mutex_t smpi_process_mutex(void);
+smx_cond_t smpi_process_cond(void);
int smpi_run_simulation(int *argc, char **argv);
int smpi_create_request(void *buf, int count, smpi_mpi_datatype_t datatype,
int src, int dst, int tag,
int smpi_mpi_comm_rank(smpi_mpi_communicator_t comm)
{
- return comm->index_to_rank_map[smpi_host_index()];
+ return comm->index_to_rank_map[smpi_process_index()];
}
void smpi_process_init(int *argc, char***argv)
{
- smx_host_t host;
- smpi_host_data_t hdata;
+ smpi_process_data_t pdata;
// initialize some local variables
- host = SIMIX_host_self();
- hdata = xbt_new(s_smpi_host_data_t, 1);
- SIMIX_host_set_data(host, hdata);
- SIMIX_process_set_data(SIMIX_process_self(),hdata);
+ pdata = xbt_new(s_smpi_process_data_t, 1);
+ SIMIX_process_set_data(SIMIX_process_self(),pdata);
/* get rank from command line, and remove it from argv */
- hdata->index = atoi( (*argv)[1] );
+ pdata->index = atoi( (*argv)[1] );
if (*argc>2) {
memmove((*argv)[1],(*argv)[2], sizeof(char*)* (*argc-2));
(*argv)[ (*argc)-1] = NULL;
}
(*argc)--;
- hdata->mutex = SIMIX_mutex_init();
- hdata->cond = SIMIX_cond_init();
- hdata->finalize = 0;
+ pdata->mutex = SIMIX_mutex_init();
+ pdata->cond = SIMIX_cond_init();
+ pdata->finalize = 0;
- hdata->pending_recv_request_queue = xbt_fifo_new();
- hdata->pending_send_request_queue = xbt_fifo_new();
- hdata->received_message_queue = xbt_fifo_new();
+ pdata->pending_recv_request_queue = xbt_fifo_new();
+ pdata->pending_send_request_queue = xbt_fifo_new();
+ pdata->received_message_queue = xbt_fifo_new();
- hdata->main = SIMIX_process_self();
- hdata->sender = SIMIX_process_create("smpi_sender",
- smpi_sender, hdata,
+ pdata->main = SIMIX_process_self();
+ pdata->sender = SIMIX_process_create("smpi_sender",
+ smpi_sender, pdata,
SIMIX_host_get_name(SIMIX_host_self()), 0, NULL,
/*props */ NULL);
- hdata->receiver = SIMIX_process_create("smpi_receiver",
- smpi_receiver, hdata,
+ pdata->receiver = SIMIX_process_create("smpi_receiver",
+ smpi_receiver, pdata,
SIMIX_host_get_name(SIMIX_host_self()), 0, NULL,
/*props */ NULL);
- smpi_global->main_processes[hdata->index] = SIMIX_process_self();
+ smpi_global->main_processes[pdata->index] = SIMIX_process_self();
return;
}
void smpi_process_finalize()
{
- smpi_host_data_t hdata = SIMIX_host_get_data(SIMIX_host_self());
+ smpi_process_data_t pdata = SIMIX_process_get_data(SIMIX_process_self());
- hdata->finalize = 2; /* Tell sender and receiver to quit */
- SIMIX_process_resume(hdata->sender);
- SIMIX_process_resume(hdata->receiver);
- while (hdata->finalize>0) { /* wait until it's done */
- SIMIX_cond_wait(hdata->cond,hdata->mutex);
+ pdata->finalize = 2; /* Tell sender and receiver to quit */
+ SIMIX_process_resume(pdata->sender);
+ SIMIX_process_resume(pdata->receiver);
+ while (pdata->finalize>0) { /* wait until it's done */
+ SIMIX_cond_wait(pdata->cond,pdata->mutex);
}
- SIMIX_mutex_destroy(hdata->mutex);
- SIMIX_cond_destroy(hdata->cond);
- xbt_fifo_free(hdata->pending_recv_request_queue);
- xbt_fifo_free(hdata->pending_send_request_queue);
- xbt_fifo_free(hdata->received_message_queue);
+ SIMIX_mutex_destroy(pdata->mutex);
+ SIMIX_cond_destroy(pdata->cond);
+ xbt_fifo_free(pdata->pending_recv_request_queue);
+ xbt_fifo_free(pdata->pending_send_request_queue);
+ xbt_fifo_free(pdata->received_message_queue);
}
int smpi_mpi_barrier(smpi_mpi_communicator_t comm)
int smpi_mpi_isend(smpi_mpi_request_t request)
{
- smpi_host_data_t hdata = SIMIX_host_get_data(SIMIX_host_self());
+ smpi_process_data_t pdata = SIMIX_process_get_data(SIMIX_process_self());
int retval = MPI_SUCCESS;
if (NULL == request) {
retval = MPI_ERR_INTERN;
} else {
- xbt_fifo_push(hdata->pending_send_request_queue, request);
- SIMIX_process_resume(hdata->sender);
+ xbt_fifo_push(pdata->pending_send_request_queue, request);
+ SIMIX_process_resume(pdata->sender);
}
return retval;
int smpi_mpi_irecv(smpi_mpi_request_t request)
{
int retval = MPI_SUCCESS;
- smpi_host_data_t hdata = SIMIX_host_get_data(SIMIX_host_self());
+ smpi_process_data_t pdata = SIMIX_process_get_data(SIMIX_process_self());
if (NULL == request) {
retval = MPI_ERR_INTERN;
} else {
- xbt_fifo_push(hdata->pending_recv_request_queue, request);
+ xbt_fifo_push(pdata->pending_recv_request_queue, request);
- if (SIMIX_process_is_suspended(hdata->receiver)) {
- SIMIX_process_resume(hdata->receiver);
+ if (SIMIX_process_is_suspended(pdata->receiver)) {
+ SIMIX_process_resume(pdata->receiver);
}
}
void smpi_execute(double duration)
{
smx_host_t host = SIMIX_host_self();
- smx_mutex_t mutex = smpi_host_mutex();
- smx_cond_t cond = smpi_host_cond();
+ smx_mutex_t mutex = smpi_process_mutex();
+ smx_cond_t cond = smpi_process_cond();
smx_action_t action;
e_surf_action_state_t state;
// config variable
smpi_global->reference_speed = SMPI_DEFAULT_SPEED;
- // host info blank until sim starts
- // FIXME: is this okay?
- smpi_global->host_count = 0;
-
// mallocators
smpi_global->request_mallocator =
xbt_mallocator_new(SMPI_REQUEST_MALLOCATOR_SIZE, smpi_request_new,
smpi_global->do_once_duration = NULL;
smpi_global->do_once_mutex = SIMIX_mutex_init();
- smpi_global->host_count = SIMIX_host_get_number();
+ smpi_global->process_count = SIMIX_process_count();
smpi_mpi_global = xbt_new(s_smpi_mpi_global_t, 1);
// global communicator
smpi_mpi_global->mpi_comm_world = xbt_new(s_smpi_mpi_communicator_t, 1);
- smpi_mpi_global->mpi_comm_world->size = smpi_global->host_count;
+ smpi_mpi_global->mpi_comm_world->size = smpi_global->process_count;
smpi_mpi_global->mpi_comm_world->barrier_count = 0;
smpi_mpi_global->mpi_comm_world->barrier_mutex = SIMIX_mutex_init();
smpi_mpi_global->mpi_comm_world->barrier_cond = SIMIX_cond_init();
smpi_mpi_global->mpi_comm_world->rank_to_index_map =
- xbt_new(int, smpi_global->host_count);
+ xbt_new(int, smpi_global->process_count);
smpi_mpi_global->mpi_comm_world->index_to_rank_map =
- xbt_new(int, smpi_global->host_count);
- for (i = 0; i < smpi_global->host_count; i++) {
+ xbt_new(int, smpi_global->process_count);
+ for (i = 0; i < smpi_global->process_count; i++) {
smpi_mpi_global->mpi_comm_world->rank_to_index_map[i] = i;
smpi_mpi_global->mpi_comm_world->index_to_rank_map[i] = i;
}
}
-int smpi_host_index()
+int smpi_process_index()
{
- smx_host_t host = SIMIX_host_self();
- smpi_host_data_t hdata = (smpi_host_data_t) SIMIX_host_get_data(host);
- return hdata->index;
+ smpi_process_data_t pdata = (smpi_process_data_t) SIMIX_process_get_data(SIMIX_process_self());
+ return pdata->index;
}
-smx_mutex_t smpi_host_mutex()
+smx_mutex_t smpi_process_mutex()
{
- smx_host_t host = SIMIX_host_self();
- smpi_host_data_t hdata = (smpi_host_data_t) SIMIX_host_get_data(host);
- return hdata->mutex;
+ smpi_process_data_t pdata = (smpi_process_data_t) SIMIX_process_get_data(SIMIX_process_self());
+ return pdata->mutex;
}
-smx_cond_t smpi_host_cond()
+smx_cond_t smpi_process_cond()
{
- smx_host_t host = SIMIX_host_self();
- smpi_host_data_t hdata = (smpi_host_data_t) SIMIX_host_get_data(host);
- return hdata->cond;
+ smpi_process_data_t pdata = (smpi_process_data_t) SIMIX_process_get_data(SIMIX_process_self());
+ return pdata->cond;
}
int smpi_run_simulation(int *argc, char **argv)
// FIXME: need to test parameters
- index = smpi_host_index();
+ index = smpi_process_index();
rank = comm->index_to_rank_map[index];
// default output
tempcomm->barrier_mutex = SIMIX_mutex_init();
tempcomm->barrier_cond = SIMIX_cond_init();
tempcomm->rank_to_index_map = xbt_new(int, count);
- tempcomm->index_to_rank_map = xbt_new(int, smpi_global->host_count);
- for (j = 0; j < smpi_global->host_count; j++) {
+ tempcomm->index_to_rank_map = xbt_new(int, smpi_global->process_count);
+ for (j = 0; j < smpi_global->process_count; j++) {
tempcomm->index_to_rank_map[j] = -1;
}
for (j = 0; j < count; j++) {
int smpi_receiver(int argc, char*argv[])
{
- smpi_host_data_t mydata = SIMIX_process_get_data(SIMIX_process_self());
+ smpi_process_data_t mydata = SIMIX_process_get_data(SIMIX_process_self());
smx_process_t self;
int index = mydata->index;
"Logging specific to SMPI (sender)");
int smpi_sender(int argc,char*argv[]) {
- smpi_host_data_t mydata = SIMIX_process_get_data(SIMIX_process_self());
+ smpi_process_data_t mydata = SIMIX_process_get_data(SIMIX_process_self());
smx_process_t self;
smx_host_t shost;
request->datatype->size * request->count);
dindex = request->comm->rank_to_index_map[request->dst];
+ smpi_process_data_t remote_process = SIMIX_process_get_data(smpi_global->main_processes[dindex]);
dhost = SIMIX_process_get_host(smpi_global->main_processes[dindex]);
- smpi_host_data_t remote_host = SIMIX_host_get_data(dhost);
message->forward = (request->forward - 1) / 2;
request->forward = request->forward / 2;
SIMIX_cond_wait(request->cond, request->mutex);
}
- xbt_fifo_push(remote_host->received_message_queue, message);
+ xbt_fifo_push(remote_process->received_message_queue, message);
SIMIX_unregister_action_to_condition(action, request->cond);
SIMIX_action_destroy(action);
SIMIX_mutex_unlock(request->mutex);
// wake up receiver if necessary
- SIMIX_process_resume(remote_host->receiver);
+ SIMIX_process_resume(remote_process->receiver);
} else if (mydata->finalize>0) { /* main wants me to die and nothing to do */
mydata->finalize--;
smpi_bench_end();
host = SIMIX_host_self();
- mutex = smpi_host_mutex();
- cond = smpi_host_cond();
+ mutex = smpi_process_mutex();
+ cond = smpi_process_cond();
SIMIX_mutex_lock(mutex);