Flow123d  master-f44eb46
sys_profiler.hh
Go to the documentation of this file.
1 /*!
2  *
3  * Copyright (C) 2015 Technical University of Liberec. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify it under
6  * the terms of the GNU General Public License version 3 as published by the
7  * Free Software Foundation. (http://www.gnu.org/licenses/gpl-3.0.en.html)
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12  *
13  *
14  * @file sys_profiler.hh
15  * @brief
16  * @todo
17  * - START_GLOBAL_TIMER(tag) - this calls the start_timer, which creates local timer on the correct place in the hierarchy,
18  * further this timer is added to the list of global timers, this contains groups of timers with same tag, and
19  * collect/sum data from these timers in the report.
20  *
21  * - Allow output even during calculation (not complete, but at least some thing)
22  * Report should contain time of start as well as time of creation of the report or time from start of the program.
23  *
24  * - When generating report we has to deal with possibly different trees at every MPI process.
25  *
26  * - test memory profiling
27  * in our own new and xmalloc functions - register allocatied and deallocated memory to active Profiler frame.
28  *
29  * - test in parallel
30  * - extended output:
31  * cas na jedno volani (jina redukce nez pro kumulativni cas, pokud je pocet volani ruzny)
32  * procenta vuci predkovi
33  * code point (az nekde na konci radky)
34  *
35  *
36  * !!! Unfortunately using constexpr is worse (without optimization).
37  * This is probably due to use of static variable for
38  * CodePoint, the access could be slow, and computation of hash is done only once. Actually timing results
39  * are:
40  *
41  * OPTIONS OVERHEAD (compared to call 2x clock())
42  * -g, no c++11 : 18%
43  * -g, c++11 : 60%
44  * -O3,no c++11 : 6%
45  * -O3, c++11 : 6%
46  */
47 
48 #ifndef PROFILER_H
49 #define PROFILER_H
50 
51 #include "global_defs.h"
52 
53 #include <mpi.h>
54 #include <ostream>
55 #include <unordered_map>
56 
57 namespace boost { template <class T> struct hash; }
58 #include <boost/functional/hash/hash.hpp> // for hash
59 #include <boost/ref.hpp>
60 #include <boost/tuple/detail/tuple_basic.hpp> // for get
61 
62 #include <nlohmann/json.hpp>
63 
64 #include "time_point.hh"
65 #include "petscsys.h"
66 #include "simple_allocator.hh"
67 
68 //instead of #include "mpi.h"
69 //mpi declarations follows:
71 public:
72  static int sum(int* val, MPI_Comm comm);
73  static double sum(double* val, MPI_Comm comm);
74  static long sum(long* val, MPI_Comm comm);
75 
76  static int min(int* val, MPI_Comm comm);
77  static double min(double* val, MPI_Comm comm);
78  static long min(long* val, MPI_Comm comm);
79 
80  static int max(int* val, MPI_Comm comm);
81  static double max(double* val, MPI_Comm comm);
82  static long max(long* val, MPI_Comm comm);
83 };
84 
85 // Assuming all compilers support constexpr
86 #define CONSTEXPR_ constexpr
87 
88 using namespace std;
89 
90 
91 // These helper macros are necessary due to use of _LINE_ variable in START_TIMER macro.
92 #define _PASTE(a,b) a ## b
93 #define PASTE(a,b) _PASTE(a, b)
94 
95 
96 
97 /**
98  * \def START_TIMER(tag)
99  *
100  * @brief Starts a timer with specified tag.
101  *
102  * In fact it creates an static constant expression that identifies the point in the code and
103  * contains tag of the involved timer and its hash. Then it creates local variable that
104  * calls @p Profiler::start_timer() in constructor and @p Profiler::stop_timer() in destructor.
105  * This way the timer is automatically closed at the end of current block.
106  *
107  * ATTENTION: This macro expands to two statements so following code is illegal:
108  * @code
109  * if (some_condition) START_TIMER(tag);
110  * @endcode
111  */
112 #ifdef FLOW123D_DEBUG_PROFILER
113 #define START_TIMER(tag) static CONSTEXPR_ CodePoint PASTE(cp_,__LINE__) = CODE_POINT(tag); TimerFrame PASTE(timer_,__LINE__) = TimerFrame( PASTE(cp_,__LINE__) )
114 #else
115 #define START_TIMER(tag)
116 #endif
117 
118 /**
119  * \def START_TIMER_EXT (tag, subtag)
120  *
121  * @brief Starts a timer with specified tag and subtag.
122  *
123  * In fact it creates an static constant expression that identifies the point in the code and
124  * contains tag and subtag of the involved timer and its hash. Then it creates local variable that
125  * calls @p Profiler::start_timer() in constructor and @p Profiler::stop_timer() in destructor.
126  * This way the timer is automatically closed at the end of current block.
127  *
128  * ATTENTION: This macro expands to two statements so following code is illegal:
129  * @code
130  * if (some_condition) START_TIMER_EXT(tag, subtag);
131  * @endcode
132  */
133 #ifdef FLOW123D_DEBUG_PROFILER
134 #define START_TIMER_EXT(tag, subtag) static CONSTEXPR_ CodePoint PASTE(cp_,__LINE__) = CODE_POINT_EXT(tag, subtag); TimerFrame PASTE(timer_,__LINE__) = TimerFrame( PASTE(cp_,__LINE__) )
135 #else
136 #define START_TIMER_EXT(tag, subtag)
137 #endif
138 
139 /**
140  * \def END_TIMER(tag)
141  *
142  * @brief Ends a timer with specified tag.
143  *
144  * Use only if you want to end timer before the end of block. Again this expands into two lines, see ATTENTION in previous macro.
145  */
146 #ifdef FLOW123D_DEBUG_PROFILER
147 #define END_TIMER(tag) static CONSTEXPR_ CodePoint PASTE(cp_,__LINE__) = CODE_POINT(tag); Profiler::instance()->stop_timer( PASTE(cp_,__LINE__) )
148 #else
149 #define END_TIMER(tag)
150 #endif
151 
152 /**
153  * \def END_START_TIMER(tag)
154  *
155  * Ends current timer and starts the new one with given tag. Again this expands into two lines, see ATTENTION in previous macro.
156  */
157 #ifdef FLOW123D_DEBUG_PROFILER
158 #define END_START_TIMER(tag) Profiler::instance()->stop_timer(); START_TIMER(tag);
159 #else
160 #define END_START_TIMER(tag)
161 #endif
162 
163 
164 /**
165  * \def ADD_CALLS(n_calls)
166  *
167  * @brief Increase number of calls in actual timer.
168  *
169  * Some time you want to measure a performance of a cycle with body that is below resolution of the Timer implementation.
170  * If you know number of cycles, you can use this macro in following way:
171  *
172  * @code
173  * START_TIMER("cycle");
174  * unsigned int i;
175  * for(i =0; i<1000000; i++) i*i*i;
176  * ADD_CALLS(i);
177  * END_TIMER("cycle");
178  * @endcode
179  *
180  * In the profiler report you get the total time spent in the cycle, and time per one call which will be average
181  * time spent in the body of the cycle.
182  */
183 #ifdef FLOW123D_DEBUG_PROFILER
184 #define ADD_CALLS(n_calls) Profiler::instance()->add_calls(n_calls)
185 #else
186 #define ADD_CALLS(n_calls)
187 #endif
188 
189 
190 #ifdef FLOW123D_DEBUG_PROFILER
191 #define CUMUL_TIMER(tag) Profiler::instance()->find_timer(tag).cumulative_time()
192 #else
193 #define CUMUL_TIMER(tag) 0
194 #endif
195 
196 //////////////////////////////////////////////////////////////////////////////////////////////
197 #ifdef FLOW123D_DEBUG_PROFILER
198 
199 /**
200  * Variable which represents value when no subtag was specified in CodePoint class
201  */
202 #define PROFILER_EMPTY_SUBTAG ""
203 
204 /**
205  * Variable used for default value in hash process
206  */
207 #define PROFILER_HASH_DEFAULT 0
208 
209 /**
210  * @brief Function for compile-time hash computation. (Needs C++x11 standard.)
211  * Input, @p str, is constant null terminated string, result is unsigned int (usually 4 bytes).
212  * Function has to be recursive, since standard requires that the body consists only from the return statement.
213  *
214  * SALT is hash for the empty string. Currently zero for simpler testing.
215  */
216 inline CONSTEXPR_ unsigned int str_hash(const char * str, unsigned int default_value) {
217  #define SALT 0 //0xef50e38f
218  return (*str == 0 ? SALT : default_value + str_hash(str+1, PROFILER_HASH_DEFAULT) * 101 + (unsigned int)(*str) );
219 }
220 
221 /**
222  * Macro to generate constexpr CodePoint object.
223  */
224 #define CODE_POINT(tag) CodePoint(tag, __FILE__, __func__, __LINE__)
225 
226 /**
227  * Macro to generate constexpr CodePoint object.
228  */
229 #define CODE_POINT_EXT(tag, subtag) CodePoint(tag, subtag, __FILE__, __func__, __LINE__)
230 
231 
232 
233 
234 /**
235  * @brief Class that represents point in the code.
236  *
237  * This class allow construction at compile time. And includes the information about the code point as well
238  * as the 'tag' of the timer and cimpile-time computed hashes of this 'tag'. The @p hash_ is long one with
239  * very small probability of collisions - this we use for comparison of tags. The @p hash_idx_ is the long hash modulo
240  * length of the array of Timer's children, this is used for fast loop up into this array that servers as a simple hash table.
241  */
242 class CodePoint {
243 public:
244  CONSTEXPR_ CodePoint(const char *tag, const char * file, const char * func, const unsigned int line)
245  : tag_(tag), subtag_(PROFILER_EMPTY_SUBTAG), file_(file), func_(func), line_(line),
246  hash_(str_hash(tag, PROFILER_HASH_DEFAULT)),
247  hash_idx_( str_hash(tag, PROFILER_HASH_DEFAULT)%max_n_timer_childs )
248  {};
249  CONSTEXPR_ CodePoint(const char *tag, const char *subtag, const char * file, const char * func, const unsigned int line)
250  : tag_(tag), subtag_(subtag), file_(file), func_(func), line_(line),
251  hash_(str_hash(subtag, str_hash(tag, PROFILER_HASH_DEFAULT))),
252  hash_idx_( str_hash(subtag, str_hash(tag, PROFILER_HASH_DEFAULT))%max_n_timer_childs )
253  {};
254 
255  /// Size of child arrays in timer nodes.
256  static const unsigned int max_n_timer_childs=13;
257 
258  /// Tag of the code point.
259  const char * const tag_;
260 
261  /// Subtag of the code point.
262  const char * const subtag_;
263 
264  /// file name of the code point
265  const char * const file_;
266 
267  /// file name of the code point
268  const char * const func_;
269 
270  /// file name of the code point
271  const unsigned int line_;
272 
273  /// Full 32-bit hash of the tag ( practically no chance of collision)
274  unsigned int hash_;
275 
276  /// Hash modulo size of array of timer childs ( we have to check full hash to prevent collision)
277  unsigned int hash_idx_;
278 };
279 
280 
281 
282 /**
283  * @brief Class for profiling tree nodes.
284  *
285  * One Timer represents one particular time frame in the execution tree.
286  * It collects information about total time, number of calls, allocated and deallocated memory.
287  *
288  * It should be accessed only through Profiler, which is its friend class.
289  *
290  * TODO: for better performance: move copy hash_ and hash_idx_ into Timer since CodePoint are in static
291  * variables, that may be slower to acces.
292  *
293  */
294 class Timer {
295 
296 
297 public:
298  /// Size of array @p child_timers, the hash table containing descendants in the call tree.
299  static const unsigned int max_n_childs=CodePoint::max_n_timer_childs;
300 
301  /**
302  * Creates the timer node object. Should not be called directly, but through the START_TIMER macro.
303  */
304  Timer(const CodePoint &cp, int parent);
305 
306 
307  /**
308  * Start the timer. If it is already started, just increase number of starts (recursions) and calls.
309  */
310  void start();
311 
312  /**
313  * If number of starts (recursions) drop back to zero, we stop the timer and add the period to the cumulative time.
314  * This method do not take care of its childs (it has no access to the other timers).
315  * When the parameter 2p forced is 'true', we stop the timer immediately regardless the number of recursions.
316  * Returns true if the timer is not closed (recursions didn't drop to zero yet).
317  */
318  bool stop(bool forced = false);
319 
320 
321  /// Getter for the 'tag'.
322  inline string tag() const {
323  string buf(code_point_->tag_);
324  buf.append(code_point_->subtag_);
325  return buf;
326  }
327 
328  /// Returns true if the timer is open, number of starts (recursions) is nonzero.
329  inline bool running() const
330  { return start_count >0; }
331 
332  /// Returns string with description of the code point where the timer was first started.
333  std::string code_point_str() const;
334 
335  /**
336  * Returns cumulative time of the timer in seconds.
337  */
338  double cumulative_time() const;
339 
340  /*
341  * Adds given index @p child_index of the timer @p child to the correct place in the hash table.
342  */
343  void add_child(int child_index, const Timer &child);
344 
345 
346 protected:
347 
348  /**
349  * Pauses current timer, save measured petsc memory information util resume.
350  * We get Petsc maximum memory usage via PetscMemoryGetMaximumUsage call
351  * and save this value into temp value. (we override local maximum if temp
352  * value is greater)
353  */
354  void pause();
355  /**
356  * Resume current timer. e tell Petsc to monitor the maximum memory
357  * usage once again. We call PetscMemorySetGetMaximumUsage so later in
358  * resume() method will PetscMemoryGetMaximumUsage method work.
359  */
360  void resume();
361 
362  /**
363  * Start time when frame opens.
364  */
365  TimePoint start_time;
366  /**
367  * Cumulative time spent in the frame.
368  */
369  double cumul_time;
370  /**
371  * Total number of opening of the frame.
372  */
373  unsigned int call_count;
374  /**
375  * Number of recursive openings.
376  */
377  unsigned int start_count;
378 
379 
380  /**
381  * Code point of the first START_TIMER for the particular tag. The 'tag' identifies timer
382  * and is used in reported profiler table.
383  */
384  const CodePoint *code_point_;
385  /// Full tag hash. Copy from code_point_.
386  unsigned int full_hash_;
387  /// Hash modulo size of array of timer childs. Copy from code_point_.
388  unsigned int hash_idx_;
389 
390  /**
391  * Index of the parent timer node in the tree. Negative value means 'not set'.
392  */
393  int parent_timer;
394  /**
395  * Indices of the child timers in the Profiler::timers_ vector. Negative values means 'not set'.
396  */
397  int child_timers[max_n_childs];
398 
399  /**
400  * Total number of bytes allocated in this frame. After
401  * Profiler::propagate_timers call will also contain values from children.
402  */
403  size_t total_allocated_;
404  /**
405  * Total number of bytes deallocated in this frame. After
406  * Profiler::propagate_timers call, will also contain values from children.
407  */
408  size_t total_deallocated_;
409  /**
410  * Maximum number of bytes allocated at one time in this frame. After
411  * Profiler::propagate_timers call, maximum value will be taken from this
412  * Timer and also from all children Timers.
413  */
414  size_t max_allocated_;
415  /**
416  * Current number of bytes allocated in this frame at the same time.
417  * This value is used to monitor maximum bytes allocated. When notify_free
418  * and notify_malloc is called this values is changed and new maximum
419  * is tested.
420  */
421  size_t current_allocated_;
422 
423  /**
424  * Number of times new/new[] operator was used in this scope
425  */
426  int alloc_called;
427  /**
428  * Number of times delete/delete[] operator was used in this scope
429  */
430  int dealloc_called;
431 
432  #ifdef FLOW123D_HAVE_PETSC
433  /**
434  * Number of bytes used by Petsc at the start of time-frame
435  */
436  PetscLogDouble petsc_start_memory;
437  /**
438  * Number of bytes used by Petsc at the end of time-frame
439  */
440  PetscLogDouble petsc_end_memory;
441  /**
442  * Difference between start and end of a petsc memory usage
443  */
444  PetscLogDouble petsc_memory_difference;
445  /**
446  * Maximum amount of memory used that was PetscMalloc()ed at any time
447  * during this run.
448  *
449  * The memory usage reported here includes all Fortran arrays (that may be
450  * used in application-defined sections of code).
451  */
452  PetscLogDouble petsc_peak_memory;
453  /**
454  * Local maximum amount of memory used that was PetscMalloc()ed
455  * used during time-frame pause/resume. Auxilary variable for storing
456  * local memory used when pause is called.
457  */
458  PetscLogDouble petsc_local_peak_memory;
459  #endif // FLOW123D_HAVE_PETSC
460 
461  friend class Profiler;
462  friend std::ostream & operator <<(std::ostream&, const Timer&);
463 
464  /**
465  * if under unit testing, specify friend so protected members can be tested
466  */
467  #ifdef __UNIT_TEST__
468  friend ProfilerTest;
469  #endif /* __UNIT_TEST__ */
470 
471 };
472 
473 /*
474 struct SimpleTranslator {
475  typedef std::string internal_type;
476  typedef int external_type;
477 
478  // Converts a string to int
479  boost::optional<external_type> get_value(const internal_type& str) {
480  return boost::optional<external_type>(std::stoi(str));
481  }
482 
483  // Converts a bool to string
484  boost::optional<internal_type> put_value(const external_type& i){
485  return boost::optional<internal_type>(std::to_string(i));
486  }
487 };
488 
489 namespace boost {
490 namespace property_tree {
491 
492 template<typename Ch, typename Traits, typename Alloc>
493 struct translator_between<std::basic_string< Ch, Traits, Alloc >, int> {
494  typedef SimpleTranslator type;
495 };
496 
497 
498 } // namespace property_tree
499 } // namespace boost
500 */
501 /**
502  *
503  * @brief Main class for profiling by measuring time intervals.
504  *
505  * These time intervals form a tree structure where each interval is represented
506  * by a Timer object. The root node of the tree is automatically created and
507  * started after creating the Profiler object and cannot be stopped manually.
508  *
509  * The class implements a singleton pattern and all the functions are accessible trough
510  * Profiler::instance(), but in most cases the programmer will access the profiler
511  * functions via the #START_TIMER and #END_TIMER macros. The #START_TIMER macro
512  * is responsible for the fact that we don't have to call #END_TIMER macro to stop the timer and
513  * the timer will be stopped at the end of the block in which #START_TIMER was used.
514  * These macros internally use the TimerFrame objects and the programmer should
515  * not use the TimerFrame objects directly.
516  *
517  * By using #SET_TIMER_SUBFRAMES macro, the programmer can specify the number of subframes (eg. iterations)
518  * for the currently active timer.
519  *
520  *
521  * Currently the Profiler system is not thread safe. No idea how to do this.
522  *
523  */
524 class Profiler {
525 public:
526  /**
527  * Returns unique Profiler object.
528  * if clear flag is set, will delete profiiler isntance
529  */
530  static Profiler* instance(bool clear = false);
531  /**
532  * Sets task specific information. The string @p description with textual description of the task and the
533  * number of elements of the mesh (parameter @p size). This is used for weak scaling graphs so it should
534  * measure size of the task of the same type (same description).
535  *
536  */
537  void set_task_info(string description, int size);
538  /**
539  * Sets informations about program version. This consists of @p program_version (includes program name), @p branch in the repository or rather full URL of the branch,
540  * and SVN @p revision (or hash for GIT).
541  *
542  */
543  void set_program_info(string program_name, string program_version, string branch, string revision, string build);
544 
545 
546  /**
547  * Starts a timer with code point, tag and hashes specified by CodePoint object @p cp.
548  * If the timer is not already created, it creates a new one. It returns index of
549  * the actual timer.
550  */
551  int start_timer(const CodePoint &cp);
552  /**
553  * Stops actual timer. It check if the hash of given code point match hash of the
554  * tag of actual timer node. If not we print out warning and try to find the correct tag
555  * towards the tree root closing all nodes we pass through.
556  *
557  * If FLOW123D_DEBUG is set, we check that all children are closed.
558  */
559  void stop_timer(const CodePoint &cp);
560 
561  /**
562  * Stop timer with index given by @p timer_index. If this is not equal to @p actual_node, we
563  * traverse the tree towards root while force closing nodes by the way.
564  *
565  * Negative @p timer_index means close @p actual_node
566  */
567  void stop_timer(int timer_index = -1);
568 
569  /**
570  * Adds @p n_calls - 1 to the total number of calls of the current timer. Minus one, since one call is counted when
571  * timer was started. You should use macro ADD_CALLS above.
572  */
573  void add_calls(unsigned int n_calls);
574  /**
575  * Notification about allocation of given size.
576  * Increase total allocated memory in current profiler frame.
577  */
578  void notify_malloc(const size_t size, const long p);
579  /**
580  * Notification about freeing memory of given size.
581  * Increase total deallocated memory in current profiler frame.
582  */
583  void notify_free(const long p);
584 
585  /**
586  * Return average profiler timer resolution in seconds
587  * based on 100 measurements
588  */
589  static double get_resolution ();
590 
591  /**
592  * Find a first timer matching the tag.
593  * O(n) complexity.
594  */
595  Timer find_timer(string tag);
596 
597 
598 
599 
600 #ifdef FLOW123D_HAVE_MPI
601  /**
602  * @brief Output current timing information into the given stream.
603  *
604  * COLECTIVE - all processes in the communicator have to call this
605  * method. All timers are finished, all processes are synchronized, collect
606  * profiling informations are collected and written to the given stream.
607  *
608  * Pass through the profiling tree (collective over processors)
609  * Print cumulative times average, balance (max/min), count (denote differences)
610  *
611  */
612  void output(MPI_Comm comm, std::ostream &os);
613 
614  /**
615  * Same as previous, but output to the file with default name: "profiler_info_YYMMDD_HH::MM:SS.log".
616  * Empty body if macro FLOW123D_DEBUG_PROFILER is not defined.
617  */
618  string output(MPI_Comm comm, string profiler_path = "");
619 
620 #endif /* FLOW123D_HAVE_MPI */
621  /**
622  * @brief Output current timing information into the given stream.
623  *
624  * It temporally stops all timers, synchronize all processes, collect
625  * profiling informations and write it to the given stream.
626  *
627  * Pass through the profiling tree (collective over processors)
628  * Print cumulative times average, balance (max/min), count (denote differences)
629  *
630  */
631  void output(std::ostream &os);
632 
633  /**
634  * Same as previous, but output to the file with default name: "profiler_info_YYMMDD_HH::MM:SS.log".
635  * Empty body if macro FLOW123D_DEBUG_PROFILER is not defined.
636  */
637  string output(string profiler_path = "");
638 
639  /**
640  * Method will transform last profiler json file to desired format
641  */
642 // void transform_profiler_data (const string &output_file_suffix, const string &formatter);
643  /**
644  * Stop all timers and destroys the Profiler object.
645  * If you want some output call @p output method just before.
646  */
647  static void uninitialize();
648 
649  /**
650  * Class-specific allocation function new. Called by the usual
651  * single-object new-expressions if allocating an object of type Profiler.
652  */
653  static void* operator new (size_t sz);
654  /**
655  * Class-specific allocation function delete. Deallocates storage
656  * previously allocated by a matching operator new. These deallocation
657  * functions are called by delete-expressions.
658  */
659  static void operator delete (void* p);
660  /// Sized deallocator, doesthe same as operator delete (void* p)
661  static void operator delete (void* p, std::size_t);
662 
663  /**
664  * Public setter to turn on/off memory monitoring
665  * @param global_monitor whether to turn global monitoring on or off
666  * @param petsc_monitor petsc monitoring
667  */
668  void static set_memory_monitoring(const bool global_monitor, const bool petsc_monitor);
669 
670  /**
671  * Public getter to memory monitoring
672  * @return memory monitoring status
673  */
674  inline bool static get_global_memory_monitoring() {
675  return global_monitor_memory;
676  }
677 
678  /**
679  * Public getter to petsc memory monitoring
680  * @return memory monitoring status
681  */
682  inline bool static get_petsc_memory_monitoring() {
683  return petsc_monitor_memory;
684  }
685 
686  /**
687  * Run calibration frame "UNIT PAYLOAD".
688  * That should be about 100x timer resolution.
689  */
690  void calibrate();
691 
692  /**
693  * Time of a unit payload, result of a single measurement. Can be used for raw calibration.
694  */
695  double calibration_time() {
696  if (calibration_time_ < 0) calibrate();
697  return calibration_time_;
698  }
699  /**
700  * if under unit testing, specify friend so protected members can be tested
701  */
702  #ifdef __UNIT_TEST__
703  friend ProfilerTest;
704  #endif /* __UNIT_TEST__ */
705 
706 
707 protected:
708 
709  /**
710  * Whether to monitor operator 'new/delete'
711  */
712  static bool global_monitor_memory;
713 
714  /**
715  * Whether to monitor petsc memory usage
716  */
717  static bool petsc_monitor_memory;
718 
719  /**
720  * When creating Profiler also reserve some bytes in malloc_map so overhead
721  * of creating single items is lowered. This value is passed as parameter in
722  * map.reserve() method so it indicates how many objects (pointers) are
723  * allocated at first.
724  */
725  static const long malloc_map_reserve;
726 
727 
728  /**
729  * Method will propagate values from children timers to its parents
730  */
731  void propagate_timers ();
732 
733  /**
734  * Method for exchanging metrics from child timer to its parent timer
735  */
736  void accept_from_child (Timer &parent, Timer &child);
737 
738  /**
739  * Try to find timer with tag (in fact only its 32-bit hash) from given code point @p cp.
740  * Returns -1 if it is not found otherwise it returns its index.
741  */
742  int find_child(const CodePoint &cp);
743 
744 
745  /**
746  * Method will prepare construct specific details about the run (time start and time end)
747  * and write them along with basic informations about the run (name, description, ...)
748  * into nlohmann:json object
749  */
750  void output_header (nlohmann::json &root, int mpi_size);
751 
752  /**
753  * Open a new file for profiler output with default name based on the
754  * actual time and date. Returns a pointer to the stream of the output file.
755  */
756  //std::shared_ptr<std::ostream> get_output_stream(string path);
757 
758  /// Vector of all timers. Whole tree is stored in this array.
760 
761  /// Index of the actual timer node. Negative value means 'unset'.
762  unsigned int actual_node;
763 
764  /// MPI communicator used for final reduce of the timer node tree.
765  //MPI_Comm communicator_;
766  /// MPI_rank
767  //int mpi_rank_;
768 
769  /**
770  * flag indicating that collection of timer details will be
771  * using MPI
772  bool mpi_used;
773  */
774  // header informations
775 
776  /// Some measure of the size of the task in the set of the tasks that differs
777  /// only by size - used for scaling tests.
778  int task_size_;
779  /// Task description and identifier in possible database of all Profiler results.
780  string task_description_;
781  /// Time and date of the start of the task solution. In fact start of the Profiler.
782  time_t start_time;
783 
784  /// Name of the program.
785  string flow_name_;
786  /// Version of the program.
787  string flow_version_;
788  /// Http address of the branch in a repository.
789  string flow_branch_;
790  /// Revision or GIT hash.
791  string flow_revision_;
792  /// Build date and time.
793  string flow_build_;
794  /// Variable which stores last json log filepath
795  //string json_filepath;
796 
797  Timer none_timer_;
798 
799  /// Time of a unit payload, result of single measurement. Can be used for raw calibration.
800  double calibration_time_;
801 
802 protected:
803  /**
804  * Use DFS to pass through the tree and collect information about all timers reduced from the processes in the communicator.
805  * For every timer the information strings are stored in the struct TimerInfo in order to pad fields correctly
806  * to have alligned columns on the output. The alligning is performed in the output() method.
807  */
808  template<typename ReduceFunctor>
809  void add_timer_info(ReduceFunctor reduce, nlohmann::json* node, int timer_idx, double parent_time);
810 
811  //Profiler(MPI_Comm comm); // private constructor
812  Profiler(); // private constructor
813  Profiler(Profiler const&); // copy constructor is private
814  Profiler & operator=(Profiler const&); // assignment operator is private
815 
816 };
817 
818 
819 
820 
821 
822 
823 /**
824  *
825  * @brief Class for automatic timer closing. This class is used by #START_TIMER macro
826  * and is responsible for the fact that we don't have to call #END_TIMER macro to stop the timer,
827  * the timer will be stopped at the end of the block in which #START_TIMER was used.
828  *
829  * The main idea of the approach described is that the TimerFrame variable will be destroyed
830  * at the end of the block where #START_TIMER macro was used. In order to work properly
831  * in situations where #END_TIMER was used to stop the timer manually before (but there is still the
832  * variable which will be later destroyed), we have to store references to these variables and
833  * destroy them on-demand.
834  *
835  * TODO:
836  * Should only contain pointer to the Timer. And destructor, that close the timer.
837  */
838 class TimerFrame {
839 private:
840  int const timer_index_;
841 public:
842  inline TimerFrame(const CodePoint &cp)
843  : timer_index_( Profiler::instance()->start_timer(cp) )
844  {}
845 
846  ~TimerFrame() {
847  Profiler::instance()->stop_timer(timer_index_);
848  }
849 };
850 
851 
852 /**
853  * Simple class providing static map variable storing address and alloc size
854  */
855 // gcc version 4.9 and lower has following bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59751
856 // fix in version 4.9: https://gcc.gnu.org/gcc-4.9/changes.html#cxx
857 // typedef unordered_map<long, int, hash<long>, equal_to<long>, internal::SimpleAllocator<pair<const long, int>>> unordered_map_with_alloc;
858 typedef std::unordered_map<long, int, boost::hash<long>, equal_to<long>, internal::SimpleAllocator<std::pair<const long, int>>> unordered_map_with_alloc;
859 class MemoryAlloc {
860 public:
861  /**
862  * Create static map containing <allocation address, allocation size> pairs
863  * map is used for storing allocations and deallocations of all object not
864  * related to profiler after profiler initialization phase
865  */
866  static unordered_map_with_alloc & malloc_map();
867 };
868 
869 
870 
871 
872 #else // FLOW123D_DEBUG_PROFILER
873 
874 
875 // dummy declaration of Profiler class
876 class Profiler {
877 public:
878  static Profiler* instance(bool clear = false);
879 
880  void set_task_info(string, int)
881  {}
882  void set_program_info(string, string, string, string, string)
883  {}
884  void notify_malloc(const size_t )
885  {}
886  void notify_free(const size_t )
887  {}
888  void output(MPI_Comm, ostream &)
889  {}
890  string output(MPI_Comm, string)
891  {return "";}
892  void output(std::ostream &)
893  {}
894  string output(string)
895  {return "";}
896 // void output(MPI_Comm)
897 // {}
898 // string output()
899 // {}
900 // void transform_profiler_data(const string &, const string &)
901 // {}
902  double get_resolution () const
903  { return 0.0; }
904  const char *actual_tag() const
905  { return NULL; }
906  inline unsigned int actual_count() const
907  { return 0; }
908  inline double actual_cumulative_time() const
909  { return 0.0; }
910  static void uninitialize();
911  void calibrate();
912  double calibration_time() {
913  return -2;
914  }
915 private:
916  Profiler() {}
917 };
918 
919 
920 
921 
922 #endif
923 
924 
925 #endif
926 
static int sum(int *val, MPI_Comm comm)
Definition: sys_profiler.cc:42
static int min(int *val, MPI_Comm comm)
Definition: sys_profiler.cc:60
static int max(int *val, MPI_Comm comm)
Definition: sys_profiler.cc:78
double calibration_time()
void notify_malloc(const size_t)
void output(MPI_Comm, ostream &)
void notify_free(const size_t)
static Profiler * instance(bool clear=false)
double actual_cumulative_time() const
void output(std::ostream &)
string output(string)
unsigned int actual_count() const
void set_program_info(string, string, string, string, string)
const char * actual_tag() const
string output(MPI_Comm, string)
void set_task_info(string, int)
void calibrate()
double get_resolution() const
Definition: memory.cc:33
a class to store JSON values
Definition: json.hpp:174
Global macros to enhance readability and debugging, general constants.
int MPI_Comm
Definition: mpi.h:141
#define CONSTEXPR_
Definition: sys_profiler.hh:86
STREAM & operator<<(STREAM &s, UpdateFlags u)