logs.h

Go to the documentation of this file.

/*******************************************************************************
 * \copyright   This file is part of the GADGET4 N-body/SPH code developed
 * \copyright   by Volker Springel. Copyright (C) 2014-2020 by Volker Springel
 * \copyright   (vspringel@mpa-garching.mpg.de) and all contributing authors.
 *******************************************************************************/
 
#ifndef LOGS_H
#define LOGS_H
 
#include <stdio.h>
 
#include "../main/simulation.h"
#include "../mpi_utils/setcomm.h"
 
#define CPU_STRING_LEN 120
 
#define TIMER_STACK_DEPTH 30
 
class simparticles;
class lcparticles;
 
class logs : public setcomm
{
 public:
  logs() : setcomm("delayed init")  // constructor
  {
 
#define TIMER_STRUCT
#include "../logs/timer.h"
#undef TIMER_STRUCT
 
  }
 
 
 
  simparticles *Sp;
 
  double CPUThisRun; 
  FILE *FdInfo,   
      *FdEnergy,  
      *FdTimings, 
      *FdDensity, 
      *FdHydro,   
      *FdBalance, 
      *FdTimebin, 
      *FdDomain,  
      *FdCPU;     
  FILE *FdCPUCSV; 
#ifdef MEASURE_TOTAL_MOMENTUM
  FILE *FdMomentum;
#endif
 
#ifdef STARFORMATION
  FILE *FdSfr; 
#endif
 
#ifdef DEBUG_MD5
  FILE *FdDebug; 
#endif
 
#ifdef FORCETEST
  FILE *FdForceTest; 
#endif
 
  void init_cpu_log(simparticles *Sp_ptr);
  void open_logfiles(void);
  void write_cpu_log(void);
  void output_log_messages(void);
  void compute_statistics(void);
  void print_particle_info_from_ID(MyIDType ID);
  void print_particle_info(int i);
  void log_debug_md5(const char *msg);
  void calc_memory_checksum(const char *msg, void *base, size_t bytes);
  void block_checksum(void *base, size_t bytes, int res[4]);
  int flush_everything(void);
  void compute_total_momentum(void);
 
  double measure_time(void);
  double timediff(double t0, double t1);
  double second(void);
 
  enum timers
  {
    CPU_NONE = -2, 
    CPU_ROOT = -1, 
#define TIMER_ENUM
#include "../logs/timer.h"
#undef TIMER_ENUM
 
  };
 
  struct timer_d
  {
    int parent;         
    char shortname[30]; 
    char longname[30];  
    char symb;          
    char symbImbal;     
    char depth;         
  };
  timer_d Timer_data[CPU_LAST + 1];
 
  double CPU_Step[CPU_LAST];
  double CPU_Step_Stored[CPU_LAST];
  double CPU_Sum[CPU_LAST]; 
  enum timers TimerStack[TIMER_STACK_DEPTH];
  int TimerStackPos = 0;
 
 private:
  double StartOfRun; 
  double WallclockTime; 
  void put_symbol(char *string, double t0, double t1, char c);
 
  /* global state of system */
  struct state_of_system
  {
    double Mass, EnergyKin, EnergyPot, EnergyInt, EnergyTot, Momentum[4], AngMomentum[4], CenterOfMass[4], MassComp[NTYPES],
        EnergyKinComp[NTYPES], EnergyPotComp[NTYPES], EnergyIntComp[NTYPES], EnergyTotComp[NTYPES], MomentumComp[NTYPES][4],
        AngMomentumComp[NTYPES][4], CenterOfMassComp[NTYPES][4];
  };
  state_of_system SysState;
 
  void compute_global_quantities_of_system(void);
 
 public:
  void timer_stop(enum timers counter)
  {
    if(TimerStack[TimerStackPos] != counter)
      Terminate("Wrong use of timer_stop(), you must stop the timer started last");
 
    CPU_Step[TimerStack[TimerStackPos--]] += measure_time();
 
    if(TimerStackPos < 0)
      Terminate("Do not stop the out CPU_MISC timer");
  }
 
  void timer_start(enum timers counter)
  {
    CPU_Step[TimerStack[TimerStackPos]] += measure_time();
 
    for(int itimer = 0; itimer <= TimerStackPos; itimer++)
      if(counter == TimerStack[itimer])
        Terminate("Try to start timer %d, but it is already running.\n", counter);
 
    if(++TimerStackPos >= TIMER_STACK_DEPTH)
      {
        Terminate("Run out of timer stack space, increase TIMER_STACK_DEPTH");
      }
    else
      TimerStack[TimerStackPos] = counter;
  }
};
 
#include "../data/simparticles.h"
 
#define TIMER_START_INTERNAL(counter)                                                      \
  {                                                                                        \
    Logs.CPU_Step[Logs.TimerStack[Logs.TimerStackPos]] += Logs.measure_time();             \
    for(int itimer = 0; itimer <= Logs.TimerStackPos; itimer++)                            \
      if(logs::counter == Logs.TimerStack[itimer])                                         \
        {                                                                                  \
          Terminate("Try to start timer %d, but it is already running.\n", logs::counter); \
        };                                                                                 \
    if(++Logs.TimerStackPos >= TIMER_STACK_DEPTH)                                          \
      {                                                                                    \
        Terminate("Run out of timer stack space, increase TIMER_STACK_DEPTH");             \
      }                                                                                    \
    else                                                                                   \
      {                                                                                    \
        Logs.TimerStack[Logs.TimerStackPos] = logs::counter;                               \
      }                                                                                    \
  }
 
#define TIMER_START(counter) TIMER_START_INTERNAL(counter)
 
#define TIMER_STOP_INTERNAL(counter)                                                \
  {                                                                                 \
    if(Logs.TimerStack[Logs.TimerStackPos] != logs::counter)                        \
      {                                                                             \
        Terminate("Wrong use of TIMER_STOP, you must stop the timer started last"); \
      }                                                                             \
    Logs.CPU_Step[Logs.TimerStack[Logs.TimerStackPos--]] += Logs.measure_time();    \
    if(Logs.TimerStackPos < 0)                                                      \
      {                                                                             \
        Terminate("Do not stop the out CPU_MISC timer");                            \
      }                                                                             \
  }
 
#define TIMER_STOP(counter) TIMER_STOP_INTERNAL(counter)
 
#define TIMER_STOPSTART(stop, start) \
  {                                  \
    TIMER_STOP_INTERNAL(stop);       \
    TIMER_START_INTERNAL(start);     \
  }
 
#define TIMER_ADD(counter, amount) Logs.CPU_Step[counter] += (amount);
 
#define TIMER_DIFF(counter) (Logs.CPU_Step[logs::counter] - Logs.CPU_Step_Stored[logs::counter])
 
#define TIMER_STORE memcpy(Logs.CPU_Step_Stored, Logs.CPU_Step, sizeof(Logs.CPU_Step));
 
extern logs Logs;
 
#endif