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 <c>setjump/longjmp</c>) 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_swag A specific set datatype
  33      *  \ingroup XBT_API
  34      *  \brief Warning, this module is done to be efficient and performs tons of
  35      *  cast and dirty things. So avoid using it unless you really know
  36      *  what you are doing. It is basically a fifo but with restrictions so that
  37      *  it can be used as a set. Any operation (add, remove, belongs) is O(1) and
  38      *  no call to malloc/free is done.
  39      */
  40     /** \defgroup XBT_heap A generic heap data structure
  41      *  \ingroup XBT_API
  42      *  \brief This section describes the API to generic heap.
  43      */
  44     /** \defgroup XBT_log A generic logging facility in the spirit of log4j
  45      *  \ingroup XBT_API
  46      *  \brief This section describes the API to the log functions used
  47      *  everywhere in this project.
  48      */
  49     /** \defgroup XBT_sysdep All system dependency
  50      *  \ingroup XBT_API
  51      *  \brief This section describes many macros/functions that can serve as
  52      *  an OS abstraction.
  53      */
  54
  55
  56 /** \defgroup SURF_API       API of SURF
  57  *  \ingroup SimGrid_API
  58  */
  59
  60
  61 /** \defgroup MSG_API      API of MSG
  62  *  \ingroup SimGrid_API
  63  */
  64     /** \defgroup m_datatypes_management MSG Data Types
  65      *  \ingroup MSG_API
  66      *  \brief This section describes the different datatypes provided by MSG.
  67      *
  68      */
  69
  70     /** \defgroup m_process_management Management Functions of Agents
  71      *  \ingroup MSG_API
  72      *  \brief This section describes the agent structure of MSG
  73      *  (#m_process_t) and the functions for managing it.
  74      *
  75      *  We need to simulate many independent scheduling decisions, so
  76      *  the concept of <em>process</em> is at the heart of the
  77      *  simulator. A process may be defined as a <em>code</em>, with
  78      *  some <em>private data</em>, executing in a <em>location</em>.
  79      *  \see m_process_t
  80      */
  81
  82     /** \defgroup m_host_management    Management Functions of Hosts
  83      *  \ingroup MSG_API
  84      *  \brief This section describes the host structure of MSG
  85      * (#m_host_t) and the functions for managing it.
  86      *
  87      *  A <em>location</em> (or <em>host</em>) is any possible place where
  88      *  a process may run. Thus it may be represented as a
  89      *  <em>physical resource with computing capabilities</em>, some
  90      *  <em>mailboxes</em> to enable running process to communicate with
  91      *  remote ones, and some <em>private data</em> that can be only
  92      *  accessed by local process.
  93      *  \see m_host_t
  94      */
  95
  96     /** \defgroup m_task_management    Management Functions of Tasks
  97      *  \ingroup MSG_API
  98      *  \brief This section describes the task structure of MSG
  99      *  (#m_task_t) and the functions for managing it.
 100      *
 101      *  Since most scheduling algorithms rely on a concept of task
 102      *  that can be either <em>computed</em> locally or
 103      *  <em>transferred</em> on another processor, it seems to be the
 104      *  right level of abstraction for our purposes. A <em>task</em>
 105      *  may then be defined by a <em>computing amount</em>, a
 106      *  <em>message size</em> and some <em>private data</em>.
 107      */
 108
 109     /** \defgroup msg_gos_functions    MSG Operating System Functions
 110      *  \ingroup MSG_API
 111      *  \brief This section describes the functions that can be used
 112      *  by an agent for handling some task.
 113      */
 114
 115     /** \defgroup m_channel_management    Understanding channels
 116      *  \ingroup MSG_API
 117      *  \brief This section briefly describes the channel notion of MSG
 118      *  (#m_channel_t).
 119      *
 120      *  For convenience, the simulator provides the notion of channel
 121      *  that is close to the tag notion in MPI. A channel is not a
 122      *  socket. It doesn't need to be opened neither closed. It rather
 123      *  corresponds to the ports opened on the different machines.
 124      */
 125
 126     /** \defgroup msg_easier_life      Platform and Application management
 127      *  \ingroup MSG_API
 128      *  \brief This section describes functions to manage the platform creation
 129      *  and the application deployment. You should also have a look at
 130      *  \ref MSG_examples  to have an overview of their usage.
 131      */
 132
 133     /** \defgroup msg_simulation       MSG simulation Functions
 134      *  \ingroup MSG_API
 135      *  \brief This section describes the functions you need to know to
 136      *  set up a simulation. You should have a look at \ref MSG_examples
 137      *  to have an overview of their usage.
 138      */