add benchmarking code for linux; needs implemented on WIN32, OSX

mpictor · mpictor · commit 7c187a7372a7 · 2012-08-07T19:10:22.000-04:00
* 'getMemAndTime()' can be used from C or C++
* 'benchmark' class calculates a delta for phys/virt memory and
   user/sys cpu time. Uses getMemAndTime() internally.
diff --git a/src/base/CMakeLists.txt b/src/base/CMakeLists.txt
@@ -3,6 +3,7 @@ set(SCL_BASE_SOURCES
     scl_memmgr.cc
     scl_trace_fprintf.c
     sc_getopt.cc
+    sc_benchmark.cc
 )
 
 if(MSVC OR BORLAND)
diff --git a/src/base/sc_benchmark.cc b/src/base/sc_benchmark.cc
@@ -0,0 +1,113 @@
+/// \file sc_benchmark.cc memory info, timers, etc for benchmarking
+
+#include "sc_benchmark.h"
+
+#ifdef __WIN32
+  #include <Windows.h>
+#else
+  #include <sys/time.h>
+  #include <ctime>
+  #include <unistd.h>
+#endif
+
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <string>
+#include <sstream>
+
+/// mem values in kb, times in ms (granularity may be higher than 1ms)
+benchVals getMemAndTime( ) {
+    benchVals vals;
+  #ifdef __linux__
+    // adapted from http://stackoverflow.com/questions/669438/how-to-get-memory-usage-at-run-time-in-c
+    std::ifstream stat_stream("/proc/self/stat",std::ios_base::in);
+
+    // dummy vars for leading entries in stat that we don't care about
+    std::string pid, comm, state, ppid, pgrp, session, tty_nr;
+    std::string tpgid, flags, minflt, cminflt, majflt, cmajflt;
+    std::string /*utime, stime,*/ cutime, cstime, priority, nice;
+    std::string O, itrealvalue, starttime;
+
+    // the fields we want
+    unsigned long utime, stime, vsize;
+    long rss;
+
+    stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
+                >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
+                >> utime >> stime >> cutime >> cstime >> priority >> nice
+                >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest
+
+    long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
+    vals.physMemKB  = rss * page_size_kb;
+    vals.virtMemKB  = ( vsize / 1024 ) - vals.physMemKB;
+    vals.userMilliseconds = ( utime * 1000 ) / sysconf(_SC_CLK_TCK);
+    vals.sysMilliseconds  = ( stime * 1000 ) / sysconf(_SC_CLK_TCK);
+  #elif defined(__APPLE__)
+    // http://stackoverflow.com/a/1911863/382458
+  #elif defined(__WIN32)
+    // http://stackoverflow.com/a/282220/382458 and http://stackoverflow.com/a/64166/382458
+  #else
+    #warning Unknown platform!
+  #endif // __linux__
+    return vals;
+}
+
+// ---------------------   benchmark class   ---------------------
+
+benchmark::benchmark( std::string description, bool debugMessages, std::ostream& o_stream ): ostr( o_stream ),
+                            descr( description ), debug( debugMessages ), stopped( false ) {
+    initialVals = getMemAndTime( );
+}
+
+benchmark::~benchmark() {
+    if( !stopped ) {
+        stop( );
+        if( debug ) {
+            ostr << "benchmark::~benchmark(): stop was not called before destructor!" << std::endl;
+        }
+        out( );
+    }
+}
+
+void benchmark::stop( ) {
+    if( stopped ) {
+        std::cerr << "benchmark::stop(): tried to stop a benchmark that was already stopped!" << std::endl;
+    } else {
+        laterVals = getMemAndTime( );
+        stopped = true;
+    }
+}
+
+benchVals benchmark::get( ) {
+    if( !stopped ) {
+        laterVals = getMemAndTime( );
+    }
+    benchVals delta;
+    delta.physMemKB = laterVals.physMemKB - initialVals.physMemKB;
+    delta.virtMemKB = laterVals.virtMemKB - initialVals.virtMemKB;
+    delta.sysMilliseconds = laterVals.sysMilliseconds - initialVals.sysMilliseconds;
+    delta.userMilliseconds = laterVals.userMilliseconds - initialVals.userMilliseconds;
+    return delta;
+}
+
+void benchmark::reset( ) {
+    stopped = false;
+    initialVals = getMemAndTime();
+}
+
+std::string benchmark::str( ) {
+    return str( get( ) );
+}
+
+void benchmark::out() {
+    ostr << str( ) << std::endl;
+}
+
+std::string benchmark::str( const benchVals& bv ) {
+    std::stringstream ss;
+    ss << descr << " Physical memory: " << bv.physMemKB << "kb; Virtual memory: " << bv.virtMemKB;
+    ss << "kb; User CPU time: " << bv.userMilliseconds << "ms; System CPU time: " << bv.sysMilliseconds << "ms";
+    return ss.str();
+}
+
diff --git a/src/base/sc_benchmark.h b/src/base/sc_benchmark.h
@@ -0,0 +1,66 @@
+#ifndef SC_BENCHMARK_H
+#define SC_BENCHMARK_H
+/// \file sc_benchmark.h memory info, timers, etc for benchmarking
+
+#include "scl_export.h"
+
+#ifdef __cplusplus
+#include <iostream>
+#include <string>
+
+extern "C" {
+#endif
+
+typedef struct {
+    long virtMemKB, physMemKB, userMilliseconds, sysMilliseconds;
+} benchVals;
+
+/** return a benchVals struct with four current statistics for this process:
+ * virtual and physical memory use in kb,
+ * user and system cpu time in ms
+ *
+ * not yet implemented for OSX or Windows.
+ */
+SCL_BASE_EXPORT benchVals getMemAndTime( );
+
+#ifdef __cplusplus
+}
+
+
+/** reports the difference in memory and cpu use between when the
+ * constructor is called and when stop() or the destructor is called.
+ *
+ * if the destructor is called and stop() had not previously been
+ * called, the results are printed to the ostream given in the
+ * constructor, prefixed by the description.
+ *
+ * depends on getMemAndTime() above - may not work on all platforms.
+ */
+SCL_BASE_EXPORT class benchmark {
+protected:
+    benchVals initialVals, laterVals;
+    std::ostream& ostr;
+    std::string descr;
+    bool debug, stopped;
+public:
+    benchmark( std::string description = "", bool debugMessages = true, std::ostream& o_stream = std::cout );
+
+    /// if 'stopped' is false, uses str(true) to print to ostream
+    ~benchmark( );
+    void reset( );
+    benchVals get( );
+    void stop( );
+
+    /// converts data member 'laterVals' into a string and returns it
+    std::string str( );
+
+    /// outputs result of str() on ostream 'ostr'
+    void out( );
+
+    /// converts 'bv' into a string, prefixed by data member 'descr'
+    std::string str( const benchVals& bv );
+};
+
+
+#endif //__cplusplus
+#endif //SC_BENCHMARK_H
diff --git a/src/test/p21read/p21read.cc b/src/test/p21read/p21read.cc
@@ -22,6 +22,7 @@ extern void SchemaInit( class Registry & );
 #include <errordesc.h>
 #include <algorithm>
 #include <string>
+#include "sc_benchmark.h"
 #ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif
@@ -97,6 +98,7 @@ void printUse( const char * exe ) {
     std::cout << "p21read - read a STEP Part 21 exchange file using SCL, and write the data to another file." << std::endl;
     std::cout << "Syntax:  " << exe << " [-i] [-s] infile [outfile]" << std::endl;
     std::cout << "Use '-i' to ignore a schema name mismatch." << std::endl;
+    std::cout << "Use '-m' to turn off memory info." << std::endl;
     std::cout << "Use '-s' for strict interpretation (attributes that are \"missing and required\" will cause errors)." << std::endl;
     std::cout << "Use '-v' to print the version info below and exit." << std::endl;
     std::cout << "Use '--' as the last argument if a file name starts with a dash." << std::endl;
@@ -107,15 +109,21 @@ void printUse( const char * exe ) {
 int main( int argc, char * argv[] ) {
     bool ignoreErr = false;
     bool strict = false;
+    bool memInfo = true;
     char c;
+    double physMem, virtMem, preReadPhysMem, preReadVirtMem; //for memory monitoring
+
     if( argc > 4 || argc < 2 ) {
         printUse( argv[0] );
     }
-    while( ( c = sc_getopt( argc, argv, "isv" ) ) != -1 ) {
+    while( ( c = sc_getopt( argc, argv, "imsv" ) ) != -1 ) {
         switch( c ) {
             case 'i':
                 ignoreErr = true;
                 break;
+            case 'm':
+                memInfo = false;
+                break;
             case 's':
                 strict = true;
                 break;
@@ -128,7 +136,6 @@ int main( int argc, char * argv[] ) {
         }
     }
 
-
     ///////////////////////////////////////////////////////////////////////////////
     // You have to initialize the schema before you do anything else.
     // This initializes all of the registry information for the schema you
@@ -142,31 +149,41 @@ int main( int argc, char * argv[] ) {
     STEPfile  sfile( registry, instance_list, "", strict );
     char   *  flnm;
 
-    cout << "\nEXAMPLE :  load file ..." << endl;
+    benchmark stats( "p21 ReadExchangeFile()" );
+
+    cout << argv[0] << ": load file ..." << endl;
     if( argc >= ( optind + 1 ) ) {
         flnm = argv[optind];
     } else {
         flnm = ( char * )"testfile.step";
     }
     sfile.ReadExchangeFile( flnm );
-    sfile.Error().PrintContents( cout );
+    if( sfile.Error().severity() < SEVERITY_USERMSG ) {
+        sfile.Error().PrintContents( cout );
+    }
+
+    stats.stop();
+    stats.out( );
 
-    if ( sfile.Error().severity() <= SEVERITY_INCOMPLETE )
+    if ( sfile.Error().severity() <= SEVERITY_INCOMPLETE ) {
         exit(1);
+    }
 
     checkSchemaName( registry, sfile, ignoreErr );
 
     Severity readSev = sfile.Error().severity(); //otherwise, errors from reading will be wiped out by sfile.WriteExchangeFile()
 
-    cout << "EXAMPLE :  write file ..." << endl;
+    cout << argv[0] << ": write file ..." << endl;
     if( argc == optind + 2 ) {
         flnm = argv[optind + 1];
     } else {
         flnm = ( char * )"file.out";
     }
     sfile.WriteExchangeFile( flnm );
-    sfile.Error().PrintContents( cout );
-    cout << flnm << " written"  << endl;
+    if( sfile.Error().severity() < SEVERITY_USERMSG ) {
+        sfile.Error().PrintContents( cout );
+    }
+    cout << argv[0] << ": " << flnm << " written"  << endl;
 
     if( ( sfile.Error().severity() <= SEVERITY_INCOMPLETE ) || ( readSev <= SEVERITY_INCOMPLETE ) ) { //lower is worse
         exit( 1 );

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ set(SCL_BASE_SOURCES`
`3`	`3`	`scl_memmgr.cc`
`4`	`4`	`scl_trace_fprintf.c`
`5`	`5`	`sc_getopt.cc`
	`6`	`+ sc_benchmark.cc`
`6`	`7`	`)`
`7`	`8`
`8`	`9`	`if(MSVC OR BORLAND)`