Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Add dev_guide mecanism
[simgrid.git] / src / smpi / smpi_global.c
1 /* Copyright (c) 2007, 2008, 2009, 2010. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5   * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #include <stdint.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10
11 #include "private.h"
12 #include "smpi_mpi_dt_private.h"
13 #include "mc/mc.h"
14 #include "surf/surf.h"
15 #include "simix/smx_private.h"
16
17
18 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_kernel, smpi,
19                                 "Logging specific to SMPI (kernel)");
20
21 typedef struct s_smpi_process_data {
22   int index;
23   int* argc;
24   char*** argv;
25   smx_rdv_t mailbox;
26   smx_rdv_t mailbox_small;
27   xbt_os_timer_t timer;
28   double simulated;
29   MPI_Comm comm_self;
30   void *data; /* user data */
31 } s_smpi_process_data_t;
32
33 static smpi_process_data_t *process_data = NULL;
34 static int process_count = 0;
35
36 MPI_Comm MPI_COMM_WORLD = MPI_COMM_NULL;
37
38 #define MAILBOX_NAME_MAXLEN (5 + sizeof(int) * 2 + 1)
39
40 static char* get_mailbox_name(char* str, int index) {
41   snprintf(str, MAILBOX_NAME_MAXLEN, "SMPI-%0*x", (int)(sizeof(int) * 2), index);
42   return str;
43 }
44
45 static char* get_mailbox_name_small(char* str, int index) {
46   snprintf(str, MAILBOX_NAME_MAXLEN, "small%0*x", (int)(sizeof(int) * 2), index);
47   return str;
48 }
49
50 void smpi_process_init(int *argc, char ***argv)
51 {
52   int index;
53   smpi_process_data_t data;
54   smx_process_t proc;
55
56   if(argc && argv) {
57     proc = SIMIX_process_self();
58     index = atoi((*argv)[1]);
59     data = smpi_process_remote_data(index);
60     simcall_process_set_data(proc, data);
61     if (*argc > 2) {
62       free((*argv)[1]);
63       memmove(&(*argv)[1], &(*argv)[2], sizeof(char *) * (*argc - 2));
64       (*argv)[(*argc) - 1] = NULL;
65     }
66     (*argc)--;
67     data->argc = argc;
68     data->argv = argv;
69     simcall_rdv_set_receiver(data->mailbox_small, proc);// set the process attached to the mailbox
70     XBT_DEBUG("<%d> New process in the game: %p", index, proc);
71   }
72 }
73
74 void smpi_process_destroy(void)
75 {
76   int index = smpi_process_index();
77
78   XBT_DEBUG("<%d> Process left the game", index);
79 }
80
81 /**
82  * @brief Prepares the current process for termination.
83  */
84 void smpi_process_finalize(void)
85 {
86   // wait for all pending asynchronous comms to finish
87   while (SIMIX_process_has_pending_comms(SIMIX_process_self())) {
88     simcall_process_sleep(0.01);
89   }
90 }
91
92 #ifdef SMPI_F2C
93 int smpi_process_argc(void) {
94   smpi_process_data_t data = smpi_process_data();
95
96   return data->argc ? *(data->argc) - 1 : 0;
97 }
98
99 int smpi_process_getarg(integer* index, char* dst, ftnlen len) {
100   smpi_process_data_t data = smpi_process_data();
101   char* arg;
102   ftnlen i;
103
104   if(!data->argc || !data->argv
105      || *index < 1 || *index >= *(data->argc)) {
106     return -1;
107   }
108   arg = (*data->argv)[*index];
109   for(i = 0; i < len && arg[i] != '\0'; i++) {
110     dst[i] = arg[i];
111   }
112   for(; i < len; i++) {
113     dst[i] = ' ';
114   }
115   return 0;
116 }
117
118 int smpi_global_size(void) {
119    char* value = getenv("SMPI_GLOBAL_SIZE");
120
121    if(!value) {
122      fprintf(stderr, "Please set env var SMPI_GLOBAL_SIZE to expected number of processes.\n");
123      xbt_abort();
124    }
125    return atoi(value);
126 }
127 #endif
128
129 smpi_process_data_t smpi_process_data(void)
130 {
131   return SIMIX_process_self_get_data(SIMIX_process_self());
132 }
133
134 smpi_process_data_t smpi_process_remote_data(int index)
135 {
136   return process_data[index];
137 }
138
139 void smpi_process_set_user_data(void *data)
140 {
141   smpi_process_data_t process_data = smpi_process_data();
142   process_data->data = data;
143 }
144
145 void* smpi_process_get_user_data(){
146   smpi_process_data_t process_data = smpi_process_data();
147   return process_data->data;
148 }
149
150 int smpi_process_count(void)
151 {
152   return process_count;
153 }
154
155 int smpi_process_index(void)
156 {
157   smpi_process_data_t data = smpi_process_data();
158
159   return data->index;
160 }
161
162 smx_rdv_t smpi_process_mailbox(void) {
163   smpi_process_data_t data = smpi_process_data();
164
165   return data->mailbox;
166 }
167
168 smx_rdv_t smpi_process_mailbox_small(void) {
169   smpi_process_data_t data = smpi_process_data();
170
171   return data->mailbox_small;
172 }
173
174 smx_rdv_t smpi_process_remote_mailbox(int index) {
175   smpi_process_data_t data = smpi_process_remote_data(index);
176
177   return data->mailbox;
178 }
179
180
181 smx_rdv_t smpi_process_remote_mailbox_small(int index) {
182   smpi_process_data_t data = smpi_process_remote_data(index);
183
184   return data->mailbox_small;
185 }
186
187 xbt_os_timer_t smpi_process_timer(void)
188 {
189   smpi_process_data_t data = smpi_process_data();
190
191   return data->timer;
192 }
193
194 void smpi_process_simulated_start(void) {
195   smpi_process_data_t data = smpi_process_data();
196
197   data->simulated = SIMIX_get_clock();
198 }
199
200 double smpi_process_simulated_elapsed(void) {
201   smpi_process_data_t data = smpi_process_data();
202
203   return SIMIX_get_clock() - data->simulated;
204 }
205
206 MPI_Comm smpi_process_comm_self(void) {
207   smpi_process_data_t data = smpi_process_data();
208
209   return data->comm_self;
210 }
211
212 void print_request(const char *message, MPI_Request request) {
213   XBT_DEBUG("%s  request %p  [buf = %p, size = %zu, src = %d, dst = %d, tag = %d, flags = %x]",
214          message, request, request->buf, request->size,
215          request->src, request->dst, request->tag, request->flags);
216 }
217
218 static void SMPI_comm_copy_buffer_callback(smx_action_t comm, void* buff, size_t buff_size)
219 {
220   XBT_DEBUG("Copy the data over");
221   memcpy(comm->comm.dst_buff, buff, buff_size);
222   if (comm->comm.detached) { // if this is a detached send, the source buffer was duplicated by SMPI sender to make the original buffer available to the application ASAP
223     xbt_free(buff);
224     //It seems that the request is used after the call there this should
225     //be free somewhereelse  but where???
226     //xbt_free(comm->comm.src_data);// inside SMPI the request is keep
227     //inside the user data and should be free 
228     comm->comm.src_buff = NULL;
229   }
230 }
231
232 void smpi_global_init(void)
233 {
234   int i;
235   MPI_Group group;
236   char name[MAILBOX_NAME_MAXLEN];
237
238   SIMIX_comm_set_copy_data_callback(&SMPI_comm_copy_buffer_callback);
239   process_count = SIMIX_process_count();
240   process_data = xbt_new(smpi_process_data_t, process_count);
241   for (i = 0; i < process_count; i++) {
242     process_data[i] = xbt_new(s_smpi_process_data_t, 1);
243     process_data[i]->index = i;
244     process_data[i]->argc = NULL;
245     process_data[i]->argv = NULL;
246     process_data[i]->mailbox = simcall_rdv_create(get_mailbox_name(name, i));
247     process_data[i]->mailbox_small = simcall_rdv_create(get_mailbox_name_small(name, i));
248     process_data[i]->timer = xbt_os_timer_new();
249     group = smpi_group_new(1);
250     process_data[i]->comm_self = smpi_comm_new(group);
251     smpi_group_set_mapping(group, i, 0);
252   }
253   group = smpi_group_new(process_count);
254   MPI_COMM_WORLD = smpi_comm_new(group);
255   for (i = 0; i < process_count; i++) {
256     smpi_group_set_mapping(group, i, i);
257   }
258 }
259
260 void smpi_global_destroy(void)
261 {
262   int count = smpi_process_count();
263   int i;
264
265   smpi_bench_destroy();
266   smpi_comm_destroy(MPI_COMM_WORLD);
267   MPI_COMM_WORLD = MPI_COMM_NULL;
268   for (i = 0; i < count; i++) {
269     smpi_comm_destroy(process_data[i]->comm_self);
270     xbt_os_timer_free(process_data[i]->timer);
271     simcall_rdv_destroy(process_data[i]->mailbox);
272     simcall_rdv_destroy(process_data[i]->mailbox_small);
273     xbt_free(process_data[i]);
274   }
275   xbt_free(process_data);
276   process_data = NULL;
277
278   smpi_free_static();
279 }
280
281 /* Fortran specific stuff */
282 /* With smpicc, the following weak symbols are used */
283 /* With smpiff, the following weak symbols are replaced by those in libf2c */
284 int __attribute__((weak)) xargc;
285 char** __attribute__((weak)) xargv;
286
287 int __attribute__((weak)) main(int argc, char** argv) {
288    xargc = argc;
289    xargv = argv;
290    return MAIN__();
291 }
292
293 #ifdef WIN32
294 #include <windows.h>
295
296 int __attribute__((weak)) smpi_simulated_main(int argc, char** argv) {
297   xbt_die("Should not be in this smpi_simulated_main");
298   return 1;
299 }
300
301 /* TODO FOR WIN32 */
302 /* Dummy prototype to make gcc happy */
303 int APIENTRY WinMain(HINSTANCE hInst,HINSTANCE hInst2,LPSTR lpstr01,int nCmdShow)
304 {
305         return MAIN__();
306 }
307
308 #endif
309
310 int MAIN__(void)
311 {
312   srand(SMPI_RAND_SEED);
313
314   if(getenv("SMPI_PRETEND_CC") != NULL) {
315   /* Hack to ensure that smpicc can pretend to be a simple compiler. Particularly handy to pass it to the configuration tools */
316     return 0;
317   }
318
319   /* Connect log categories.  See xbt/log.c */
320   XBT_LOG_CONNECT(smpi);  /* Keep this line as soon as possible in this function: xbt_log_appender_file.c depends on it
321                              DO NOT connect this in XBT or so, or it will be useless to xbt_log_appender_file.c */
322   XBT_LOG_CONNECT(smpi_base);
323   XBT_LOG_CONNECT(smpi_bench);
324   XBT_LOG_CONNECT(smpi_coll);
325   XBT_LOG_CONNECT(smpi_comm);
326   XBT_LOG_CONNECT(smpi_group);
327   XBT_LOG_CONNECT(smpi_kernel);
328   XBT_LOG_CONNECT(smpi_mpi);
329   XBT_LOG_CONNECT(smpi_mpi_dt);
330   XBT_LOG_CONNECT(smpi_pmpi);
331   XBT_LOG_CONNECT(smpi_replay);
332
333 #ifdef HAVE_TRACING
334   TRACE_global_init(&xargc, xargv);
335 #endif
336
337   SIMIX_global_init(&xargc, xargv);
338
339 #ifdef HAVE_TRACING
340   TRACE_start();
341 #endif
342
343   // parse the platform file: get the host list
344   SIMIX_create_environment(xargv[1]);
345
346   SIMIX_function_register_default(smpi_simulated_main);
347   SIMIX_launch_application(xargv[2]);
348
349   smpi_global_init();
350
351   /* Clean IO before the run */
352   fflush(stdout);
353   fflush(stderr);
354
355   if (MC_is_active())
356     MC_modelcheck();
357   else
358     SIMIX_run();
359
360   if (xbt_cfg_get_int(_surf_cfg_set, "smpi/display_timing"))
361     XBT_INFO("Simulation time: %g seconds.", SIMIX_get_clock());
362
363   smpi_global_destroy();
364
365 #ifdef HAVE_TRACING
366   TRACE_end();
367 #endif
368
369   return 0;
370 }