Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
cc1c756473554d442164f2a688aac46e6ae6eb92
[simgrid.git] / src / modules.doc
1 /** 
2   \defgroup SimGrid_API  API of SimGrid */
3
4 /** \defgroup XBT_API      XBT (eXtended Bundle of tools)
5        \ingroup SimGrid_API
6        \brief The core toolbox of SimGrid, containing usefull datatypes,
7        portability support and so on.
8 */
9 /**    \defgroup XBT_ground Grounding features of the XBT (logging and error reporting)
10        \ingroup XBT_API        */
11 /**       \addtogroup  XBT_log
12           \ingroup XBT_ground  */
13 /**       \addtogroup  XBT_error
14           \ingroup XBT_ground  */
15
16 /**    \defgroup XBT_structs  Datatypes defined in the XBT
17        \ingroup XBT_API        */
18 /**       \addtogroup XBT_dict
19           \ingroup XBT_structs */
20 /**       \addtogroup XBT_dynar
21           \ingroup XBT_structs */
22 /**       \addtogroup XBT_fifo
23           \ingroup XBT_structs */
24 /**       \addtogroup XBT_set
25           \ingroup XBT_structs */
26 /**        \addtogroup XBT_swag
27           \ingroup XBT_structs */
28 /**       \addtogroup XBT_heap
29           \ingroup XBT_structs */
30      
31 /**    \defgroup XBT_port     Portability support defined in the XBT 
32                               (you shouldn't use it directly) 
33        \ingroup XBT_API        */
34 /**       \addtogroup XBT_context 
35           \ingroup XBT_port    */
36 /**       \addtogroup XBT_sysdep
37           \ingroup XBT_port    */
38
39 /** \defgroup SURF_API       SURF (simulator kernel)
40     \ingroup SimGrid_API
41     \brief Kernel of all the simulators used in SimGrid, and associated models.
42  
43       SURF provides the core functionnalities to simulate a virtual
44       platform. It is very low-level and is not intended to be used as
45       such but rather to serve as a basis for higher-level simulators.
46       We're still working on it and the structure is a little bit
47       complex. So we'll document it only when we'll be completely satisfied of 
48       the way it is organized.
49
50       It is where platform models are encoded. If you need a model that is not 
51       encoded yet, please tell me (<arnaud.legrand@imag.fr>) and we'll
52       see if it is feasible or not (hopefully it should be but who knows).
53
54       Please note that as it is not really intended for public use,
55       this module is only partially documented.
56 */
57
58 /** \defgroup MSG_API      MSG
59     \ingroup SimGrid_API
60     \brief Simple programming environment 
61   
62       MSG was the first distributed programming environment provided within
63       SimGrid. While almost realistic, it remains quite simple (simplistic?).
64
65       \section MSG_who Who should use this (and who shouldn't)
66       
67       You should use this model if you want to study some heuristics for a
68       given problem you don't really want to implement. If you want to get a
69       real implementation of your solution, have a look at the \ref GRAS_API 
70       programming environment. If you want to study an existing MPI program,
71       have a look at the \ref SMPI_API one. If none of those programming
72       environments fits your needs, you may consider implementing your own 
73       directly on top of \ref SURF_API (but you probably want to contact us
74       before). 
75 */
76 /**     \addtogroup m_datatypes_management
77         \ingroup MSG_API  */
78 /**     \addtogroup m_process_management
79         \ingroup MSG_API  */
80 /**     \addtogroup m_host_management
81         \ingroup MSG_API  */
82 /**     \addtogroup m_task_management
83         \ingroup MSG_API  */
84 /**     \addtogroup msg_gos_functions
85         \ingroup MSG_API  */
86 /**     \addtogroup m_channel_management
87         \ingroup MSG_API  */
88 /**     \addtogroup msg_easier_life
89         \ingroup MSG_API  */
90 /**     \addtogroup msg_simulation
91         \ingroup MSG_API  */
92
93
94 /** \defgroup GRAS_API      GRAS
95     \ingroup SimGrid_API
96     \brief Realistic programming environment (Grid Reality And Simulation)
97   
98     GRAS provide a complete API to implement distributed application on top
99     of heterogeneous plateforms. In addition to the SimGrid implementation
100     of this interface (allowing you to work on your application within the
101     comfort of the simulator), an implementation suited to real platforms is
102     also provided (allowing you to really use your application once you're
103     done with developing it).
104   
105     GRAS thus constitute a complete grid application developement framework,
106     encompassing both developer helping tools (the simulator and associated
107     tools) and an efficient while portable execution runtime.
108   
109     \section GRAS_who Who should use this (and who shouldn't)
110     
111     You should use this programming environment if you want to develop real
112     applications, ie if the final result of your work is a program which 
113     may eventually be distributed. 
114     If you just want to study some heuristics for a given problem you don't
115     want to implement really (ie, if your result would be a theorem), have a
116     look at the \ref MSG_API one.
117     If you want to study an existing MPI program, have a look at the 
118     \ref SMPI_API one. 
119     If none of those programming environments fits your needs, you may
120     consider implementing your own directly on top of \ref SURF_API (but you
121     probably want to contact us before).
122   
123     \section GRAS_funct Offered functionnalities
124      - <b>Communication facilities</b>: Exchanging messages between peers
125        - \ref GRAS_dd: any data which may transit on the network must be
126          described beforehand so that GRAS can handle the platform
127          heterogeneity and convert them if needed.
128        - \ref GRAS_sock: this is how to open a communication channel to
129          other processes, and retrive information about them.
130        - \ref GRAS_msg: communications are message oriented. You have to
131          describe all possible messages and their payload beforehand, and
132          can then attach callbacks to the arrival of a given kind of message. 
133      - <b>Virtualization</b>: Running both on top of the simulator and on
134        top of real platforms, and portability support.
135        - \ref GRAS_globals: The use of globals is forbidden since the
136          "processes" are threads in simulation mode. \n
137          This is how to let GRAS handle your globals properly.
138        - \ref GRAS_cond: How to declare specific code for the simulation mode
139           or for the real mode.
140        - \ref GRAS_virtu: You naturally don't want to call the
141           gettimeofday(2) function in simulation mode since it would give
142           you the time on the host running the simulation, not the time in
143           the simulated world (you are belonging to).\n
144           This a system call virtualization layer, which also acts as a
145           portability layer.
146           
147     @{
148 */     
149
150        /** \defgroup GRAS_dd      Data description      */       
151        /** \defgroup GRAS_sock    Sockets               */           
152        /** \defgroup GRAS_msg     Messages              */               
153          
154        /** \defgroup GRAS_globals Globals               */ 
155        /** \defgroup GRAS_cond    Conditional execution */ 
156        /** \defgroup GRAS_virtu   Syscalls              */ 
157
158 /** @} */ 
159
160 /** \defgroup SMPI_API      SMPI
161     \ingroup SimGrid_API
162     \brief Programming environment for the simulation of MPI applications
163   
164     Once implemented, this programming environment will allow you to study
165     within the simulator any MPI application without having to modify them
166     for that. In other words, it will constitute an emulation solution for
167     parallel codes.
168     
169     \section SMPI_who Who should use this (and who shouldn't)
170     
171     You should use this programming environment of the SimGrid suite if you
172     want to study existing MPI applications.
173     If you want to work on a distributed application, have a look at the 
174     \ref GRAS_API environment. 
175     If you want to study some heuristics for a given problem (and if your
176     goal is to produce theorems, not code), have a look at the \ref MSG_API
177     environment.
178     If none of those programming environments fits your needs, you may
179     consider implementing your own directly on top of \ref SURF_API (but you
180     probably want to contact us before).
181   
182  */