Logo AND Algorithmique Numérique Distribuée

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