src/smpi/smpi_global.c

   1 #include <stdio.h>
   2
   3 #include "private.h"
   4
   5 XBT_LOG_NEW_CATEGORY(smpi, "All SMPI categories");
   6
   7 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_kernel, smpi, "Logging specific to SMPI (kernel)");
   8
   9 smpi_global_t     smpi_global     = NULL;
  10
  11 void *smpi_request_new(void);
  12
  13 void *smpi_request_new()
  14 {
  15         smpi_mpi_request_t request = xbt_new(s_smpi_mpi_request_t, 1);
  16
  17         request->buf       = NULL;
  18         request->completed = 0;
  19         request->mutex     = SIMIX_mutex_init();
  20         request->cond      = SIMIX_cond_init();
  21         request->data      = NULL;
  22         request->forward   = 0;
  23
  24         return request;
  25 }
  26
  27 void smpi_request_free(void *pointer);
  28
  29 void smpi_request_free(void *pointer)
  30 {
  31
  32         smpi_mpi_request_t request = pointer;
  33
  34         SIMIX_cond_destroy(request->cond);
  35         SIMIX_mutex_destroy(request->mutex);
  36         xbt_free(request);
  37
  38         return;
  39 }
  40
  41 void smpi_request_reset(void *pointer);
  42
  43 void smpi_request_reset(void *pointer)
  44 {
  45         smpi_mpi_request_t request = pointer;
  46
  47         request->buf       = NULL;
  48         request->completed = 0;
  49         request->data      = NULL;
  50         request->forward   = 0;
  51
  52         return;
  53 }
  54
  55
  56 void *smpi_message_new(void);
  57
  58 void *smpi_message_new()
  59 {
  60         smpi_received_message_t message = xbt_new(s_smpi_received_message_t, 1);
  61         message->buf = NULL;
  62         return message;
  63 }
  64
  65 void smpi_message_free(void *pointer);
  66
  67 void smpi_message_free(void *pointer)
  68 {
  69         xbt_free(pointer);
  70         return;
  71 }
  72
  73 void smpi_message_reset(void *pointer);
  74
  75 void smpi_message_reset(void *pointer)
  76 {
  77         smpi_received_message_t message = pointer;
  78         message->buf = NULL;
  79         return;
  80 }
  81
  82 int smpi_create_request(void *buf, int count, smpi_mpi_datatype_t datatype,
  83         int src, int dst, int tag, smpi_mpi_communicator_t comm, smpi_mpi_request_t *requestptr)
  84 {
  85         int retval = MPI_SUCCESS;
  86
  87         smpi_mpi_request_t request = NULL;
  88
  89         // parameter checking prob belongs in smpi_mpi, but this is less repeat code
  90         if (NULL == buf) {
  91                 retval = MPI_ERR_INTERN;
  92         } else if (0 > count) {
  93                 retval = MPI_ERR_COUNT;
  94         } else if (NULL == datatype) {
  95                 retval = MPI_ERR_TYPE;
  96         } else if (MPI_ANY_SOURCE != src && (0 > src || comm->size <= src)) {
  97                 retval = MPI_ERR_RANK;
  98         } else if (0 > dst || comm->size <= dst) {
  99                 retval = MPI_ERR_RANK;
 100         } else if (MPI_ANY_TAG != tag && 0 > tag) {
 101                 retval = MPI_ERR_TAG;
 102         } else if (NULL == comm) {
 103                 retval = MPI_ERR_COMM;
 104         } else if (NULL == requestptr) {
 105                 retval = MPI_ERR_ARG;
 106         } else {
 107                 request           = xbt_mallocator_get(smpi_global->request_mallocator);
 108                 request->comm     = comm;
 109                 request->src      = src;
 110                 request->dst      = dst;
 111                 request->tag      = tag;
 112                 request->buf      = buf;
 113                 request->datatype = datatype;
 114                 request->count    = count;
 115
 116                 *requestptr       = request;
 117         }
 118         return retval;
 119 }
 120
 121 void smpi_global_init()
 122 {
 123         int i;
 124
 125         int size = SIMIX_host_get_number();
 126
 127         /* Connect our log channels: that must be done manually under windows */
 128 #ifdef XBT_LOG_CONNECT
 129         XBT_LOG_CONNECT(smpi_base, smpi);
 130         XBT_LOG_CONNECT(smpi_bench, smpi);
 131         XBT_LOG_CONNECT(smpi_kernel, smpi);
 132         XBT_LOG_CONNECT(smpi_mpi, smpi);
 133         XBT_LOG_CONNECT(smpi_receiver, smpi);
 134         XBT_LOG_CONNECT(smpi_sender, smpi);
 135         XBT_LOG_CONNECT(smpi_util, smpi);
 136 #endif
 137
 138         smpi_global                                      = xbt_new(s_smpi_global_t, 1);
 139         // config variable
 140         smpi_global->reference_speed                     = SMPI_DEFAULT_SPEED;
 141
 142         smpi_global->root_ready                          = 0;
 143         smpi_global->ready_process_count                 = 0;
 144
 145         // start/stop
 146         smpi_global->start_stop_mutex                    = SIMIX_mutex_init();
 147         smpi_global->start_stop_cond                     = SIMIX_cond_init();
 148
 149         // host info blank until sim starts
 150         // FIXME: is this okay?
 151         smpi_global->hosts                               = NULL;
 152         smpi_global->host_count                          = 0;
 153
 154         // running hosts
 155         smpi_global->running_hosts_count_mutex           = SIMIX_mutex_init();
 156         smpi_global->running_hosts_count                 = 0;
 157
 158         // mallocators
 159         smpi_global->request_mallocator                  = xbt_mallocator_new(SMPI_REQUEST_MALLOCATOR_SIZE,
 160                                                              smpi_request_new, smpi_request_free, smpi_request_reset);
 161         smpi_global->message_mallocator                  = xbt_mallocator_new(SMPI_MESSAGE_MALLOCATOR_SIZE,
 162                                                              smpi_message_new, smpi_message_free, smpi_message_reset);
 163
 164         // queues
 165         smpi_global->pending_send_request_queues         = xbt_new(xbt_fifo_t,  size);
 166         smpi_global->pending_send_request_queues_mutexes = xbt_new(smx_mutex_t, size);
 167         smpi_global->pending_recv_request_queues         = xbt_new(xbt_fifo_t,  size);
 168         smpi_global->pending_recv_request_queues_mutexes = xbt_new(smx_mutex_t, size);
 169         smpi_global->received_message_queues             = xbt_new(xbt_fifo_t,  size);
 170         smpi_global->received_message_queues_mutexes     = xbt_new(smx_mutex_t, size);
 171
 172         // sender/receiver processes
 173         smpi_global->sender_processes                    = xbt_new(smx_process_t, size);
 174         smpi_global->receiver_processes                  = xbt_new(smx_process_t, size);
 175
 176         // timers
 177         smpi_global->timer                               = xbt_os_timer_new();
 178         smpi_global->timer_mutex                         = SIMIX_mutex_init();
 179         smpi_global->timer_cond                          = SIMIX_cond_init();
 180
 181         smpi_global->do_once_duration_nodes              = NULL;
 182         smpi_global->do_once_duration                    = NULL;
 183         smpi_global->do_once_mutex                       = SIMIX_mutex_init();
 184
 185         for (i = 0; i < size; i++) {
 186                 smpi_global->pending_send_request_queues[i]         = xbt_fifo_new();
 187                 smpi_global->pending_send_request_queues_mutexes[i] = SIMIX_mutex_init();
 188                 smpi_global->pending_recv_request_queues[i]         = xbt_fifo_new();
 189                 smpi_global->pending_recv_request_queues_mutexes[i] = SIMIX_mutex_init();
 190                 smpi_global->received_message_queues[i]             = xbt_fifo_new();
 191                 smpi_global->received_message_queues_mutexes[i]     = SIMIX_mutex_init();
 192         }
 193
 194 }
 195
 196 void smpi_global_destroy()
 197 {
 198         int i;
 199
 200         int size = SIMIX_host_get_number();
 201
 202         smpi_do_once_duration_node_t curr, next;
 203
 204         // start/stop
 205         SIMIX_mutex_destroy(smpi_global->start_stop_mutex);
 206         SIMIX_cond_destroy(smpi_global->start_stop_cond);
 207
 208         // processes
 209         xbt_free(smpi_global->sender_processes);
 210         xbt_free(smpi_global->receiver_processes);
 211
 212         // running hosts
 213         SIMIX_mutex_destroy(smpi_global->running_hosts_count_mutex);
 214
 215         // mallocators
 216         xbt_mallocator_free(smpi_global->request_mallocator);
 217         xbt_mallocator_free(smpi_global->message_mallocator);
 218
 219         xbt_os_timer_free(smpi_global->timer);
 220         SIMIX_mutex_destroy(smpi_global->timer_mutex);
 221         SIMIX_cond_destroy(smpi_global->timer_cond);
 222
 223         for(curr = smpi_global->do_once_duration_nodes; NULL != curr; curr = next) {
 224                 next = curr->next;
 225                 xbt_free(curr->file);
 226                 xbt_free(curr);
 227         }
 228
 229         SIMIX_mutex_destroy(smpi_global->do_once_mutex);
 230
 231         for(i = 0; i < size; i++) {
 232                 xbt_fifo_free(smpi_global->pending_send_request_queues[i]);
 233                 SIMIX_mutex_destroy(smpi_global->pending_send_request_queues_mutexes[i]);
 234                 xbt_fifo_free(smpi_global->pending_recv_request_queues[i]);
 235                 SIMIX_mutex_destroy(smpi_global->pending_recv_request_queues_mutexes[i]);
 236                 xbt_fifo_free(smpi_global->received_message_queues[i]);
 237                 SIMIX_mutex_destroy(smpi_global->received_message_queues_mutexes[i]);
 238         }
 239
 240         xbt_free(smpi_global->pending_send_request_queues);
 241         xbt_free(smpi_global->pending_send_request_queues_mutexes);
 242         xbt_free(smpi_global->pending_recv_request_queues);
 243         xbt_free(smpi_global->pending_recv_request_queues_mutexes);
 244         xbt_free(smpi_global->received_message_queues);
 245         xbt_free(smpi_global->received_message_queues_mutexes);
 246
 247         xbt_free(smpi_global);
 248
 249         smpi_global = NULL;
 250 }
 251
 252 int smpi_host_index()
 253 {
 254         smx_host_t host = SIMIX_host_self();
 255         smpi_host_data_t hdata = (smpi_host_data_t)SIMIX_host_get_data(host);
 256         return hdata->index;
 257 }
 258
 259 smx_mutex_t smpi_host_mutex()
 260 {
 261         smx_host_t host = SIMIX_host_self();
 262         smpi_host_data_t hdata = (smpi_host_data_t)SIMIX_host_get_data(host);
 263         return hdata->mutex;
 264 }
 265
 266 smx_cond_t smpi_host_cond()
 267 {
 268         smx_host_t host = SIMIX_host_self();
 269         smpi_host_data_t hdata = (smpi_host_data_t)SIMIX_host_get_data(host);
 270         return hdata->cond;
 271 }
 272
 273 int smpi_run_simulation(int *argc, char **argv)
 274 {
 275         smx_cond_t   cond           = NULL;
 276         smx_action_t action         = NULL;
 277
 278         xbt_fifo_t   actions_failed = xbt_fifo_new();
 279         xbt_fifo_t   actions_done   = xbt_fifo_new();
 280
 281         srand(SMPI_RAND_SEED);
 282
 283         SIMIX_global_init(argc, argv);
 284
 285         SIMIX_function_register("smpi_simulated_main", smpi_simulated_main);
 286         SIMIX_function_register("smpi_sender",         smpi_sender);
 287         SIMIX_function_register("smpi_receiver",       smpi_receiver);
 288
 289         // FIXME: ought to verify these files...
 290         SIMIX_create_environment(argv[1]);
 291
 292         // must initialize globals between creating environment and launching app....
 293         smpi_global_init();
 294
 295         SIMIX_launch_application(argv[2]);
 296
 297         /* Prepare to display some more info when dying on Ctrl-C pressing */
 298         // FIXME: doesn't work
 299         //signal(SIGINT, inthandler);
 300
 301         /* Clean IO before the run */
 302         fflush(stdout);
 303         fflush(stderr);
 304         SIMIX_init();
 305
 306         while (SIMIX_solve(actions_done, actions_failed) != -1.0) {
 307                 while ((action = xbt_fifo_pop(actions_failed))) {
 308                         DEBUG1("** %s failed **", action->name);
 309                         while((cond = xbt_fifo_pop(action->cond_list))) {
 310                                 SIMIX_cond_broadcast(cond);
 311                         }
 312                 }
 313                 while((action = xbt_fifo_pop(actions_done))) {
 314                         DEBUG1("** %s done **",action->name);
 315                         while((cond = xbt_fifo_pop(action->cond_list))) {
 316                                 SIMIX_cond_broadcast(cond);
 317                         }
 318                 }
 319         }
 320
 321         // FIXME: cleanup incomplete
 322         xbt_fifo_free(actions_failed);
 323         xbt_fifo_free(actions_done);
 324
 325         INFO1("simulation time %g", SIMIX_get_clock());
 326
 327         smpi_global_destroy();
 328
 329         SIMIX_clean();
 330
 331         return 0;
 332 }