src/smpi/smpi_global.c

   1 #include <stdio.h>
   2
   3 #include "private.h"
   4
   5 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi,XBT_LOG_ROOT_CAT, "All SMPI categories");
   6
   7 SMPI_Global_t     smpi_global     = NULL;
   8
   9 void *smpi_request_new()
  10 {
  11         smpi_mpi_request_t request = xbt_new(s_smpi_mpi_request_t, 1);
  12
  13         request->completed = 0;
  14         request->mutex     = SIMIX_mutex_init();
  15         request->cond      = SIMIX_cond_init();
  16
  17         return request;
  18 }
  19
  20 void smpi_request_free(void *pointer)
  21 {
  22
  23         smpi_mpi_request_t request = pointer;
  24
  25         if (NULL != request) {
  26                 SIMIX_cond_destroy(request->cond);
  27                 SIMIX_mutex_destroy(request->mutex);
  28                 xbt_free(request);
  29         }
  30
  31         return;
  32 }
  33
  34 void smpi_request_reset(void *pointer)
  35 {
  36         return;
  37 }
  38
  39
  40 void *smpi_message_new()
  41 {
  42         return xbt_new(s_smpi_received_message_t, 1);
  43 }
  44
  45 void smpi_message_free(void *pointer)
  46 {
  47         if (NULL != pointer) {
  48                 xbt_free(pointer);
  49         }
  50
  51         return;
  52 }
  53
  54 void smpi_message_reset(void *pointer)
  55 {
  56         return;
  57 }
  58
  59 void smpi_global_init()
  60 {
  61         int i;
  62
  63         int size = SIMIX_host_get_number();
  64
  65         smpi_global                                      = xbt_new(s_SMPI_Global_t, 1);
  66
  67         // config variable
  68         smpi_global->reference_speed                     = SMPI_DEFAULT_SPEED;
  69
  70         smpi_global->root_ready                          = 0;
  71         smpi_global->ready_process_count                 = 0;
  72
  73         // start/stop
  74         smpi_global->start_stop_mutex                    = SIMIX_mutex_init();
  75         smpi_global->start_stop_cond                     = SIMIX_cond_init();
  76
  77         // processes
  78         smpi_global->sender_processes                    = xbt_new(smx_process_t, size);
  79         smpi_global->receiver_processes                  = xbt_new(smx_process_t, size);
  80
  81         // running hosts
  82         smpi_global->running_hosts_count_mutex           = SIMIX_mutex_init();
  83         smpi_global->running_hosts_count                 = 0;
  84
  85         // mallocators
  86         smpi_global->request_mallocator                  = xbt_mallocator_new(SMPI_REQUEST_MALLOCATOR_SIZE,
  87                                                              smpi_request_new, smpi_request_free, smpi_request_reset);
  88         smpi_global->message_mallocator                  = xbt_mallocator_new(SMPI_MESSAGE_MALLOCATOR_SIZE,
  89                                                              smpi_message_new, smpi_message_free, smpi_message_reset);
  90
  91         // queues
  92         smpi_global->pending_send_request_queues         = xbt_new(xbt_fifo_t,  size);
  93         smpi_global->pending_send_request_queues_mutexes = xbt_new(smx_mutex_t, size);
  94         smpi_global->pending_recv_request_queues         = xbt_new(xbt_fifo_t,  size);
  95         smpi_global->pending_recv_request_queues_mutexes = xbt_new(smx_mutex_t, size);
  96         smpi_global->received_message_queues             = xbt_new(xbt_fifo_t,  size);
  97         smpi_global->received_message_queues_mutexes     = xbt_new(smx_mutex_t, size);
  98
  99         // timers
 100         smpi_global->timers                              = xbt_new(xbt_os_timer_t, size);
 101         smpi_global->timers_mutexes                      = xbt_new(smx_mutex_t, size);
 102
 103         for(i = 0; i < size; i++) {
 104                 smpi_global->pending_send_request_queues[i]         = xbt_fifo_new();
 105                 smpi_global->pending_send_request_queues_mutexes[i] = SIMIX_mutex_init();
 106                 smpi_global->pending_recv_request_queues[i]         = xbt_fifo_new();
 107                 smpi_global->pending_recv_request_queues_mutexes[i] = SIMIX_mutex_init();
 108                 smpi_global->received_message_queues[i]             = xbt_fifo_new();
 109                 smpi_global->received_message_queues_mutexes[i]     = SIMIX_mutex_init();
 110                 smpi_global->timers[i]                              = xbt_os_timer_new();
 111                 smpi_global->timers_mutexes[i]                      = SIMIX_mutex_init();
 112         }
 113
 114 }
 115
 116 void smpi_global_destroy()
 117 {
 118         int i;
 119
 120         int size = SIMIX_host_get_number();
 121
 122         // start/stop
 123         SIMIX_mutex_destroy(smpi_global->start_stop_mutex);
 124         SIMIX_cond_destroy(smpi_global->start_stop_cond);
 125
 126         // processes
 127         xbt_free(smpi_global->sender_processes);
 128         xbt_free(smpi_global->receiver_processes);
 129
 130         // running hosts
 131         SIMIX_mutex_destroy(smpi_global->running_hosts_count_mutex);
 132
 133         // mallocators
 134         xbt_mallocator_free(smpi_global->request_mallocator);
 135         xbt_mallocator_free(smpi_global->message_mallocator);
 136
 137         for(i = 0; i < size; i++) {
 138                 xbt_fifo_free(smpi_global->pending_send_request_queues[i]);
 139                 SIMIX_mutex_destroy(smpi_global->pending_send_request_queues_mutexes[i]);
 140                 xbt_fifo_free(smpi_global->pending_recv_request_queues[i]);
 141                 SIMIX_mutex_destroy(smpi_global->pending_recv_request_queues_mutexes[i]);
 142                 xbt_fifo_free(smpi_global->received_message_queues[i]);
 143                 SIMIX_mutex_destroy(smpi_global->received_message_queues_mutexes[i]);
 144                 xbt_os_timer_free(smpi_global->timers[i]);
 145                 SIMIX_mutex_destroy(smpi_global->timers_mutexes[i]);
 146         }
 147
 148         xbt_free(smpi_global->pending_send_request_queues);
 149         xbt_free(smpi_global->pending_send_request_queues_mutexes);
 150         xbt_free(smpi_global->pending_recv_request_queues);
 151         xbt_free(smpi_global->pending_recv_request_queues_mutexes);
 152         xbt_free(smpi_global->received_message_queues);
 153         xbt_free(smpi_global->received_message_queues_mutexes);
 154         xbt_free(smpi_global->timers);
 155         xbt_free(smpi_global->timers_mutexes);
 156
 157         xbt_free(smpi_global);
 158
 159         smpi_global = NULL;
 160 }
 161
 162 int smpi_run_simulation(int argc, char **argv)
 163 {
 164         xbt_fifo_item_t cond_item   = NULL;
 165         smx_cond_t   cond           = NULL;
 166         xbt_fifo_item_t action_item = NULL;
 167         smx_action_t action         = NULL;
 168
 169         xbt_fifo_t   actions_failed = xbt_fifo_new();
 170         xbt_fifo_t   actions_done   = xbt_fifo_new();
 171
 172         srand(SMPI_RAND_SEED);
 173
 174         SIMIX_global_init(&argc, argv);
 175
 176         SIMIX_function_register("smpi_simulated_main", smpi_simulated_main);
 177         SIMIX_function_register("smpi_sender",         smpi_sender);
 178         SIMIX_function_register("smpi_receiver",       smpi_receiver);
 179
 180         // FIXME: ought to verify these files...
 181         SIMIX_create_environment(argv[1]);
 182
 183         // must initialize globals between creating environment and launching app....
 184         smpi_global_init();
 185
 186         SIMIX_launch_application(argv[2]);
 187
 188         /* Prepare to display some more info when dying on Ctrl-C pressing */
 189         // FIXME: doesn't work
 190         //signal(SIGINT, inthandler);
 191
 192         /* Clean IO before the run */
 193         fflush(stdout);
 194         fflush(stderr);
 195
 196         while (SIMIX_solve(actions_done, actions_failed) != -1.0) {
 197                 xbt_fifo_foreach(actions_failed, action_item, action, smx_action_t) {
 198                         DEBUG1("** %s failed **", action->name);
 199                         xbt_fifo_foreach(action->cond_list, cond_item, cond, smx_cond_t) {
 200                                 SIMIX_cond_broadcast(cond);
 201                         }
 202                 }
 203                 xbt_fifo_foreach(actions_done, action_item, action, smx_action_t) {
 204                         DEBUG1("** %s done **",action->name);
 205                         xbt_fifo_foreach(action->cond_list, cond_item, cond, smx_cond_t) {
 206                                 SIMIX_cond_broadcast(cond);
 207                         }
 208                 }
 209         }
 210
 211         // FIXME: cleanup incomplete
 212         xbt_fifo_free(actions_failed);
 213         xbt_fifo_free(actions_done);
 214
 215         INFO1("simulation time %g", SIMIX_get_clock());
 216
 217         smpi_global_destroy();
 218
 219         SIMIX_clean();
 220
 221         return 0;
 222 }