Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
fafe88603adf2c979eecfe2430ed2e31a451f14a
[simgrid.git] / 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      */