src/modules.doc

   1 /** \defgroup SimGrid_API  API of SimGrid */
   2
   3 /** \defgroup XBT_API      API of the toolbox (FIFO, hashtables, macros...)
   4     \ingroup SimGrid_API
   5 */
   6     /** \defgroup XBT_context User-level context library
   7      *  \ingroup XBT_API
   8      *  \brief This section describes how to use high-level functions
   9      *  (as opposed to <tt>setjump/longjmp</tt>) to schedule non-preemptible
  10      *  threads.
  11      */
  12     /** \defgroup XBT_dict A generic dictionnary
  13      *  \ingroup XBT_API
  14      *  \brief This section describes the API to a dictionnary structure that
  15      *  associates as string to a void* key. It is not a hash table and the
  16      *  internal data-structure rather looks like a tree.
  17      */
  18     /** \defgroup XBT_dynar A generic dynamic array
  19      *  \ingroup XBT_API
  20      *  \brief This section describes the API to generic dynamic array (vector).
  21      */
  22     /** \defgroup XBT_error Error tracking support.
  23      *  \ingroup XBT_API
  24      *  \brief This section describes a set of macros used to handle errors easily.
  25      */
  26     /** \defgroup XBT_fifo A generic workqueue
  27      *  \ingroup XBT_API
  28      *  \brief This section describes the API to generic workqueue. These functions
  29      *   provide the same kind of functionnality as dynamic arrays but in time O(1).
  30      *   However these functions use malloc/free a way too much often.
  31      */
  32     /** \defgroup XBT_set A generic set datatype
  33      *  \ingroup XBT_API
  34      *  \brief A data container consisting in \ref XBT_dict and \ref XBT_dynar
  35      */
  36     /** \defgroup XBT_swag A specific set datatype
  37      *  \ingroup XBT_API
  38      *  \brief Warning, this module is done to be efficient and performs tons of
  39      *  cast and dirty things. So avoid using it unless you really know
  40      *  what you are doing. It is basically a fifo but with restrictions so that
  41      *  it can be used as a set. Any operation (add, remove, belongs) is O(1) and
  42      *  no call to malloc/free is done.
  43      */
  44     /** \defgroup XBT_heap A generic heap data structure
  45      *  \ingroup XBT_API
  46      *  \brief This section describes the API to generic heap.
  47      */
  48     /** \defgroup XBT_log A generic logging facility in the spirit of log4j
  49      *  \ingroup XBT_API
  50      *  \brief This section describes the API to the log functions used
  51      *  everywhere in this project.
  52      */
  53     /** \defgroup XBT_sysdep All system dependency
  54      *  \ingroup XBT_API
  55      *  \brief This section describes many macros/functions that can serve as
  56      *  an OS abstraction.
  57      */
  58
  59
  60 /** \defgroup SURF_API       API of SURF
  61  *  \ingroup SimGrid_API
  62  *  \brief (Not documented yet).
  63  *
  64
  65  * SURF provides the core functionnalities to simulate a virtual
  66  * platform. It is very low-level and is not intended to be used as
  67  * such but rather to serve as a basis for higher-level simulators.
  68  * We're still working on it and the structure is a little bit complex.
  69  * So we'll document it only when we'll be completely satisfied of
  70  * the way it is organized.
  71  *
  72  * It is where platform models are encoded. If you need a model that is not
  73  * encoded yet, please tell me (<arnaud.legrand@imag.fr>) and we'll see if
  74  * it is feasible or not (hopefully it should be but who knows).
  75  */
  76
  77 /** \defgroup MSG_API      API of MSG
  78  *  \ingroup SimGrid_API
  79  */
  80     /** \defgroup m_datatypes_management MSG Data Types
  81      *  \ingroup MSG_API
  82      *  \brief This section describes the different datatypes provided by MSG.
  83      *
  84      */
  85
  86     /** \defgroup m_process_management Management Functions of Agents
  87      *  \ingroup MSG_API
  88      *  \brief This section describes the agent structure of MSG
  89      *  (#m_process_t) and the functions for managing it.
  90      *
  91      *  We need to simulate many independent scheduling decisions, so
  92      *  the concept of <em>process</em> is at the heart of the
  93      *  simulator. A process may be defined as a <em>code</em>, with
  94      *  some <em>private data</em>, executing in a <em>location</em>.
  95      *  \see m_process_t
  96      */
  97
  98     /** \defgroup m_host_management    Management Functions of Hosts
  99      *  \ingroup MSG_API
 100      *  \brief This section describes the host structure of MSG
 101      * (#m_host_t) and the functions for managing it.
 102      *
 103      *  A <em>location</em> (or <em>host</em>) is any possible place where
 104      *  a process may run. Thus it may be represented as a
 105      *  <em>physical resource with computing capabilities</em>, some
 106      *  <em>mailboxes</em> to enable running process to communicate with
 107      *  remote ones, and some <em>private data</em> that can be only
 108      *  accessed by local process.
 109      *  \see m_host_t
 110      */
 111
 112     /** \defgroup m_task_management    Management Functions of Tasks
 113      *  \ingroup MSG_API
 114      *  \brief This section describes the task structure of MSG
 115      *  (#m_task_t) and the functions for managing it.
 116      *
 117      *  Since most scheduling algorithms rely on a concept of task
 118      *  that can be either <em>computed</em> locally or
 119      *  <em>transferred</em> on another processor, it seems to be the
 120      *  right level of abstraction for our purposes. A <em>task</em>
 121      *  may then be defined by a <em>computing amount</em>, a
 122      *  <em>message size</em> and some <em>private data</em>.
 123      */
 124
 125     /** \defgroup msg_gos_functions    MSG Operating System Functions
 126      *  \ingroup MSG_API
 127      *  \brief This section describes the functions that can be used
 128      *  by an agent for handling some task.
 129      */
 130
 131     /** \defgroup m_channel_management    Understanding channels
 132      *  \ingroup MSG_API
 133      *  \brief This section briefly describes the channel notion of MSG
 134      *  (#m_channel_t).
 135      *
 136      *  For convenience, the simulator provides the notion of channel
 137      *  that is close to the tag notion in MPI. A channel is not a
 138      *  socket. It doesn't need to be opened neither closed. It rather
 139      *  corresponds to the ports opened on the different machines.
 140      */
 141
 142     /** \defgroup msg_easier_life      Platform and Application management
 143      *  \ingroup MSG_API
 144      *  \brief This section describes functions to manage the platform creation
 145      *  and the application deployment. You should also have a look at
 146      *  \ref MSG_examples  to have an overview of their usage.
 147      */
 148
 149     /** \defgroup msg_simulation       MSG simulation Functions
 150      *  \ingroup MSG_API
 151      *  \brief This section describes the functions you need to know to
 152      *  set up a simulation. You should have a look at \ref MSG_examples
 153      *  to have an overview of their usage.
 154      */