/**
- \defgroup SimGrid_API API of SimGrid */
+ \defgroup SimGrid_API SimGrid modules */
-/** \defgroup XBT_API XBT (eXtended Bundle of tools)
- \ingroup SimGrid_API
- \brief The core toolbox of SimGrid, containing usefull datatypes,
- portability support and so on.
-*/
-/** \defgroup XBT_ground Grounding features of the XBT (logging and error reporting)
- \ingroup XBT_API */
- /** \addtogroup XBT_log
- \ingroup XBT_ground */
- /** \defgroup XBT_log_cats Existing log categories
- \ingroup XBT_log
- \brief (automatically extracted)
-
- This is the list of all existing log categories in SimGrid.
- This list was automatically extracted from the source code by
- the src/xbt_log_extract_hierarchy utility.
-
- You can thus be certain that it is uptodate, but it may somehow
- lack a final manual touch.
- Anyway, nothing's perfect ;)
- */
- /** \addtogroup XBT_error
- \ingroup XBT_ground */
-
-/** \defgroup XBT_structs Datatypes defined in the XBT
- \ingroup XBT_API */
-/** \addtogroup XBT_dict
- \ingroup XBT_structs */
-/** \addtogroup XBT_dynar
- \ingroup XBT_structs */
-/** \addtogroup XBT_fifo
- \ingroup XBT_structs */
-/** \addtogroup XBT_set
- \ingroup XBT_structs */
-/** \addtogroup XBT_swag
- \ingroup XBT_structs */
-/** \addtogroup XBT_heap
- \ingroup XBT_structs */
-
-/** \defgroup XBT_port Portability support defined in the XBT
- (you shouldn't use it directly)
- \ingroup XBT_API */
-/** \addtogroup XBT_context
- \ingroup XBT_port */
-/** \addtogroup XBT_sysdep
- \ingroup XBT_port */
-
-/** \defgroup SURF_API SURF (simulator kernel)
+/** \defgroup XBT_API XBT
\ingroup SimGrid_API
- \brief Kernel of all the simulators used in SimGrid, and associated models.
-
- SURF provides the core functionnalities to simulate a virtual
- platform. It is very low-level and is not intended to be used as
- such but rather to serve as a basis for higher-level simulators.
- We're still working on it and the structure is a little bit
- complex. So we'll document it only when we'll be completely satisfied of
- the way it is organized.
-
- It is where platform models are encoded. If you need a model that is not
- encoded yet, please tell me (<arnaud.legrand@imag.fr>) and we'll
- see if it is feasible or not (hopefully it should be but who knows).
-
- Please note that as it is not really intended for public use,
- this module is only partially documented.
+ \brief The core toolbox of SimGrid, containing usefull datatypes,
+ portability support and so on.
+
*/
/** \defgroup MSG_API MSG
\section MSG_who Who should use this (and who shouldn't)
- You should use this model if you want to study some heuristics for a
- given problem you don't really want to implement. If you want to get a
- real implementation of your solution, have a look at the \ref GRAS_API
- programming environment. If you want to study an existing MPI program,
+ You should use this module if you want to study some heuristics for a
+ given problem you don't really want to implement.
+ If you want to use DAGs, have a look at the \ref SD_API programming
+ environment.
+ If you want to get a real (but experimental) implementation of your solution, have a look
+ at the \ref GRAS_API one. If you want to study an existing MPI program,
have a look at the \ref SMPI_API one. If none of those programming
environments fits your needs, you may consider implementing your own
directly on top of \ref SURF_API (but you probably want to contact us
before).
*/
-/** \addtogroup m_datatypes_management
- \ingroup MSG_API */
-/** \addtogroup m_process_management
- \ingroup MSG_API */
-/** \addtogroup m_host_management
- \ingroup MSG_API */
-/** \addtogroup m_task_management
- \ingroup MSG_API */
-/** \addtogroup msg_gos_functions
- \ingroup MSG_API */
-/** \addtogroup m_channel_management
- \ingroup MSG_API */
-/** \addtogroup msg_easier_life
- \ingroup MSG_API */
-/** \addtogroup msg_simulation
- \ingroup MSG_API */
/** \defgroup GRAS_API GRAS
\ingroup SimGrid_API
\brief Realistic programming environment (Grid Reality And Simulation)
- GRAS provide a complete API to implement distributed application on top
+ GRAS provides a complete API to implement distributed application on top
of heterogeneous plateforms. In addition to the SimGrid implementation
of this interface (allowing you to work on your application within the
comfort of the simulator), an implementation suited to real platforms is
also provided (allowing you to really use your application once you're
- done with developing it).
+ done with developing it). It may still contain rought corners as
+ GRAS is not the most used part of SimGrid, however.
GRAS thus constitute a complete grid application developement framework,
encompassing both developer helping tools (the simulator and associated
You should use this programming environment if you want to develop real
applications, ie if the final result of your work is a program which
- may eventually be distributed.
+ may eventually be distributed. Rember however that GRAS is
+ considered as experimental at this point. Help would be welcomed
+ to improve this sorry situation...
+
If you just want to study some heuristics for a given problem you don't
want to implement really (ie, if your result would be a theorem), have a
- look at the \ref MSG_API one.
+ look at the \ref MSG_API one, or the \ref SD_API one if you need to use DAGs.
If you want to study an existing MPI program, have a look at the
\ref SMPI_API one.
If none of those programming environments fits your needs, you may
probably want to contact us before).
*/
+/** \defgroup AMOK_API AMOK
+ \ingroup SimGrid_API
+ \brief Distributed toolkit built over \ref GRAS_API (Advanced Metacomputing Overlay Kit)
+
+ AMOK provides several tools useful to most applications built on top of GRAS,
+ but yet not belonging to GRAS itself. It is planned that those modules will be
+ changed to real plugins one day, allowing users to load only the needed parts at
+ run time. For now, they live in another library against which you should link your
+ programs explicitly.
+*/
+
/** \defgroup SMPI_API SMPI
\ingroup SimGrid_API
\brief Programming environment for the simulation of MPI applications
\ref GRAS_API environment.
If you want to study some heuristics for a given problem (and if your
goal is to produce theorems, not code), have a look at the \ref MSG_API
- environment.
+ environment, or the \ref SD_API one if you need to use DAGs.
If none of those programming environments fits your needs, you may
consider implementing your own directly on top of \ref SURF_API (but you
probably want to contact us before).
*/
+
+
+/** \defgroup SD_API SimDag
+ \ingroup SimGrid_API
+ \brief Programming environment for DAG applications
+
+ SimDag provides some functionnalities to simulate parallel task scheduling
+ with DAGs models (Direct Acyclic Graphs).
+ The old versions of SimGrid were based on DAGs. But the DAG part (named SG)
+ was removed in SimGrid 3 because the new kernel (\ref SURF_API) was implemented. \ref SURF_API
+ was much faster and more flexible than SG and did not use DAGs.
+ SimDag is a new implementation of DAGs handling and it is built on top of \ref SURF_API.
+
+ \section SD_who Who should use this (and who shouldn't)
+
+ You should use this programming environment of the SimGrid suite if you want
+ to study algorithms and heuristics with DAGs of parallel tasks.
+ If you don't need to use DAGs for your simulation, have a look at the
+ \ref MSG_API programming environment.
+ If you want to implement a real distributed application, have a look at the
+ \ref GRAS_API programming environment.
+ If you want to study an existing MPI program, have a look at the
+ \ref SMPI_API one.
+ If none of those programming environments fits your needs, you may
+ consider implementing your own directly on top of \ref SURF_API (but you
+ probably want to contact us before).
+
+*/
+
+/**
+@defgroup SURF_API SURF
+@ingroup SimGrid_API
+@brief Internal kernel of all the simulators used in SimGrid, and associated models.
+
+SURF provides the core functionnalities to simulate a virtual
+platform. It is very low-level and is not intended to be used by end
+users, but rather to serve as a basis for higher-level simulators. Its
+interface are not frozen (and will probably never be), and the
+structure emphasis on performance over ease of use. This module
+contains the platform models. If you need a model that is not encoded
+yet, please come to the devel mailing list so that we can discuss on
+the feasibility of your idea.
+
+Please note that as it is not really intended for public use, this
+module is only partially documented.
+*/
+
+
+/**
+@defgroup TRACE_API TRACE
+@ingroup SimGrid_API
+@brief Tracing mechanism and its functions.
+
+SimGrid can trace the resource (of hosts and links) utilization using
+any of its programming interfaces (MSG, SimDAG and SMPI). This means
+that the tracing will register how much power is used for each host
+and how much bandwidth is used for each link of the platform.
+
+The idea of the tracing facilities is to give SimGrid users to
+possibility to classify MSG and SimDAG tasks by category, tracing the
+platform utilization (hosts and links) for each of the categories.
+The API enables the declaration of categories and a function to
+associate them to the tasks (MSG and SD). The tasks that are not
+classified according to a category are not traced. If no categories
+are specified, simulations can still be traced using a special
+parameter in the command line (see \ref tracing_tracing for details).
+*/
+
