CASToR  2.0
Tomographic Reconstruction (PET/SPECT/CT)
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sChronoManager.cc
Go to the documentation of this file.
1 /*
2 This file is part of CASToR.
3 
4  CASToR is free software: you can redistribute it and/or modify it under the
5  terms of the GNU General Public License as published by the Free Software
6  Foundation, either version 3 of the License, or (at your option) any later
7  version.
8 
9  CASToR is distributed in the hope that it will be useful, but WITHOUT ANY
10  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12  details.
13 
14  You should have received a copy of the GNU General Public License along with
15  CASToR (in file GNU_GPL.TXT). If not, see <http://www.gnu.org/licenses/>.
16 
17 Copyright 2017-2018 all CASToR contributors listed below:
18 
19  --> current contributors: Thibaut MERLIN, Simon STUTE, Didier BENOIT, Claude COMTAT, Marina FILIPOVIC, Mael MILLARDET
20  --> past contributors: Valentin VIELZEUF
21 
22 This is CASToR version 2.0.
23 */
24 
32 #include "sChronoManager.hh"
33 
34 // =====================================================================
35 // ---------------------------------------------------------------------
36 // ---------------------------------------------------------------------
37 // =====================================================================
38 
39 sChronoManager* sChronoManager::mp_Instance = NULL;
40 
41 // =====================================================================
42 // ---------------------------------------------------------------------
43 // ---------------------------------------------------------------------
44 // =====================================================================
45 
46 sChronoManager::sChronoManager()
47 {
48  // Simply default all members
49  mp_Instance = NULL;
50  m_nbThreadsForProjection = 0;
51  m_nbThreadsForImageComputation = 0;
52  m_nbThreadsMax = 0;
53  // Permanent profiled steps
54  mp_durationIterativeDataUpdateStep1 = NULL;
55  mp_durationIterativeDataUpdateStep2 = NULL;
56  mp_durationIterativeDataUpdateStep3 = NULL;
57  mp_durationIterativeDataUpdateStep4 = NULL;
58  mp_startIterativeDataUpdateStep1 = NULL;
59  mp_startIterativeDataUpdateStep2 = NULL;
60  mp_startIterativeDataUpdateStep3 = NULL;
61  mp_startIterativeDataUpdateStep4 = NULL;
62  // Custom profiled steps
63  m_nbCustomSteps = 0;
64  mpp_durationCustomSteps = NULL;
65  mpp_startCustomSteps = NULL;
66  // Verbose
67  m_verbose = 0;
68 }
69 
70 // =====================================================================
71 // ---------------------------------------------------------------------
72 // ---------------------------------------------------------------------
73 // =====================================================================
74 
75 int sChronoManager::CheckParameters()
76 {
77  // Check number of threads
78  if (m_nbThreadsForProjection<=0)
79  {
80  Cerr("***** sChronoManager::CheckParameters() -> Number of threads for projections is incorrectly set !" << endl);
81  return 1;
82  }
83  if (m_nbThreadsForImageComputation<=0)
84  {
85  Cerr("***** sChronoManager::CheckParameters() -> Number of threads for image computation is incorrectly set !" << endl);
86  return 1;
87  }
88  // Check number of custom steps
89  if (m_nbCustomSteps<0)
90  {
91  Cerr("***** sChronoManager::CheckParameters() -> Number of custom steps is incorrectly set !" << endl);
92  return 1;
93  }
94  // Verbose
95  if (m_verbose<0)
96  {
97  Cerr("***** sChronoManager::CheckParameters() -> Verbose cannot be negative !" << endl);
98  return 1;
99  }
100  // Normal end
101  return 0;
102 }
103 
104 // =====================================================================
105 // ---------------------------------------------------------------------
106 // ---------------------------------------------------------------------
107 // =====================================================================
108 
109 int sChronoManager::Initialize()
110 {
111  // Verbose
112  if (m_verbose>=VERBOSE_LIGHT) Cout("sChronoManager::Initialize() -> Initialize all duration counters for profiling" << endl);
113  // Initialize buffers for data update steps
114  mp_durationIterativeDataUpdateStep1 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
115  mp_durationIterativeDataUpdateStep2 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
116  mp_durationIterativeDataUpdateStep3 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
117  mp_durationIterativeDataUpdateStep4 = (DurationNano*)malloc(m_nbThreadsForProjection*sizeof(DurationNano));
118  mp_startIterativeDataUpdateStep1 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
119  mp_startIterativeDataUpdateStep2 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
120  mp_startIterativeDataUpdateStep3 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
121  mp_startIterativeDataUpdateStep4 = (ChronoTime*)malloc(m_nbThreadsForProjection*sizeof(ChronoTime));
122  for (int th=0; th<m_nbThreadsForProjection; th++)
123  {
124  mp_durationIterativeDataUpdateStep1[th] = chrono::duration<int64_t,nano>::zero();
125  mp_durationIterativeDataUpdateStep2[th] = chrono::duration<int64_t,nano>::zero();
126  mp_durationIterativeDataUpdateStep3[th] = chrono::duration<int64_t,nano>::zero();
127  mp_durationIterativeDataUpdateStep4[th] = chrono::duration<int64_t,nano>::zero();
128  }
129  // Initialize convolution
130  m_durationConvolution = chrono::duration<int64_t,nano>::zero();
131  // Initialize buffers for custom profiling
132  if (m_nbCustomSteps>0)
133  {
134  mpp_durationCustomSteps = (DurationNano**)malloc(m_nbCustomSteps*sizeof(DurationNano*));
135  mpp_startCustomSteps = (ChronoTime**)malloc(m_nbCustomSteps*sizeof(ChronoTime*));
136  for (int nb=0; nb<m_nbCustomSteps; nb++)
137  {
138  mpp_durationCustomSteps[nb] = (DurationNano*)malloc(m_nbThreadsMax*sizeof(DurationNano));
139  mpp_startCustomSteps[nb] = (ChronoTime*)malloc(m_nbThreadsMax*sizeof(ChronoTime));
140  for (int th=0; th<m_nbThreadsMax; th++) mpp_durationCustomSteps[nb][th] = chrono::duration<int64_t,nano>::zero();
141  }
142  }
143  // Normal end
144  return 0;
145 }
146 
147 // =====================================================================
148 // ---------------------------------------------------------------------
149 // ---------------------------------------------------------------------
150 // =====================================================================
151 
152 void sChronoManager::Display()
153 {
154  if (m_verbose>=VERBOSE_LIGHT)
155  {
156  // Verbose
157  Cout("sChronoManager::Display() -> Results from the profiling" << endl);
158  // Sum over all threads
159  for (int th=1; th<m_nbThreadsForProjection; th++)
160  {
161  mp_durationIterativeDataUpdateStep1[0] += mp_durationIterativeDataUpdateStep1[th];
162  mp_durationIterativeDataUpdateStep2[0] += mp_durationIterativeDataUpdateStep2[th];
163  mp_durationIterativeDataUpdateStep3[0] += mp_durationIterativeDataUpdateStep3[th];
164  mp_durationIterativeDataUpdateStep4[0] += mp_durationIterativeDataUpdateStep4[th];
165  }
166  for (int nb=0; nb<m_nbCustomSteps; nb++) for (int th=1; th<m_nbThreadsMax; th++)
167  mpp_durationCustomSteps[nb][0] += mpp_durationCustomSteps[nb][th];
168  // Divide by number of threads (not for the custom steps as we cannot know if they are multi-threaded
169  // using the number of threads for projection or image computation)
170  mp_durationIterativeDataUpdateStep1[0] /= m_nbThreadsForProjection;
171  mp_durationIterativeDataUpdateStep2[0] /= m_nbThreadsForProjection;
172  mp_durationIterativeDataUpdateStep3[0] /= m_nbThreadsForProjection;
173  mp_durationIterativeDataUpdateStep4[0] /= m_nbThreadsForProjection;
174  // Display data update steps
175  Cout(" --> Profiling of the data update step:" << endl);
176  Cout(" | Datafile management: " << setfill( '0' )
177  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep1[0] ).count() << " hours "
178  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep1[0] % Hs( 1 ) ).count() << " mins "
179  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep1[0] % Mins( 1 ) ).count() << " secs "
180  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep1[0] % Secs( 1 ) ).count() << " ms" << endl);
181  Cout(" | Dynamic management: " << setfill( '0' )
182  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep2[0] ).count() << " hours "
183  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep2[0] % Hs( 1 ) ).count() << " mins "
184  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep2[0] % Mins( 1 ) ).count() << " secs "
185  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep2[0] % Secs( 1 ) ).count() << " ms" << endl);
186  Cout(" | Projection management: " << setfill( '0' )
187  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep3[0] ).count() << " hours "
188  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep3[0] % Hs( 1 ) ).count() << " mins "
189  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep3[0] % Mins( 1 ) ).count() << " secs "
190  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep3[0] % Secs( 1 ) ).count() << " ms" << endl);
191  Cout(" | Optimizer management: " << setfill( '0' )
192  << setw( 2 ) << chrono::duration_cast<Hs> ( mp_durationIterativeDataUpdateStep4[0] ).count() << " hours "
193  << setw( 2 ) << chrono::duration_cast<Mins>( mp_durationIterativeDataUpdateStep4[0] % Hs( 1 ) ).count() << " mins "
194  << setw( 2 ) << chrono::duration_cast<Secs>( mp_durationIterativeDataUpdateStep4[0] % Mins( 1 ) ).count() << " secs "
195  << setw( 3 ) << chrono::duration_cast<Ms> ( mp_durationIterativeDataUpdateStep4[0] % Secs( 1 ) ).count() << " ms" << endl);
196  // Display convolution performances
197  Cout(" --> Profiling of the convolution steps: " << setfill( '0' )
198  << setw( 2 ) << chrono::duration_cast<Hs> ( m_durationConvolution ).count() << " hours "
199  << setw( 2 ) << chrono::duration_cast<Mins>( m_durationConvolution % Hs( 1 ) ).count() << " mins "
200  << setw( 2 ) << chrono::duration_cast<Secs>( m_durationConvolution % Mins( 1 ) ).count() << " secs "
201  << setw( 3 ) << chrono::duration_cast<Ms> ( m_durationConvolution % Secs( 1 ) ).count() << " ms" << endl);
202  // Display custom update steps
203  for (int nb=0; nb<m_nbCustomSteps; nb++)
204  {
205  Cout(" --> Custom update step " << nb+1 << ": " << setfill( '0' )
206  << setw( 2 ) << chrono::duration_cast<Hs> ( mpp_durationCustomSteps[nb][0] ).count() << " hours "
207  << setw( 2 ) << chrono::duration_cast<Mins>( mpp_durationCustomSteps[nb][0] % Hs( 1 ) ).count() << " mins "
208  << setw( 2 ) << chrono::duration_cast<Secs>( mpp_durationCustomSteps[nb][0] % Mins( 1 ) ).count() << " secs "
209  << setw( 3 ) << chrono::duration_cast<Ms> ( mpp_durationCustomSteps[nb][0] % Secs( 1 ) ).count() << " ms" << endl);
210  }
211  }
212 }
213 
214 // =====================================================================
215 // ---------------------------------------------------------------------
216 // ---------------------------------------------------------------------
217 // =====================================================================
sChronoManager::mp_startIterativeDataUpdateStep3
ChronoTime * mp_startIterativeDataUpdateStep3
Definition: sChronoManager.hh:234
sChronoManager::m_nbThreadsForImageComputation
int m_nbThreadsForImageComputation
Definition: sChronoManager.hh:225
sChronoManager::CheckParameters
int CheckParameters()
Check validity of all parameters.
Definition: sChronoManager.cc:75
Secs
std::chrono::seconds Secs
Definition: sChronoManager.hh:41
sChronoManager::sChronoManager
sChronoManager()
The constructor of sChronoManager.
Definition: sChronoManager.cc:46
Hs
std::chrono::hours Hs
Definition: sChronoManager.hh:43
sChronoManager::mp_durationIterativeDataUpdateStep2
DurationNano * mp_durationIterativeDataUpdateStep2
Definition: sChronoManager.hh:229
ChronoTime
std::chrono::time_point< std::chrono::system_clock > ChronoTime
Definition: sChronoManager.hh:38
DurationNano
std::chrono::duration< int64_t, std::nano > DurationNano
Definition: sChronoManager.hh:39
Mins
std::chrono::minutes Mins
Definition: sChronoManager.hh:42
sChronoManager::mpp_startCustomSteps
ChronoTime ** mpp_startCustomSteps
Definition: sChronoManager.hh:241
sChronoManager::mp_startIterativeDataUpdateStep4
ChronoTime * mp_startIterativeDataUpdateStep4
Definition: sChronoManager.hh:235
sChronoManager::m_durationConvolution
DurationNano m_durationConvolution
Definition: sChronoManager.hh:236
sChronoManager::mp_Instance
static sChronoManager * mp_Instance
Definition: sChronoManager.hh:217
sChronoManager::mp_durationIterativeDataUpdateStep1
DurationNano * mp_durationIterativeDataUpdateStep1
Definition: sChronoManager.hh:228
Cerr
#define Cerr(MESSAGE)
Definition: sOutputManager.hh:113
sChronoManager::mp_durationIterativeDataUpdateStep3
DurationNano * mp_durationIterativeDataUpdateStep3
Definition: sChronoManager.hh:230
sChronoManager::mp_durationIterativeDataUpdateStep4
DurationNano * mp_durationIterativeDataUpdateStep4
Definition: sChronoManager.hh:231
VERBOSE_LIGHT
#define VERBOSE_LIGHT
Definition: sOutputManager.hh:130
sChronoManager::Initialize
int Initialize()
Initialize all thread-safe buffers for profiling.
Definition: sChronoManager.cc:109
sChronoManager::mp_startIterativeDataUpdateStep1
ChronoTime * mp_startIterativeDataUpdateStep1
Definition: sChronoManager.hh:232
sChronoManager.hh
Declaration of class sChronoManager.
sChronoManager::mpp_durationCustomSteps
DurationNano ** mpp_durationCustomSteps
Definition: sChronoManager.hh:240
Cout
#define Cout(MESSAGE)
Definition: sOutputManager.hh:101
sChronoManager
This class is designed to manage some profiling of the code.
Definition: sChronoManager.hh:50
sChronoManager::mp_startIterativeDataUpdateStep2
ChronoTime * mp_startIterativeDataUpdateStep2
Definition: sChronoManager.hh:233
sChronoManager::Display
void Display()
Display the results of the duration buffers.
Definition: sChronoManager.cc:152
Generated on Mon Apr 23 2018 18:04:33 for CASToR by   doxygen 1.8.6