CASToR  3.2
Tomographic Reconstruction (PET/SPECT/CT)
src/management/sChronoManager.cc
Go to the documentation of this file.
1 
9 #include "sChronoManager.hh"
10 
11 // =====================================================================
12 // ---------------------------------------------------------------------
13 // ---------------------------------------------------------------------
14 // =====================================================================
15 
16 sChronoManager* sChronoManager::mp_Instance = NULL;
17 
18 // =====================================================================
19 // ---------------------------------------------------------------------
20 // ---------------------------------------------------------------------
21 // =====================================================================
22 
23 sChronoManager::sChronoManager()
24 {
25  // Simply default all members
26  mp_Instance = NULL;
27  m_nbThreadsForProjection = 0;
28  m_nbThreadsForImageComputation = 0;
29  m_nbThreadsMax = 0;
30  // Permanent profiled steps
31  mp_durationIterativeDataUpdateStep1 = NULL;
32  mp_durationIterativeDataUpdateStep2 = NULL;
33  mp_durationIterativeDataUpdateStep3 = NULL;
34  mp_durationIterativeDataUpdateStep4 = NULL;
35  mp_startIterativeDataUpdateStep1 = NULL;
36  mp_startIterativeDataUpdateStep2 = NULL;
37  mp_startIterativeDataUpdateStep3 = NULL;
38  mp_startIterativeDataUpdateStep4 = NULL;
39  // Custom profiled steps
40  m_nbCustomSteps = 0;
41  mpp_durationCustomSteps = NULL;
42  mpp_startCustomSteps = NULL;
43  // Verbose
44  m_verbose = 0;
45 }
46 
47 // =====================================================================
48 // ---------------------------------------------------------------------
49 // ---------------------------------------------------------------------
50 // =====================================================================
51 
52 int sChronoManager::CheckParameters()
53 {
54  // Check number of threads
55  if (m_nbThreadsForProjection<=0)
56  {
57  Cerr("***** sChronoManager::CheckParameters() -> Number of threads for projections is incorrectly set !" << endl);
58  return 1;
59  }
60  if (m_nbThreadsForImageComputation<=0)
61  {
62  Cerr("***** sChronoManager::CheckParameters() -> Number of threads for image computation is incorrectly set !" << endl);
63  return 1;
64  }
65  // Check number of custom steps
66  if (m_nbCustomSteps<0)
67  {
68  Cerr("***** sChronoManager::CheckParameters() -> Number of custom steps is incorrectly set !" << endl);
69  return 1;
70  }
71  // Verbose
72  if (m_verbose<0)
73  {
74  Cerr("***** sChronoManager::CheckParameters() -> Verbose cannot be negative !" << endl);
75  return 1;
76  }
77  // Normal end
78  return 0;
79 }
80 
81 // =====================================================================
82 // ---------------------------------------------------------------------
83 // ---------------------------------------------------------------------
84 // =====================================================================
85 
86 int sChronoManager::Initialize()
87 {
88  // Verbose
89  if (m_verbose>=VERBOSE_LIGHT) Cout("sChronoManager::Initialize() -> Initialize all duration counters for profiling" << endl);
90  // Initialize buffers for data update steps
91  mp_durationIterativeDataUpdateStep1 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
92  mp_durationIterativeDataUpdateStep2 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
93  mp_durationIterativeDataUpdateStep3 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
94  mp_durationIterativeDataUpdateStep4 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
95  mp_startIterativeDataUpdateStep1 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
96  mp_startIterativeDataUpdateStep2 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
97  mp_startIterativeDataUpdateStep3 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
98  mp_startIterativeDataUpdateStep4 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
99  for (int th=0; th<m_nbThreadsForProjection; th++)
100  {
101  mp_durationIterativeDataUpdateStep1[th] = chrono::duration<int64_t,nano>::zero();
102  mp_durationIterativeDataUpdateStep2[th] = chrono::duration<int64_t,nano>::zero();
103  mp_durationIterativeDataUpdateStep3[th] = chrono::duration<int64_t,nano>::zero();
104  mp_durationIterativeDataUpdateStep4[th] = chrono::duration<int64_t,nano>::zero();
105  }
106  // Initialize convolution
107  m_durationConvolution = chrono::duration<int64_t,nano>::zero();
108  // Initialize buffers for custom profiling
109  if (m_nbCustomSteps>0)
110  {
111  mpp_durationCustomSteps = (DurationNano**)malloc(m_nbCustomSteps*sizeof(DurationNano*));
112  mpp_startCustomSteps = (ChronoTime**)malloc(m_nbCustomSteps*sizeof(ChronoTime*));
113  for (int nb=0; nb<m_nbCustomSteps; nb++)
114  {
115  mpp_durationCustomSteps[nb] = (DurationNano*)malloc(m_nbThreadsMax*sizeof(DurationNano));
116  mpp_startCustomSteps[nb] = (ChronoTime*)malloc(m_nbThreadsMax*sizeof(ChronoTime));
117  for (int th=0; th<m_nbThreadsMax; th++) mpp_durationCustomSteps[nb][th] = chrono::duration<int64_t,nano>::zero();
118  }
119  }
120  // Normal end
121  return 0;
122 }
123 
124 // =====================================================================
125 // ---------------------------------------------------------------------
126 // ---------------------------------------------------------------------
127 // =====================================================================
128 
129 void sChronoManager::Display()
130 {
131  if (m_verbose>=VERBOSE_LIGHT)
132  {
133  // Verbose
134  Cout("sChronoManager::Display() -> Results from the profiling" << endl);
135  // Sum over all threads
136  for (int th=1; th<m_nbThreadsForProjection; th++)
137  {
138  mp_durationIterativeDataUpdateStep1[0] += mp_durationIterativeDataUpdateStep1[th];
139  mp_durationIterativeDataUpdateStep2[0] += mp_durationIterativeDataUpdateStep2[th];
140  mp_durationIterativeDataUpdateStep3[0] += mp_durationIterativeDataUpdateStep3[th];
141  mp_durationIterativeDataUpdateStep4[0] += mp_durationIterativeDataUpdateStep4[th];
142  }
143  for (int nb=0; nb<m_nbCustomSteps; nb++) for (int th=1; th<m_nbThreadsMax; th++)
144  mpp_durationCustomSteps[nb][0] += mpp_durationCustomSteps[nb][th];
145  // Divide by number of threads (not for the custom steps as we cannot know if they are multi-threaded
146  // using the number of threads for projection or image computation)
147  mp_durationIterativeDataUpdateStep1[0] /= m_nbThreadsForProjection;
148  mp_durationIterativeDataUpdateStep2[0] /= m_nbThreadsForProjection;
149  mp_durationIterativeDataUpdateStep3[0] /= m_nbThreadsForProjection;
150  mp_durationIterativeDataUpdateStep4[0] /= m_nbThreadsForProjection;
151  // Display data update steps
152  Cout(" --> Profiling of the data update step:" << endl);
153  Cout(" | Datafile management: " << setfill( '0' )
154  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep1[0] ).count() << " hours "
155  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep1[0] % Hs( 1 ) ).count() << " mins "
156  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep1[0] % Mins( 1 ) ).count() << " secs "
157  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep1[0] % Secs( 1 ) ).count() << " ms" << endl);
158  Cout(" | Dynamic management: " << setfill( '0' )
159  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep2[0] ).count() << " hours "
160  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep2[0] % Hs( 1 ) ).count() << " mins "
161  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep2[0] % Mins( 1 ) ).count() << " secs "
162  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep2[0] % Secs( 1 ) ).count() << " ms" << endl);
163  Cout(" | Projection management: " << setfill( '0' )
164  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep3[0] ).count() << " hours "
165  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep3[0] % Hs( 1 ) ).count() << " mins "
166  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep3[0] % Mins( 1 ) ).count() << " secs "
167  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep3[0] % Secs( 1 ) ).count() << " ms" << endl);
168  Cout(" | Optimizer management: " << setfill( '0' )
169  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep4[0] ).count() << " hours "
170  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep4[0] % Hs( 1 ) ).count() << " mins "
171  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep4[0] % Mins( 1 ) ).count() << " secs "
172  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep4[0] % Secs( 1 ) ).count() << " ms" << endl);
173  // Display convolution performances
174  Cout(" --> Profiling of the convolution steps: " << setfill( '0' )
175  << setw( 2 ) << chrono::duration_cast<Hs> ( m_durationConvolution ).count() << " hours "
176  << setw( 2 ) << chrono::duration_cast<Mins>( m_durationConvolution % Hs( 1 ) ).count() << " mins "
177  << setw( 2 ) << chrono::duration_cast<Secs>( m_durationConvolution % Mins( 1 ) ).count() << " secs "
178  << setw( 3 ) << chrono::duration_cast<Ms> ( m_durationConvolution % Secs( 1 ) ).count() << " ms" << endl);
179  // Display custom update steps
180  for (int nb=0; nb<m_nbCustomSteps; nb++)
181  {
182  Cout(" --> Custom update step " << nb+1 << ": " << setfill( '0' )
183  << setw( 2 ) << chrono::duration_cast<Hs> ( mpp_durationCustomSteps[nb][0] ).count() << " hours "
184  << setw( 2 ) << chrono::duration_cast<Mins>( mpp_durationCustomSteps[nb][0] % Hs( 1 ) ).count() << " mins "
185  << setw( 2 ) << chrono::duration_cast<Secs>( mpp_durationCustomSteps[nb][0] % Mins( 1 ) ).count() << " secs "
186  << setw( 3 ) << chrono::duration_cast<Ms> ( mpp_durationCustomSteps[nb][0] % Secs( 1 ) ).count() << " ms" << endl);
187  }
188  }
189 }
190 
191 // =====================================================================
192 // ---------------------------------------------------------------------
193 // ---------------------------------------------------------------------
194 // =====================================================================
Secs
std::chrono::seconds Secs
Definition: code/include/management/sChronoManager.hh:18
Cerr
#define Cerr(MESSAGE)
Definition: code/include/management/sOutputManager.hh:90
sChronoManager::CheckParameters
int CheckParameters()
Check validity of all parameters.
Definition: code/src/management/sChronoManager.cc:52
ChronoTime
std::chrono::time_point< std::chrono::system_clock > ChronoTime
Definition: code/include/management/sChronoManager.hh:15
sChronoManager::sChronoManager
sChronoManager()
The constructor of sChronoManager.
Definition: code/src/management/sChronoManager.cc:23
Hs
std::chrono::hours Hs
Definition: code/include/management/sChronoManager.hh:20
sChronoManager::Initialize
int Initialize()
Initialize all thread-safe buffers for profiling.
Definition: code/src/management/sChronoManager.cc:86
DurationNano
std::chrono::duration< int64_t, std::nano > DurationNano
Definition: code/include/management/sChronoManager.hh:16
sChronoManager
This class is designed to manage some profiling of the code.
Definition: code/include/management/sChronoManager.hh:27
Mins
std::chrono::minutes Mins
Definition: code/include/management/sChronoManager.hh:19
Cout
#define Cout(MESSAGE)
Definition: code/include/management/sOutputManager.hh:78
sChronoManager::Display
void Display()
Display the results of the duration buffers.
Definition: code/src/management/sChronoManager.cc:129
Generated on Tue Oct 22 2024 21:49:44 for CASToR by   doxygen 1.8.13