Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
00f5105b2dfe5b19d5df53787aa10ea28e5d08da
[simgrid.git] / src / msg / msg_io.cpp
1 /* Copyright (c) 2004-2016. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "simgrid/s4u/host.hpp"
7 #include "src/msg/msg_private.h"
8 #include <numeric>
9
10 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_io, msg, "Logging specific to MSG (io)");
11
12 SG_BEGIN_DECL()
13
14 /** @addtogroup msg_file
15  * (#msg_file_t) and the functions for managing it.
16  *
17  *  \see #msg_file_t
18  */
19
20 /********************************* File **************************************/
21 void __MSG_file_get_info(msg_file_t fd){
22
23   msg_file_priv_t priv = MSG_file_priv(fd);
24   xbt_dynar_t info = simcall_file_get_info(priv->simdata->smx_file);
25   sg_size_t *psize;
26
27   priv->content_type = xbt_dynar_pop_as(info, char *);
28   priv->storage_type = xbt_dynar_pop_as(info, char *);
29   priv->storageId = xbt_dynar_pop_as(info, char *);
30   priv->mount_point = xbt_dynar_pop_as(info, char *);
31   psize = xbt_dynar_pop_as(info, sg_size_t*);
32   priv->size = *psize;
33   xbt_free(psize);
34   xbt_dynar_free_container(&info);
35 }
36
37 static int MSG_host_get_file_descriptor_id(msg_host_t host)
38 {
39   simgrid::MsgHostExt* priv = host->extension<simgrid::MsgHostExt>();
40   if (priv->file_descriptor_table == nullptr) {
41     priv->file_descriptor_table = new std::vector<int>(sg_storage_max_file_descriptors);
42     std::iota(priv->file_descriptor_table->rbegin(), priv->file_descriptor_table->rend(), 0); // Fill with ..., 1, 0.
43   }
44   xbt_assert(!priv->file_descriptor_table->empty(), "Too much files are opened! Some have to be closed.");
45   int desc = priv->file_descriptor_table->back();
46   priv->file_descriptor_table->pop_back();
47   return desc;
48 }
49
50 static void MSG_host_release_file_descriptor_id(msg_host_t host, int id)
51 {
52   host->extension<simgrid::MsgHostExt>()->file_descriptor_table->push_back(id);
53 }
54
55 /** \ingroup msg_file
56  *
57  * \brief Set the user data of a #msg_file_t.
58  *
59  * This functions attach \a data to \a file.
60  */
61 msg_error_t MSG_file_set_data(msg_file_t fd, void *data)
62 {
63   msg_file_priv_t priv = MSG_file_priv(fd);
64   priv->data = data;
65   return MSG_OK;
66 }
67
68 /** \ingroup msg_file
69  *
70  * \brief Return the user data of a #msg_file_t.
71  *
72  * This functions checks whether \a file is a valid pointer and return the user data associated to \a file if possible.
73  */
74 void *MSG_file_get_data(msg_file_t fd)
75 {
76   msg_file_priv_t priv = MSG_file_priv(fd);
77   return priv->data;
78 }
79
80 /** \ingroup msg_file
81  * \brief Display information related to a file descriptor
82  *
83  * \param fd is a the file descriptor
84  */
85 void MSG_file_dump (msg_file_t fd){
86   /* Update the cached information first */
87   __MSG_file_get_info(fd);
88
89   msg_file_priv_t priv = MSG_file_priv(fd);
90   XBT_INFO("File Descriptor information:\n"
91            "\t\tFull path: '%s'\n"
92            "\t\tSize: %llu\n"
93            "\t\tMount point: '%s'\n"
94            "\t\tStorage Id: '%s'\n"
95            "\t\tStorage Type: '%s'\n"
96            "\t\tContent Type: '%s'\n"
97            "\t\tFile Descriptor Id: %d",
98            priv->fullpath, priv->size, priv->mount_point,
99            priv->storageId, priv->storage_type,
100            priv->content_type, priv->desc_id);
101 }
102
103 /** \ingroup msg_file
104  * \brief Read a file (local or remote)
105  *
106  * \param size of the file to read
107  * \param fd is a the file descriptor
108  * \return the number of bytes successfully read or -1 if an error occurred
109  */
110 sg_size_t MSG_file_read(msg_file_t fd, sg_size_t size)
111 {
112   msg_file_priv_t file_priv = MSG_file_priv(fd);
113   sg_size_t read_size;
114
115   if (file_priv->size == 0) /* Nothing to read, return */
116     return 0;
117
118   /* Find the host where the file is physically located and read it */
119   msg_storage_t storage_src = static_cast<msg_storage_t>(xbt_lib_get_elm_or_null(storage_lib, file_priv->storageId));
120   msg_storage_priv_t storage_priv_src = MSG_storage_priv(storage_src);
121   msg_host_t attached_host = MSG_host_by_name(storage_priv_src->hostname);
122   read_size = simcall_file_read(file_priv->simdata->smx_file, size, attached_host);
123
124   if (strcmp(storage_priv_src->hostname, MSG_host_self()->cname())) {
125     /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
126     XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", storage_priv_src->hostname, read_size);
127     msg_host_t *m_host_list = nullptr;
128     m_host_list = xbt_new0(msg_host_t, 2);
129
130     m_host_list[0] = MSG_host_self();
131     m_host_list[1] = attached_host;
132     double flops_amount[] = { 0, 0};
133     double bytes_amount[] = { 0, 0, static_cast<double>(read_size), 0 };
134
135     msg_task_t task = MSG_parallel_task_create("file transfer for read", 2, m_host_list, flops_amount, bytes_amount,
136                       nullptr);
137     msg_error_t transfer = MSG_parallel_task_execute(task);
138     MSG_task_destroy(task);
139     xbt_free(m_host_list);
140     if(transfer != MSG_OK){
141       if (transfer == MSG_HOST_FAILURE)
142         XBT_WARN("Transfer error, %s remote host just turned off!", attached_host->cname());
143       if (transfer == MSG_TASK_CANCELED)
144         XBT_WARN("Transfer error, task has been canceled!");
145
146       return -1;
147     }
148   }
149   return read_size;
150 }
151
152 /** \ingroup msg_file
153  * \brief Write into a file (local or remote)
154  *
155  * \param size of the file to write
156  * \param fd is a the file descriptor
157  * \return the number of bytes successfully write or -1 if an error occurred
158  */
159 sg_size_t MSG_file_write(msg_file_t fd, sg_size_t size)
160 {
161   msg_file_priv_t file_priv = MSG_file_priv(fd);
162
163   if (size == 0) /* Nothing to write, return */
164     return 0;
165
166   /* Find the host where the file is physically located (remote or local)*/
167   msg_storage_t storage_src = static_cast<msg_storage_t>(xbt_lib_get_elm_or_null(storage_lib, file_priv->storageId));
168   msg_storage_priv_t storage_priv_src = MSG_storage_priv(storage_src);
169   msg_host_t attached_host = MSG_host_by_name(storage_priv_src->hostname);
170
171   if (strcmp(storage_priv_src->hostname, MSG_host_self()->cname())) {
172     /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
173     XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", storage_priv_src->hostname, size);
174     msg_host_t *m_host_list = nullptr;
175     m_host_list = xbt_new0(msg_host_t, 2);
176
177     m_host_list[0] = MSG_host_self();
178     m_host_list[1] = attached_host;
179     double flops_amount[] = { 0, 0 };
180     double bytes_amount[] = { 0, static_cast<double>(size), 0, 0 };
181
182     msg_task_t task = MSG_parallel_task_create("file transfer for write", 2, m_host_list, flops_amount, bytes_amount,
183                                                nullptr);
184     msg_error_t transfer = MSG_parallel_task_execute(task);
185     MSG_task_destroy(task);
186     free(m_host_list);
187     if(transfer != MSG_OK){
188       if (transfer == MSG_HOST_FAILURE)
189         XBT_WARN("Transfer error, %s remote host just turned off!", attached_host->cname());
190       if (transfer == MSG_TASK_CANCELED)
191         XBT_WARN("Transfer error, task has been canceled!");
192
193       return -1;
194     }
195   }
196   /* Write file on local or remote host */
197   sg_size_t offset = simcall_file_tell(file_priv->simdata->smx_file);
198   sg_size_t write_size = simcall_file_write(file_priv->simdata->smx_file, size, attached_host);
199   file_priv->size = offset+write_size;
200
201   return write_size;
202 }
203
204 /** \ingroup msg_file
205  * \brief Opens the file whose name is the string pointed to by path
206  *
207  * \param fullpath is the file location on the storage
208  * \param data user data to attach to the file
209  *
210  * \return An #msg_file_t associated to the file
211  */
212 msg_file_t MSG_file_open(const char* fullpath, void* data)
213 {
214   char *name;
215   msg_file_priv_t priv = xbt_new(s_msg_file_priv_t, 1);
216   priv->data = data;
217   priv->fullpath = xbt_strdup(fullpath);
218   priv->simdata = xbt_new0(s_simdata_file_t,1);
219   priv->simdata->smx_file = simcall_file_open(fullpath, MSG_host_self());
220   priv->desc_id           = MSG_host_get_file_descriptor_id(MSG_host_self());
221
222   name = bprintf("%s:%s:%d", priv->fullpath, MSG_host_self()->cname(), priv->desc_id);
223
224   xbt_lib_set(file_lib, name, MSG_FILE_LEVEL, priv);
225   msg_file_t fd = static_cast<msg_file_t>(xbt_lib_get_elm_or_null(file_lib, name));
226   __MSG_file_get_info(fd);
227   xbt_free(name);
228
229   return fd;
230 }
231
232 /** \ingroup msg_file
233  * \brief Close the file
234  *
235  * \param fd is the file to close
236  * \return 0 on success or 1 on error
237  */
238 int MSG_file_close(msg_file_t fd)
239 {
240   char *name;
241   msg_file_priv_t priv = MSG_file_priv(fd);
242   if (priv->data)
243     xbt_free(priv->data);
244
245   int res = simcall_file_close(priv->simdata->smx_file, MSG_host_self());
246   name    = bprintf("%s:%s:%d", priv->fullpath, MSG_host_self()->cname(), priv->desc_id);
247   MSG_host_release_file_descriptor_id(MSG_host_self(), priv->desc_id);
248   xbt_lib_unset(file_lib, name, MSG_FILE_LEVEL, 1);
249   xbt_free(name);
250   return res;
251 }
252
253 /** \ingroup msg_file
254  * \brief Unlink the file pointed by fd
255  *
256  * \param fd is the file descriptor (#msg_file_t)
257  * \return 0 on success or 1 on error
258  */
259 msg_error_t MSG_file_unlink(msg_file_t fd)
260 {
261   msg_file_priv_t file_priv = MSG_file_priv(fd);
262   /* Find the host where the file is physically located (remote or local)*/
263   msg_storage_t storage_src = static_cast<msg_storage_t>(xbt_lib_get_elm_or_null(storage_lib, file_priv->storageId));
264   msg_storage_priv_t storage_priv_src = MSG_storage_priv(storage_src);
265   msg_host_t attached_host = MSG_host_by_name(storage_priv_src->hostname);
266   int res = simcall_file_unlink(file_priv->simdata->smx_file, attached_host);
267   return static_cast<msg_error_t>(res);
268 }
269
270 /** \ingroup msg_file
271  * \brief Return the size of a file
272  *
273  * \param fd is the file descriptor (#msg_file_t)
274  * \return the size of the file (as a #sg_size_t)
275  */
276 sg_size_t MSG_file_get_size(msg_file_t fd){
277   msg_file_priv_t priv = MSG_file_priv(fd);
278   return simcall_file_get_size(priv->simdata->smx_file);
279 }
280
281 /**
282  * \ingroup msg_file
283  * \brief Set the file position indicator in the msg_file_t by adding offset bytes
284  * to the position specified by origin (either SEEK_SET, SEEK_CUR, or SEEK_END).
285  *
286  * \param fd : file object that identifies the stream
287  * \param offset : number of bytes to offset from origin
288  * \param origin : Position used as reference for the offset. It is specified by one of the following constants defined
289  *                 in \<stdio.h\> exclusively to be used as arguments for this function (SEEK_SET = beginning of file,
290  *                 SEEK_CUR = current position of the file pointer, SEEK_END = end of file)
291  * \return If successful, the function returns MSG_OK (=0). Otherwise, it returns MSG_TASK_CANCELED (=8).
292  */
293 msg_error_t MSG_file_seek(msg_file_t fd, sg_offset_t offset, int origin)
294 {
295   msg_file_priv_t priv = MSG_file_priv(fd);
296   return static_cast<msg_error_t>(simcall_file_seek(priv->simdata->smx_file, offset, origin));
297 }
298
299 /**
300  * \ingroup msg_file
301  * \brief Returns the current value of the position indicator of the file
302  *
303  * \param fd : file object that identifies the stream
304  * \return On success, the current value of the position indicator is returned.
305  *
306  */
307 sg_size_t MSG_file_tell(msg_file_t fd)
308 {
309   msg_file_priv_t priv = MSG_file_priv(fd);
310   return simcall_file_tell(priv->simdata->smx_file);
311 }
312
313 const char *MSG_file_get_name(msg_file_t fd) {
314   xbt_assert((fd != nullptr), "Invalid parameters");
315   msg_file_priv_t priv = MSG_file_priv(fd);
316   return priv->fullpath;
317 }
318
319 /**
320  * \ingroup msg_file
321  * \brief Move a file to another location on the *same mount point*.
322  *
323  */
324 msg_error_t MSG_file_move (msg_file_t fd, const char* fullpath)
325 {
326   msg_file_priv_t priv = MSG_file_priv(fd);
327   return static_cast<msg_error_t>(simcall_file_move(priv->simdata->smx_file, fullpath));
328 }
329
330 /**
331  * \ingroup msg_file
332  * \brief Copy a file to another location on a remote host.
333  * \param file : the file to move
334  * \param host : the remote host where the file has to be copied
335  * \param fullpath : the complete path destination on the remote host
336  * \return If successful, the function returns MSG_OK. Otherwise, it returns MSG_TASK_CANCELED.
337  */
338 msg_error_t MSG_file_rcopy (msg_file_t file, msg_host_t host, const char* fullpath)
339 {
340   msg_file_priv_t file_priv = MSG_file_priv(file);
341   sg_size_t read_size;
342
343   /* Find the host where the file is physically located and read it */
344   msg_storage_t storage_src = static_cast<msg_storage_t>(xbt_lib_get_elm_or_null(storage_lib, file_priv->storageId));
345   msg_storage_priv_t storage_priv_src = MSG_storage_priv(storage_src);
346   msg_host_t attached_host = MSG_host_by_name(storage_priv_src->hostname);
347   MSG_file_seek(file, 0, SEEK_SET);
348   read_size = simcall_file_read(file_priv->simdata->smx_file, file_priv->size, attached_host);
349
350   /* Find the real host destination where the file will be physically stored */
351   xbt_dict_cursor_t cursor = nullptr;
352   msg_storage_t storage_dest = nullptr;
353   msg_host_t host_dest;
354   size_t longest_prefix_length = 0;
355
356   xbt_dict_t storage_list = host->mountedStoragesAsDict();
357   char *mount_name;
358   char *storage_name;
359   xbt_dict_foreach(storage_list,cursor,mount_name,storage_name){
360     char* file_mount_name = static_cast<char *>(xbt_malloc ((strlen(mount_name)+1)));
361     strncpy(file_mount_name,fullpath,strlen(mount_name)+1);
362     file_mount_name[strlen(mount_name)] = '\0';
363
364     if(!strcmp(file_mount_name,mount_name) && strlen(mount_name)>longest_prefix_length){
365       /* The current mount name is found in the full path and is bigger than the previous*/
366       longest_prefix_length = strlen(mount_name);
367       storage_dest = (msg_storage_t) xbt_lib_get_elm_or_null(storage_lib, storage_name);
368     }
369     xbt_free(file_mount_name);
370   }
371   xbt_dict_free(&storage_list);
372
373   char* host_name_dest = nullptr;
374   if(longest_prefix_length>0){
375     /* Mount point found, retrieve the host the storage is attached to */
376     msg_storage_priv_t storage_dest_priv = MSG_storage_priv(storage_dest);
377     host_name_dest = (char*)storage_dest_priv->hostname;
378     host_dest = MSG_host_by_name(host_name_dest);
379   }else{
380     XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->cname());
381     return MSG_TASK_CANCELED;
382   }
383
384   XBT_DEBUG("Initiate data transfer of %llu bytes between %s and %s.", read_size, storage_priv_src->hostname,
385             host_name_dest);
386   msg_host_t *m_host_list = nullptr;
387   m_host_list = xbt_new0(msg_host_t, 2);
388
389   m_host_list[0] = attached_host;
390   m_host_list[1] = host_dest;
391   double flops_amount[] = { 0, 0 };
392   double bytes_amount[] = { 0, static_cast<double>(read_size), 0, 0 };
393
394   msg_task_t task =
395       MSG_parallel_task_create("file transfer for write", 2, m_host_list, flops_amount, bytes_amount, nullptr);
396   msg_error_t transfer = MSG_parallel_task_execute(task);
397   MSG_task_destroy(task);
398   xbt_free(m_host_list);
399   if(transfer != MSG_OK){
400     if (transfer == MSG_HOST_FAILURE)
401       XBT_WARN("Transfer error, %s remote host just turned off!", host_name_dest);
402     if (transfer == MSG_TASK_CANCELED)
403       XBT_WARN("Transfer error, task has been canceled!");
404
405     return transfer;
406   }
407
408   /* Create file on remote host, write it and close it */
409   smx_file_t smx_file = simcall_file_open(fullpath, host_dest);
410   simcall_file_write(smx_file, read_size, host_dest);
411   simcall_file_close(smx_file, host_dest);
412   return MSG_OK;
413 }
414
415 /**
416  * \ingroup msg_file
417  * \brief Move a file to another location on a remote host.
418  * \param file : the file to move
419  * \param host : the remote host where the file has to be moved
420  * \param fullpath : the complete path destination on the remote host
421  * \return If successful, the function returns MSG_OK. Otherwise, it returns MSG_TASK_CANCELED.
422  */
423 msg_error_t MSG_file_rmove (msg_file_t file, msg_host_t host, const char* fullpath)
424 {
425   msg_error_t res = MSG_file_rcopy(file, host, fullpath);
426   MSG_file_unlink(file);
427   return res;
428 }
429
430 /**
431  * \brief Destroys a file (internal call only)
432  */
433 void __MSG_file_destroy(msg_file_priv_t file) {
434   xbt_free(file->fullpath);
435   xbt_free(file->simdata);
436   xbt_free(file);
437 }
438
439 /********************************* Storage **************************************/
440 /** @addtogroup msg_storage_management
441  * (#msg_storage_t) and the functions for managing it.
442  */
443
444 msg_storage_t __MSG_storage_create(smx_storage_t storage)
445 {
446   const char* name                   = SIMIX_storage_get_name(storage);
447   msg_storage_priv_t storage_private = xbt_new0(s_msg_storage_priv_t, 1);
448
449   storage_private->hostname = SIMIX_storage_get_host(storage);
450   storage_private->size     = SIMIX_storage_get_size(storage);
451
452   xbt_lib_set(storage_lib,name,MSG_STORAGE_LEVEL,storage_private);
453   return xbt_lib_get_elm_or_null(storage_lib, name);
454 }
455
456 /**
457  * \brief Destroys a storage (internal call only)
458  */
459 void __MSG_storage_destroy(msg_storage_priv_t storage) {
460   free(storage);
461 }
462
463 /** \ingroup msg_storage_management
464  *
465  * \brief Returns the name of the #msg_storage_t.
466  *
467  * This functions checks whether a storage is a valid pointer or not and return its name.
468  */
469 const char *MSG_storage_get_name(msg_storage_t storage) {
470   xbt_assert((storage != nullptr), "Invalid parameters");
471   return SIMIX_storage_get_name(storage);
472 }
473
474 /** \ingroup msg_storage_management
475  * \brief Returns the free space size of a storage element
476  * \param storage a storage
477  * \return the free space size of the storage element (as a #sg_size_t)
478  */
479 sg_size_t MSG_storage_get_free_size(msg_storage_t storage){
480   return simcall_storage_get_free_size(storage);
481 }
482
483 /** \ingroup msg_storage_management
484  * \brief Returns the used space size of a storage element
485  * \param storage a storage
486  * \return the used space size of the storage element (as a #sg_size_t)
487  */
488 sg_size_t MSG_storage_get_used_size(msg_storage_t storage){
489   return simcall_storage_get_used_size(storage);
490 }
491
492 /** \ingroup msg_storage_management
493  * \brief Returns a xbt_dict_t consisting of the list of properties assigned to this storage
494  * \param storage a storage
495  * \return a dict containing the properties
496  */
497 xbt_dict_t MSG_storage_get_properties(msg_storage_t storage)
498 {
499   xbt_assert((storage != nullptr), "Invalid parameters (storage is nullptr)");
500   return (simcall_storage_get_properties(storage));
501 }
502
503 /** \ingroup msg_storage_management
504  * \brief Change the value of a given storage property
505  *
506  * \param storage a storage
507  * \param name a property name
508  * \param value what to change the property to
509  */
510 void MSG_storage_set_property_value(msg_storage_t storage, const char* name, char* value)
511 {
512   xbt_dict_set(MSG_storage_get_properties(storage), name, value, nullptr);
513 }
514
515 /** \ingroup m_storage_management
516  * \brief Returns the value of a given storage property
517  *
518  * \param storage a storage
519  * \param name a property name
520  * \return value of a property (or nullptr if property not set)
521  */
522 const char *MSG_storage_get_property_value(msg_storage_t storage, const char *name)
523 {
524   return static_cast<char*>(xbt_dict_get_or_null(MSG_storage_get_properties(storage), name));
525 }
526
527 /** \ingroup msg_storage_management
528  * \brief Finds a msg_storage_t using its name.
529  * \param name the name of a storage
530  * \return the corresponding storage
531  */
532 msg_storage_t MSG_storage_get_by_name(const char *name)
533 {
534   return static_cast<msg_storage_t>(xbt_lib_get_elm_or_null(storage_lib,name));
535 }
536
537 /** \ingroup msg_storage_management
538  * \brief Returns a dynar containing all the storage elements declared at a given point of time
539  */
540 xbt_dynar_t MSG_storages_as_dynar() {
541   xbt_lib_cursor_t cursor;
542   char *key;
543   void **data;
544   xbt_dynar_t res = xbt_dynar_new(sizeof(msg_storage_t),nullptr);
545
546   xbt_lib_foreach(storage_lib, cursor, key, data) {
547     if(xbt_lib_get_level(xbt_lib_get_elm_or_null(storage_lib, key), MSG_STORAGE_LEVEL) != nullptr) {
548       xbt_dictelm_t elm = xbt_dict_cursor_get_elm(cursor);
549       xbt_dynar_push(res, &elm);
550     }
551   }
552   return res;
553 }
554
555 /** \ingroup msg_storage_management
556  *
557  * \brief Set the user data of a #msg_storage_t.
558  * This functions attach \a data to \a storage if possible.
559  */
560 msg_error_t MSG_storage_set_data(msg_storage_t storage, void *data)
561 {
562   msg_storage_priv_t priv = MSG_storage_priv(storage);
563   priv->data = data;
564   return MSG_OK;
565 }
566
567 /** \ingroup m_host_management
568  *
569  * \brief Returns the user data of a #msg_storage_t.
570  *
571  * This functions checks whether \a storage is a valid pointer and returns its associate user data if possible.
572  */
573 void *MSG_storage_get_data(msg_storage_t storage)
574 {
575   xbt_assert((storage != nullptr), "Invalid parameters");
576   msg_storage_priv_t priv = MSG_storage_priv(storage);
577   return priv->data;
578 }
579
580 /** \ingroup msg_storage_management
581  *
582  * \brief Returns the content (file list) of a #msg_storage_t.
583  * \param storage a storage
584  * \return The content of this storage element as a dict (full path file => size)
585  */
586 xbt_dict_t MSG_storage_get_content(msg_storage_t storage)
587 {
588   return SIMIX_storage_get_content(storage);
589 }
590
591 /** \ingroup msg_storage_management
592  *
593  * \brief Returns the size of a #msg_storage_t.
594  * \param storage a storage
595  * \return The size of the storage
596  */
597 sg_size_t MSG_storage_get_size(msg_storage_t storage)
598 {
599   msg_storage_priv_t priv = MSG_storage_priv(storage);
600   return priv->size;
601 }
602
603 /** \ingroup msg_storage_management
604  *
605  * \brief Returns the host name the storage is attached to
606  *
607  * This functions checks whether a storage is a valid pointer or not and return its name.
608  */
609 const char *MSG_storage_get_host(msg_storage_t storage) {
610   xbt_assert((storage != nullptr), "Invalid parameters");
611   msg_storage_priv_t priv = MSG_storage_priv(storage);
612   return priv->hostname;
613 }
614
615 SG_END_DECL()