Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
instr: prefer std::str to char*
[simgrid.git] / src / instr / instr_private.h
1 /* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #ifndef INSTR_PRIVATE_H_
7 #define INSTR_PRIVATE_H_
8
9 #include <xbt/base.h>
10
11 #include "instr/instr_interface.h"
12 #include "simgrid/instr.h"
13 #include "simgrid_config.h"
14 #include "src/internal_config.h"
15 #include <set>
16
17 /* Need to define function drand48 for Windows */
18 /* FIXME: use _drand48() defined in src/surf/random_mgr.c instead */
19 #ifdef _WIN32
20 #  define drand48() (rand()/(RAND_MAX + 1.0))
21 #endif
22
23 #define INSTR_DEFAULT_STR_SIZE 500
24
25 #include "xbt/graph.h"
26 #include "xbt/dict.h"
27
28 namespace simgrid {
29 namespace instr {
30 typedef enum {
31   PAJE_DefineContainerType,
32   PAJE_DefineVariableType,
33   PAJE_DefineStateType,
34   PAJE_DefineEventType,
35   PAJE_DefineLinkType,
36   PAJE_DefineEntityValue,
37   PAJE_CreateContainer,
38   PAJE_DestroyContainer,
39   PAJE_SetVariable,
40   PAJE_AddVariable,
41   PAJE_SubVariable,
42   PAJE_SetState,
43   PAJE_PushState,
44   PAJE_PopState,
45   PAJE_ResetState,
46   PAJE_StartLink,
47   PAJE_EndLink,
48   PAJE_NewEvent
49 } e_event_type;
50
51 typedef enum {
52   TYPE_VARIABLE,
53   TYPE_LINK,
54   TYPE_CONTAINER,
55   TYPE_STATE,
56   TYPE_EVENT
57 } e_entity_types;
58
59 //--------------------------------------------------
60
61 class Type {
62 public:
63   char* id_;
64   char* name_;
65   char* color_;
66
67   e_entity_types kind_;
68   Type* father_;
69   xbt_dict_t children_;
70   xbt_dict_t values_; // valid for all types except variable and container
71   Type(const char* typeNameBuff, const char* key, const char* color, e_entity_types kind, Type* father);
72   ~Type();
73   Type* getChild(const char* name);
74   Type* getChildOrNull(const char* name);
75
76   static Type* containerNew(const char* name, Type* father);
77   static Type* eventNew(const char* name, Type* father);
78   static Type* variableNew(const char* name, const char* color, Type* father);
79   static Type* linkNew(const char* name, Type* father, Type* source, Type* dest);
80   static Type* stateNew(const char* name, Type* father);
81 };
82
83 //--------------------------------------------------
84 class Value {
85 public:
86   char* id_;
87   char* name_;
88   char* color_;
89
90   Type* father_;
91   Value(const char* name, const char* color, Type* father);
92   ~Value();
93   static Value* get_or_new(const char* name, const char* color, Type* father);
94   static Value* get(const char* name, Type* father);
95 };
96
97
98 //--------------------------------------------------
99 typedef enum {
100   INSTR_HOST,
101   INSTR_LINK,
102   INSTR_ROUTER,
103   INSTR_AS,
104   INSTR_SMPI,
105   INSTR_MSG_VM,
106   INSTR_MSG_PROCESS,
107   INSTR_MSG_TASK
108 } e_container_types;
109
110 //--------------------------------------------------
111
112 class Container {
113 public:
114   Container(const char* name, simgrid::instr::e_container_types kind, Container* father);
115   virtual ~Container();
116
117   sg_netpoint_t netpoint_;
118   char* name_;             /* Unique name of this container */
119   char* id_;               /* Unique id of this container */
120   Type* type_;             /* Type of this container */
121   int level_ = 0;          /* Level in the hierarchy, root level is 0 */
122   e_container_types kind_; /* This container is of what kind */
123   Container* father_;
124   xbt_dict_t children_;
125 };
126
127 //--------------------------------------------------
128 class PajeEvent {
129   public:
130     double timestamp_;
131     e_event_type eventType_;
132     virtual void print() = 0;
133     virtual ~PajeEvent();
134 };
135
136 //--------------------------------------------------
137 class SetVariableEvent : public PajeEvent  {
138   private:
139     Container* container;
140     Type* type;
141     double value;
142
143   public:
144     SetVariableEvent(double timestamp, Container* container, Type* type, double value);
145     void print() override;
146 };
147
148 class AddVariableEvent:public PajeEvent {
149   private:
150     Container* container;
151     Type* type;
152     double value;
153
154   public:
155     AddVariableEvent(double timestamp, Container* container, Type* type, double value);
156     void print() override;
157 };
158 //--------------------------------------------------
159
160
161 class SubVariableEvent : public PajeEvent  {
162   private:
163     Container* container;
164     Type* type;
165     double value;
166
167   public:
168     SubVariableEvent(double timestamp, Container* container, Type* type, double value);
169     void print() override;
170 };
171 //--------------------------------------------------
172
173 class SetStateEvent : public PajeEvent  {
174   private:
175     Container* container;
176     Type* type;
177     Value* val;
178     const char* filename;
179     int linenumber;
180
181   public:
182     SetStateEvent(double timestamp, Container* container, Type* type, Value* val);
183     void print() override;
184 };
185
186
187 class PushStateEvent : public PajeEvent  {
188   public:
189     Container* container;
190     Type* type;
191     Value* val;
192     int size;
193     const char* filename;
194     int linenumber;
195     void* extra_;
196
197   public:
198     PushStateEvent(double timestamp, Container* container, Type* type, Value* val);
199     PushStateEvent(double timestamp, Container* container, Type* type, Value* val, void* extra);
200     void print() override;
201 };
202
203 class PopStateEvent : public PajeEvent  {
204   Container* container;
205   Type* type;
206
207 public:
208   PopStateEvent(double timestamp, Container* container, Type* type);
209   void print() override;
210 };
211
212 class ResetStateEvent : public PajeEvent  {
213   Container* container;
214   Type* type;
215
216 public:
217   ResetStateEvent(double timestamp, Container* container, Type* type);
218   void print() override;
219 };
220
221 class StartLinkEvent : public PajeEvent  {
222   Container* container_;
223   Type* type_;
224   Container* sourceContainer_;
225   std::string value_;
226   std::string key_;
227   int size_;
228
229 public:
230   StartLinkEvent(double timestamp, Container* container, Type* type, Container* sourceContainer, const char* value,
231                  const char* key);
232   StartLinkEvent(double timestamp, Container* container, Type* type, Container* sourceContainer, const char* value,
233                  const char* key, int size);
234   void print() override;
235 };
236
237 class EndLinkEvent : public PajeEvent  {
238   Container* container;
239   Type* type;
240   Container* destContainer;
241   char *value;
242   char *key;
243   public:
244     EndLinkEvent(double timestamp, Container* container, Type* type, Container* destContainer, const char* value,
245                  const char* key);
246     ~EndLinkEvent();
247     void print() override;
248 };
249
250
251 class NewEvent : public PajeEvent  {
252   public:
253     Container* container;
254     Type* type;
255     Value* val;
256
257   public:
258     NewEvent(double timestamp, Container* container, Type* type, Value* val);
259     void print() override;
260 };
261 }
262 } // namespace simgrid::instr
263 typedef simgrid::instr::Container* container_t;
264
265 SG_BEGIN_DECL()
266
267 extern XBT_PRIVATE std::set<std::string> created_categories;
268 extern XBT_PRIVATE std::set<std::string> declared_marks;
269 extern XBT_PRIVATE std::set<std::string> user_host_variables;
270 extern XBT_PRIVATE std::set<std::string> user_vm_variables;
271 extern XBT_PRIVATE std::set<std::string> user_link_variables;
272 extern XBT_PRIVATE double TRACE_last_timestamp_to_dump;
273
274 /* instr_paje_header.c */
275 XBT_PRIVATE void TRACE_header(int basic, int size);
276
277 /* from paje.c */
278 XBT_PRIVATE void TRACE_paje_start();
279 XBT_PRIVATE void TRACE_paje_end();
280 XBT_PRIVATE void TRACE_paje_dump_buffer (int force);
281
282
283 /* from instr_config.c */
284 XBT_PRIVATE bool TRACE_needs_platform ();
285 XBT_PRIVATE bool TRACE_is_enabled();
286 XBT_PRIVATE bool TRACE_platform();
287 XBT_PRIVATE bool TRACE_platform_topology();
288 XBT_PRIVATE bool TRACE_is_configured();
289 XBT_PRIVATE bool TRACE_categorized ();
290 XBT_PRIVATE bool TRACE_uncategorized ();
291 XBT_PRIVATE bool TRACE_msg_process_is_enabled();
292 XBT_PRIVATE bool TRACE_msg_vm_is_enabled();
293 XBT_PRIVATE bool TRACE_buffer ();
294 XBT_PRIVATE bool TRACE_disable_link();
295 XBT_PRIVATE bool TRACE_disable_speed();
296 XBT_PRIVATE bool TRACE_onelink_only ();
297 XBT_PRIVATE bool TRACE_disable_destroy ();
298 XBT_PRIVATE bool TRACE_basic ();
299 XBT_PRIVATE bool TRACE_display_sizes ();
300 XBT_PRIVATE char *TRACE_get_comment ();
301 XBT_PRIVATE char *TRACE_get_comment_file ();
302 XBT_PRIVATE int TRACE_precision ();
303 XBT_PRIVATE char *TRACE_get_filename();
304 XBT_PRIVATE char *TRACE_get_viva_uncat_conf ();
305 XBT_PRIVATE char *TRACE_get_viva_cat_conf ();
306 XBT_PRIVATE void TRACE_generate_viva_uncat_conf ();
307 XBT_PRIVATE void TRACE_generate_viva_cat_conf ();
308 XBT_PRIVATE void instr_pause_tracing ();
309 XBT_PRIVATE void instr_resume_tracing ();
310
311 /* Public functions used in SMPI */
312 XBT_PUBLIC(bool) TRACE_smpi_is_enabled();
313 XBT_PUBLIC(bool) TRACE_smpi_is_grouped();
314 XBT_PUBLIC(bool) TRACE_smpi_is_computing();
315 XBT_PUBLIC(bool) TRACE_smpi_is_sleeping();
316 XBT_PUBLIC(bool) TRACE_smpi_view_internals();
317
318 /* from resource_utilization.c */
319 XBT_PRIVATE void TRACE_surf_host_set_utilization(const char *resource, const char *category, double value, double now,
320                                      double delta);
321 XBT_PRIVATE void TRACE_surf_link_set_utilization(const char *resource,const char *category, double value, double now,
322                                      double delta);
323 XBT_PUBLIC(void) TRACE_surf_resource_utilization_alloc();
324
325 /* instr_paje.c */
326 extern XBT_PRIVATE std::set<std::string> trivaNodeTypes;
327 extern XBT_PRIVATE std::set<std::string> trivaEdgeTypes;
328 XBT_PRIVATE long long int instr_new_paje_id ();
329 XBT_PUBLIC(container_t) PJ_container_get (const char *name);
330 XBT_PUBLIC(simgrid::instr::Container*) PJ_container_get_or_null(const char* name);
331 XBT_PUBLIC(container_t) PJ_container_get_root ();
332 XBT_PUBLIC(void) PJ_container_set_root (container_t root);
333 XBT_PUBLIC(void) PJ_container_free_all (void);
334 XBT_PUBLIC(void) PJ_container_remove_from_parent (container_t container);
335
336 /* instr_paje_types.c */
337 XBT_PUBLIC(simgrid::instr::Type*) PJ_type_get_root();
338
339 /* instr_config.c */
340 XBT_PRIVATE void TRACE_TI_start();
341 XBT_PRIVATE void TRACE_TI_end();
342
343 XBT_PRIVATE void TRACE_paje_dump_buffer (int force);
344 XBT_PRIVATE void dump_comment_file (const char *filename);
345 XBT_PRIVATE void dump_comment (const char *comment);
346
347 struct s_instr_extra_data;
348 typedef struct s_instr_extra_data *instr_extra_data;
349
350 typedef enum{
351   TRACING_INIT,
352   TRACING_FINALIZE,
353   TRACING_COMM_SIZE,
354   TRACING_COMM_SPLIT,
355   TRACING_COMM_DUP,
356   TRACING_SEND,
357   TRACING_ISEND,
358   TRACING_SSEND,
359   TRACING_ISSEND,
360   TRACING_RECV,
361   TRACING_IRECV,
362   TRACING_SENDRECV,
363   TRACING_TEST,
364   TRACING_WAIT,
365   TRACING_WAITALL,
366   TRACING_WAITANY,
367   TRACING_BARRIER,
368   TRACING_BCAST,
369   TRACING_REDUCE,
370   TRACING_ALLREDUCE,
371   TRACING_ALLTOALL,
372   TRACING_ALLTOALLV,
373   TRACING_GATHER,
374   TRACING_GATHERV,
375   TRACING_SCATTER,
376   TRACING_SCATTERV,
377   TRACING_ALLGATHER,
378   TRACING_ALLGATHERV,
379   TRACING_REDUCE_SCATTER,
380   TRACING_COMPUTING,
381   TRACING_SLEEPING,
382   TRACING_SCAN,
383   TRACING_EXSCAN
384 } e_caller_type ;
385
386 typedef struct s_instr_extra_data {
387   e_caller_type type;
388   int send_size;
389   int recv_size;
390   double comp_size;
391   double sleep_duration;
392   int src;
393   int dst;
394   int root;
395   const char* datatype1;
396   const char* datatype2;
397   int * sendcounts;
398   int * recvcounts;
399   int num_processes;
400 } s_instr_extra_data_t;
401
402 /* Format of TRACING output.
403  *   - paje is the regular format, that we all know
404  *   - TI is a trick to reuse the tracing functions to generate a time independent trace during the execution. Such trace can easily be replayed with smpi_replay afterward.
405  *     This trick should be removed and replaced by some code using the signal that we will create to cleanup the TRACING
406  */
407 typedef enum { instr_fmt_paje, instr_fmt_TI } instr_fmt_type_t;
408 extern instr_fmt_type_t instr_fmt_type;
409
410 SG_END_DECL()
411
412 void LogContainerTypeDefinition(simgrid::instr::Type* type);
413 void LogVariableTypeDefinition(simgrid::instr::Type* type);
414 void LogStateTypeDefinition(simgrid::instr::Type* type);
415 void LogLinkTypeDefinition(simgrid::instr::Type* type, simgrid::instr::Type* source, simgrid::instr::Type* dest);
416 void LogEntityValue(simgrid::instr::Value* val);
417 void LogContainerCreation (container_t container);
418 void LogContainerDestruction (container_t container);
419 void LogDefineEventType(simgrid::instr::Type* type);
420
421 #endif