NeoPZ
stats_recorder.h
Go to the documentation of this file.
1 
5 #ifndef STATS_RECORDER_H
6 
7 #ifndef VC
8 #define HAS_GETRUSAGE
9 #endif
10 
11 #include<sstream> // stringstream
12 #include<string.h> // memset
13 
100 using namespace std;
101 
102 #include<csvtable.h>
103 
107 class RunStat
108 {
109 public:
110  /* Start recording the execution statistics. */
111  virtual void start() = 0;
112  /* Stop recording the execution statistics and accumulate the partial result. */
113  virtual void stop() = 0;
114 
115  virtual ~RunStat()
116  {
117 
118  }
122  virtual void print(ostream& os) const = 0;
130  virtual int setCellValues(CSVStringTable& st, unsigned row) const = 0;
131 
135  virtual void clearStats() = 0;
136 };
137 
138 #ifdef USING_PAPI
139 #include <papi.h>
140 class PAPIRunStat : public RunStat
141 {
142 public:
143 
144  PAPIRunStat()
145  {
146  clearStats();
147  }
148 
149  /* Start recording the execution statistics. */
150  void start()
151  {
152  PAPI_flops ( &rtimeS, &ptimeS, &flpopsS, &mflopsS);
153  }
154 
155  /* Stop recording the execution statistics. */
156  void stop()
157  {
158  float rtimeP, ptimeP, mflopsP;
159  int64_t flpopsP;
160  PAPI_flops ( &rtimeP, &ptimeP, &flpopsP, &mflopsP);
161  rtimeACC += (rtimeP-rtimeS);
162  ptimeACC += (ptimeP-ptimeS);
163  flpopsACC += (flpopsP-flpopsS);
164  }
165 
170  void print(ostream& os) const
171  {
172  os << "HEADERS,PAPI_RTIME,PAPI_PTIME,PAPI_FLPOPS,PAPI_MFLOPS" << endl;
173  os << "VALUES,"
174  << rtimeACC << ","
175  << ptimeACC << ","
176  << flpopsACC << ","
177  << ((double) flpopsACC / (double) ptimeACC)/1000000.0 << endl;
178  }
179 
187  int setCellValues(CSVStringTable& st, unsigned row) const
188  {
189  if (st.nRows() <= row) return -1;
190  int ret;
191  if ((ret = st.setCell(row,"PAPI_RTIME",rtimeACC,true)))
192  return ret;
193  if ((ret = st.setCell(row,"PAPI_PTIME",ptimeACC,true)))
194  return ret;
195  if ((ret = st.setCell(row,"PAPI_FLPOPS",flpopsACC,true)))
196  return ret;
197  double av_mflops = ((double) flpopsACC / (double) ptimeACC) / 1000000.0;
198  if ((ret = st.setCell(row,"PAPI_AV_MFLOPS",av_mflops,true)))
199  return ret;
200 
201  return 0; // Return ok
202  }
203 
204  void clearStats()
205  {
206  memset(&rtimeACC, 0, sizeof(rtimeACC));
207  memset(&ptimeACC, 0, sizeof(ptimeACC));
208  memset(&flpopsACC, 0, sizeof(flpopsACC));
209  }
210 
211 protected:
212 
213  float rtimeS, ptimeS, mflopsS;
214  int64_t flpopsS;
215 
216  float rtimeACC, ptimeACC;
217  int64_t flpopsACC;
218 
219 };
220 
221 #endif
222 
223 #ifdef REALpzfpcounter
224 #include "pzreal.h"
225 class PZFPCountRunStat : public RunStat
226 {
227 public:
228 
229  PZFPCountRunStat()
230  {
231  clearStats();
232  }
233 
234  /* Start recording the execution statistics. */
235  void start()
236  {
237  start_counter.copy(TPZFlopCounter::gCount);
238  }
239 
240  /* Stop recording the execution statistics. */
241  void stop()
242  {
243  TPZCounter stop_counter;
244  stop_counter.copy(TPZFlopCounter::gCount);
245  stop_counter -= start_counter;
246  acc_counter += stop_counter;
247  }
248 
253  void print(ostream& os) const
254  {
255  stringstream headers;
256  stringstream values;
257 
258  headers << "HEADERS";
259  for (int i=0; i<gNumOp; i++) {
260  headers << "," << "PZCOUNT_" << OpNames[i];
261  }
262  values << "VALUES";
263  for (int i=0; i<gNumOp; i++) {
264  values << "," << acc_counter[i];
265  }
266  os << headers << endl;
267  os << values << endl;
268  }
269 
277  int setCellValues(CSVStringTable& st, unsigned row) const
278  {
279  if (st.nRows() <= row) return -1;
280  int ret;
281 
282  for (int i=0; i<gNumOp; i++) {
283  stringstream header;
284  header << "PZCOUNT_" << OpNames[i];
285  if ((ret = st.setCell(row,header,acc_counter[i],true)))
286  return ret;
287  }
288 
289  return 0; // Return ok
290  }
291 
292  void clearStats()
293  {
294  acc_counter.clear();
295  }
296 
297 protected:
298 
299  TPZCounter start_counter;
300  TPZCounter acc_counter;
301 
302 };
303 
304 #endif
305 
306 #ifdef HAS_GETRUSAGE
307 #include <sys/resource.h> // getrusage
308 
309 class RUsageRunStat : public RunStat
310 {
311 public:
312 
313  RUsageRunStat()
314  {
315  clearStats();
316  }
317 
318  /* Start recording the execution statistics. */
319  void start()
320  {
321  getrusage(RUSAGE_SELF, &lap_self);
322  getrusage(RUSAGE_CHILDREN, &lap_children);
323  }
324 
325  /* Stop recording the execution statistics. */
326  void stop()
327  {
328  struct rusage self, children;
329  getrusage(RUSAGE_SELF, &self);
330  getrusage(RUSAGE_CHILDREN, &children);
331 #define SET_TOTAL(fld) total_self.fld += (self.fld - lap_self.fld); total_children.fld += (children.fld - lap_children.fld)
332 
333 #define SET_TOTAL_TIMEVAL(fld) \
334 total_self.fld.tv_sec += (self.fld.tv_sec - lap_self.fld.tv_sec); \
335 total_self.fld.tv_usec += (self.fld.tv_usec - lap_self.fld.tv_usec); \
336 total_children.fld.tv_sec += (children.fld.tv_sec - lap_children.fld.tv_sec); \
337 total_children.fld.tv_usec += (children.fld.tv_usec - lap_children.fld.tv_usec)
338 
339  SET_TOTAL_TIMEVAL(ru_utime); /* user time used */
340  SET_TOTAL_TIMEVAL(ru_stime); /* system time used */
341  SET_TOTAL(ru_maxrss); /* integral max resident set size */
342  SET_TOTAL(ru_ixrss); /* integral shared text memory size */
343  SET_TOTAL(ru_idrss); /* integral unshared data size */
344  SET_TOTAL(ru_isrss); /* integral unshared stack size */
345  SET_TOTAL(ru_minflt); /* page reclaims */
346  SET_TOTAL(ru_majflt); /* page faults */
347  SET_TOTAL(ru_nswap); /* swaps */
348  SET_TOTAL(ru_inblock); /* block input operations */
349  SET_TOTAL(ru_oublock); /* block output operations */
350  SET_TOTAL(ru_msgsnd); /* messages sent */
351  SET_TOTAL(ru_msgrcv); /* messages received */
352  SET_TOTAL(ru_nsignals); /* signals received */
353  SET_TOTAL(ru_nvcsw); /* voluntary context switches */
354  SET_TOTAL(ru_nivcsw); /* involuntary context switches */
355  }
356 
361  void print(ostream& os) const
362  {
363  stringstream header;
364  stringstream values;
365 
366 #define PRINT_FLD(hd,fld) header << ",SELF_" << hd << ",CHD_" << hd; values << "," << total_self.fld << "," << total_children.fld
367 
368 #define TIMEVAL_TO_DOUBLE_MS(s) ( ((double) s.tv_sec) * 1000.0 + ((double) s.tv_usec) / 1000.0)
369 
370 #define PRINT_TIMEVAL_FLD(hd,fld) \
371 header << ",SELF_" << hd << ",CHD_" << hd; \
372 values << "," << TIMEVAL_TO_DOUBLE_MS(total_self.fld) << "," << TIMEVAL_TO_DOUBLE_MS(total_children.fld)
373 
374  PRINT_TIMEVAL_FLD("RU_UTIME",ru_utime); /* user time used */
375  PRINT_TIMEVAL_FLD("RU_STIME",ru_stime); /* system time used */
376  PRINT_FLD("RU_MAXRSS",ru_maxrss); /* integral max resident set size */
377  PRINT_FLD("RU_IXRSS",ru_ixrss); /* integral shared text memory size */
378  PRINT_FLD("RU_IDRSS",ru_idrss); /* integral unshared data size */
379  PRINT_FLD("RU_ISRSS",ru_isrss); /* integral unshared stack size */
380  PRINT_FLD("RU_MINFLT",ru_minflt); /* page reclaims */
381  PRINT_FLD("RU_MAJFLT",ru_majflt); /* page faults */
382  PRINT_FLD("RU_NSWAP",ru_nswap); /* swaps */
383  PRINT_FLD("RU_INBLOCK",ru_inblock); /* block input operations */
384  PRINT_FLD("RU_OUBLOCK",ru_oublock); /* block output operations */
385  PRINT_FLD("RU_MSGND",ru_msgsnd); /* messages sent */
386  PRINT_FLD("RU_MSGRCV",ru_msgrcv); /* messages received */
387  PRINT_FLD("RU_NSIGNAL",ru_nsignals); /* signals received */
388  PRINT_FLD("RU_NVCSW",ru_nvcsw); /* voluntary context switches */
389  PRINT_FLD("RU_NIVSW",ru_nivcsw); /* involuntary context switches */
390  os << "HEADERS" << header.str() << endl;
391  os << "VALUES" << values.str() << endl;
392  }
393 
401  int setCellValues(CSVStringTable& st, unsigned row) const
402  {
403  if (st.nRows() <= row) return -1;
404 
405 #define APPEND_LONG_FLD(hd,fld) \
406 { int ret; string header("SELF_"); header += hd; \
407 if ((ret = st.setCell(row, header, total_self.fld, true))) \
408 return ret; \
409 header = "CHD_"; header += hd; \
410 if ((ret = st.setCell(row, header, total_children.fld, true))) \
411 return ret; \
412 }
413 
414 #define APPEND_TIMEVAL_FLD(hd,fld) \
415 { int ret; string header("SELF_"); header += hd; \
416 if ((ret = st.setCell(row, header, TIMEVAL_TO_DOUBLE_MS(total_self.fld), true))) \
417 return ret; \
418 header = "CHD_"; header += hd; \
419 if ((ret = st.setCell(row, header, TIMEVAL_TO_DOUBLE_MS(total_children.fld), true))) \
420 return ret; \
421 }
422  APPEND_TIMEVAL_FLD("RU_UTIME",ru_utime); /* user time used */
423  APPEND_TIMEVAL_FLD("RU_STIME",ru_stime); /* system time used */
424  APPEND_LONG_FLD("RU_MAXRSS",ru_maxrss); /* integral max resident set size */
425  APPEND_LONG_FLD("RU_IXRSS",ru_ixrss); /* integral shared text memory size */
426  APPEND_LONG_FLD("RU_IDRSS",ru_idrss); /* integral unshared data size */
427  APPEND_LONG_FLD("RU_ISRSS",ru_isrss); /* integral unshared stack size */
428  APPEND_LONG_FLD("RU_MINFLT",ru_minflt); /* page reclaims */
429  APPEND_LONG_FLD("RU_MAJFLT",ru_majflt); /* page faults */
430  APPEND_LONG_FLD("RU_NSWAP",ru_nswap); /* swaps */
431  APPEND_LONG_FLD("RU_INBLOCK",ru_inblock); /* block input operations */
432  APPEND_LONG_FLD("RU_OUBLOCK",ru_oublock); /* block output operations */
433  APPEND_LONG_FLD("RU_MSGND",ru_msgsnd); /* messages sent */
434  APPEND_LONG_FLD("RU_MSGRCV",ru_msgrcv); /* messages received */
435  APPEND_LONG_FLD("RU_NSIGNAL",ru_nsignals); /* signals received */
436  APPEND_LONG_FLD("RU_NVCSW",ru_nvcsw); /* voluntary context switches */
437  APPEND_LONG_FLD("RU_NIVSW",ru_nivcsw); /* involuntary context switches */
438 
439  return 0; // Return ok
440  }
441 
442  void clearStats()
443  {
444  memset(&lap_self, 0, sizeof(lap_self));
445  memset(&lap_children, 0, sizeof(lap_children));
446  memset(&total_self, 0, sizeof(total_self));
447  memset(&total_children, 0, sizeof(total_children));
448  }
449 
450 protected:
451 
452  struct rusage lap_self, lap_children;
453  struct rusage total_self, total_children;
454 
455 };
456 
457 #endif
458 
459 #ifdef HAS_LIBPFM
460 //#include <perfmon/pfmlib_perf_event.h>
461 //#include "perf_util.h"
462 
463 /*
464  TODO:
465  1- Initialize the libpfm
466  ret = pfm_initialize();
467  if (ret != PFM_SUCCESS) error;
468 
469  */
470 
471 class LIBPFMCounter
472 {
473 Public:
474 
475 private:
476  perf_event_desc_t event;
477 
478 };
479 
480 class LIBPFMRunStat : public RunStat
481 {
482 private:
483 
484  bool counters_enabled;
485  bool counters_created;
486  vector<perf_event_desc_t> counters;
487 
488 public:
489 
490  LIBPFMRunStat() :
491  counters_enable(false), counters_created(false)
492  {
493  clearStats();
494  }
495 
496  /* Start recording the execution statistics. */
497  void start()
498  {
499  // Check whether libpfm was properly initialized.
500  if (!libpfm_man.ok()) return;
501 
502  // Create counters
503  for (int i=0; i<counters.size(); i++) {
504  fds[i].hw.read_format = PERF_FORMAT_SCALE;
505  fds[i].hw.disabled = 1; /* do not start now */
506  /* each event is in an independent group (multiplexing likely) */
507  fds[i].fd = perf_event_open(&fds[i].hw, 0, -1, -1, 0);
508  if (fds[i].fd == -1)
509  err(1, "cannot open event %d", i);
510  }
511 
512  counters_created;
513 
514  // Enable counters attached to this thread
515  if (prctl(PR_TASK_PERF_EVENTS_ENABLE)) {
516  // ERROR(prctl(enable) failed)
517 
518  }
519  counters_enable = true;
520  }
521 
522  /* Stop recording the execution statistics. */
523  void stop()
524  {
525  if (counters_enable != true) return;
526  if (prctl(PR_TASK_PERF_EVENTS_DISABLE)) {
527  // ERROR (prctl(disable) failed)
528 
529 
530 
531  //struct rusage self, children;
532  //getrusage(RUSAGE_SELF, &self);
533  //getrusage(RUSAGE_CHILDREN, &children);
534  //#define SET_TOTAL(fld) total_self.fld += (self.fld - lap_self.fld); total_children.fld += (children.fld - lap_children.fld)
537  //SET_TOTAL(ru_maxrss); /* integral max resident set size */
538  //SET_TOTAL(ru_ixrss); /* integral shared text memory size */
539  //SET_TOTAL(ru_idrss); /* integral unshared data size */
540  //SET_TOTAL(ru_isrss); /* integral unshared stack size */
541  //SET_TOTAL(ru_minflt); /* page reclaims */
542  //SET_TOTAL(ru_majflt); /* page faults */
543  //SET_TOTAL(ru_nswap); /* swaps */
544  //SET_TOTAL(ru_inblock); /* block input operations */
545  //SET_TOTAL(ru_oublock); /* block output operations */
546  //SET_TOTAL(ru_msgsnd); /* messages sent */
547  //SET_TOTAL(ru_msgrcv); /* messages received */
548  //SET_TOTAL(ru_nsignals); /* signals received */
549  //SET_TOTAL(ru_nvcsw); /* voluntary context switches */
550  //SET_TOTAL(ru_nivcsw); /* involuntary context switches */
551  }
552 
557  void print(ostream& os) const
558  {
559  // stringstream header;
560  // stringstream values;
561  //#define PRINT_FLD(hd,fld) header << ",SELF_" << hd << ",CHD_" << hd; values << "," << total_self.fld << "," << total_children.fld
562  //
563  // //struct timeval ru_utime; /* user time used */
564  // //struct timeval ru_stime; /* system time used */
565  // PRINT_FLD("RU_MAXRSS",ru_maxrss); /* integral max resident set size */
566  // PRINT_FLD("RU_IXRSS",ru_ixrss); /* integral shared text memory size */
567  // PRINT_FLD("RU_IDRSS",ru_idrss); /* integral unshared data size */
568  // PRINT_FLD("RU_ISRSS",ru_isrss); /* integral unshared stack size */
569  // PRINT_FLD("RU_MINFLT",ru_minflt); /* page reclaims */
570  // PRINT_FLD("RU_MAJFLT",ru_majflt); /* page faults */
571  // PRINT_FLD("RU_NSWAP",ru_nswap); /* swaps */
572  // PRINT_FLD("RU_INBLOCK",ru_inblock); /* block input operations */
573  // PRINT_FLD("RU_OUBLOCK",ru_oublock); /* block output operations */
574  // PRINT_FLD("RU_MSGND",ru_msgsnd); /* messages sent */
575  // PRINT_FLD("RU_MSGRCV",ru_msgrcv); /* messages received */
576  // PRINT_FLD("RU_NSIGNAL",ru_nsignals); /* signals received */
577  // PRINT_FLD("RU_NVCSW",ru_nvcsw); /* voluntary context switches */
578  // PRINT_FLD("RU_NIVSW",ru_nivcsw); /* involuntary context switches */
579  // os << "HEADERS" << header.str() << endl;
580  // os << "VALUES" << values.str() << endl;
581  }
582 
590  int setCellValues(CSVStringTable& st, unsigned row) const
591  {
592  // if (st.nRows() <= row) return -1;
593  //
594  //#define APPEND_LONG_FLD(hd,fld) \
595  // { int ret; string header("SELF_"); header += hd; \
596  // if ((ret = st.setCell(row, header, total_self.fld, true))) \
597  // return ret; \
598  // header = "CHD_"; header += hd; \
599  // if ((ret = st.setCell(row, header, total_children.fld, true))) \
600  // return ret; \
601  // }
602  //
603  // //struct timeval ru_utime; /* user time used */
604  // //struct timeval ru_stime; /* system time used */
605  // APPEND_LONG_FLD("RU_MAXRSS",ru_maxrss); /* integral max resident set size */
606  // APPEND_LONG_FLD("RU_IXRSS",ru_ixrss); /* integral shared text memory size */
607  // APPEND_LONG_FLD("RU_IDRSS",ru_idrss); /* integral unshared data size */
608  // APPEND_LONG_FLD("RU_ISRSS",ru_isrss); /* integral unshared stack size */
609  // APPEND_LONG_FLD("RU_MINFLT",ru_minflt); /* page reclaims */
610  // APPEND_LONG_FLD("RU_MAJFLT",ru_majflt); /* page faults */
611  // APPEND_LONG_FLD("RU_NSWAP",ru_nswap); /* swaps */
612  // APPEND_LONG_FLD("RU_INBLOCK",ru_inblock); /* block input operations */
613  // APPEND_LONG_FLD("RU_OUBLOCK",ru_oublock); /* block output operations */
614  // APPEND_LONG_FLD("RU_MSGND",ru_msgsnd); /* messages sent */
615  // APPEND_LONG_FLD("RU_MSGRCV",ru_msgrcv); /* messages received */
616  // APPEND_LONG_FLD("RU_NSIGNAL",ru_nsignals); /* signals received */
617  // APPEND_LONG_FLD("RU_NVCSW",ru_nvcsw); /* voluntary context switches */
618  // APPEND_LONG_FLD("RU_NIVSW",ru_nivcsw); /* involuntary context switches */
619  //
620  return 0; // Return ok
621  }
622 
623  void clearStats()
624  {
625  // memset(&lap_self, 0, sizeof(lap_self));
626  // memset(&lap_children, 0, sizeof(lap_children));
627  // memset(&total_self, 0, sizeof(total_self));
628  // memset(&total_children, 0, sizeof(total_children));
629  }
630 
631  protected:
632 
633  // struct rusage lap_self, lap_children;
634  // struct rusage total_self, total_children;
635 
636  };
637 
638 #endif
639 
640 #include<pz_gettime.h>
641 
642  class ElapsedTimeRunStat : public RunStat
643  {
644  public:
645 
646  ElapsedTimeRunStat()
647  {
648  clearStats();
649  }
650 
651  /* Start recording the execution statistics. */
652  void start()
653  {
654  gettimeofday(&lap, NULL);
655  }
656 
657  /* Stop recording the execution statistics. */
658  void stop()
659  {
660  timeval curr;
661  gettimeofday(&curr, NULL);
662  total.tv_sec += (curr.tv_sec - lap.tv_sec );
663  total.tv_usec += (curr.tv_usec - lap.tv_usec);
664  //elapsed = (t.tv_sec - lap.tv_sec) * 1000.0; // sec to ms
665  //elapsed += (t.tv_usec - lap.tv_usec) / 1000.0; // us to ms
666  }
667 
671  void print(ostream& os) const
672  {
673  os << "HEADERS,ELAPSED_MS" << endl;
674  os << "VALUES," << getElapsedMS() << endl;
675  }
676 
684  int setCellValues(CSVStringTable& st, unsigned row) const
685  {
686  if (st.nRows() <= row) return -1;
687  return st.setCell(row, "ELAPSED", getElapsedMS(), true);
688  }
689 
690  void clearStats()
691  {
692  memset(&lap, 0, sizeof(lap));
693  memset(&total, 0, sizeof(total));
694  }
695 
696  double getElapsedMS() const
697  {
698  double elapsed;
699  elapsed = (total.tv_sec) * 1000.0; // sec to ms
700  elapsed += (total.tv_usec) / 1000.0; // us to ms
701  return elapsed;
702  }
703 
704  protected:
705 
706  timeval lap;
707  timeval total;
708  };
709 
715  class RunStatsRecorder
716  {
717  public:
718 
720  RunStatsRecorder() : n_laps(0)
721  {
722 #ifdef HAS_LIBPFM
723  /* Add the resource usage statistics. */
724  stat_items.push_back(new LIBPFMRunStat());
725 #endif
726 #ifdef HAS_GETRUSAGE
727  /* Add the resource usage statistics. */
728  stat_items.push_back(new RUsageRunStat());
729 #endif
730 #ifdef USING_PAPI
731  /* Add the PAPI counters statistics. */
732  stat_items.push_back(new PAPIRunStat());
733 #endif
734  /* Add the elapsed time statistic. */
735  stat_items.push_back(new ElapsedTimeRunStat());
736  }
737 
739  ~RunStatsRecorder()
740  {
741  vector<RunStat*>::iterator it;
742  for (it=stat_items.begin(); it!=stat_items.end(); it++) {
743  RunStat* i = *it;
744  delete i;
745  }
747  stat_items.clear();
748  }
749 
751  void start()
752  {
753  vector<RunStat*>::iterator it;
754  for (it=stat_items.begin(); it!=stat_items.end(); it++)
755  (*it)->start();
756  }
757 
759  void stop()
760  {
761  vector<RunStat*>::reverse_iterator rit;
762  for (rit=stat_items.rbegin(); rit!=stat_items.rend(); rit++)
763  (*rit)->stop();
764  n_laps++;
765  }
766 
768  void lap() { stop(); start(); }
769 
771  void print(ostream& os) const
772  {
773  vector<RunStat*>::const_iterator it;
774  for (it=stat_items.begin(); it!=stat_items.end(); it++)
775  (*it)->print(os);
776  }
777 
785  int append_to(CSVStringTable& st) const
786  {
787  int ret;
788  unsigned new_row = st.addRows(1);
789 
790  if ((ret=update_row(st, new_row)))
791  return ret;
792  else
793  return new_row;
794  }
795 
801  int update_row(CSVStringTable& st, unsigned row) const
802  {
803  int ret;
804 
805  vector<RunStat*>::const_iterator it;
806  for (it=stat_items.begin(); it!=stat_items.end(); it++) {
807  if ((ret=(*it)->setCellValues(st,row))) {
808  return ret;
809  }
810  }
811 
812  return 0;
813  }
814 
815  void clear() {
816 
817  vector<RunStat*>::iterator it;
818  for (it=stat_items.begin(); it!=stat_items.end(); it++)
819  (*it)->clearStats();
820  n_laps = 0;
821  }
822 
823  private:
824 
826  vector<RunStat*> stat_items;
827 
828  unsigned n_laps; //N_LAPS
829 
830  };
831 
832 #endif // STATS_RECORDER
833 
TPZFlopCounter::gCount
static TPZCounter gCount
Containts the counter vector by operation performed.
Definition: pzreal.h:270
RUsageRunStat::setCellValues
int setCellValues(CSVStringTable &st, unsigned row) const
Definition: stats_recorder.h:401
RunStat::~RunStat
virtual ~RunStat()
Definition: stats_recorder.h:115
CSVTable::setCell
int setCell(unsigned row_idx, string col_name, string value, bool createNewCol=false)
Definition: csvtable.h:136
APPEND_LONG_FLD
#define APPEND_LONG_FLD(hd, fld)
PRINT_TIMEVAL_FLD
#define PRINT_TIMEVAL_FLD(hd, fld)
RUsageRunStat::print
void print(ostream &os) const
Definition: stats_recorder.h:361
PRINT_FLD
#define PRINT_FLD(hd, fld)
RunStatsRecorder::update_row
int update_row(CSVStringTable &st, unsigned row) const
Definition: stats_recorder.h:801
ElapsedTimeRunStat::setCellValues
int setCellValues(CSVStringTable &st, unsigned row) const
Definition: stats_recorder.h:684
ElapsedTimeRunStat::getElapsedMS
double getElapsedMS() const
Definition: stats_recorder.h:696
SET_TOTAL_TIMEVAL
#define SET_TOTAL_TIMEVAL(fld)
gNumOp
const int gNumOp
Number of type of the operations actually counted.
Definition: pzreal.h:108
RunStatsRecorder::append_to
int append_to(CSVStringTable &st) const
Definition: stats_recorder.h:785
ElapsedTimeRunStat::print
void print(ostream &os) const
Definition: stats_recorder.h:671
csvtable.h
Contains macros and functions to support a string csv table.
CSVTable::addRows
unsigned addRows(unsigned n=1)
Definition: csvtable.h:98
RunStatsRecorder::stat_items
vector< RunStat * > stat_items
Definition: stats_recorder.h:826
CSVTable::nRows
unsigned nRows() const
Definition: csvtable.h:184
TPZCounter
Implements a counter by operations. Common.
Definition: pzreal.h:111
RunStatsRecorder::print
void print(ostream &os) const
Definition: stats_recorder.h:771
pzreal.h
Contains the declaration of TPZFlopCounter class and TPZCounter struct.
TPZCounter::copy
TPZCounter & copy(const TPZCounter &other)
Definition: pzreal.h:141
pz_gettime.h
rdt.values
def values
Definition: rdt.py:119
APPEND_TIMEVAL_FLD
#define APPEND_TIMEVAL_FLD(hd, fld)
SET_TOTAL
#define SET_TOTAL(fld)
Generated on Sun Aug 16 2020 11:17:08 for NeoPZ by   doxygen 1.8.13