[llvm-commits] CVS: llvm-test/SingleSource/Benchmarks/Misc-C++/oopack_v1p8.cpp

Chris Lattner sabre at nondot.org
Wed May 16 16:35:57 PDT 2007



Changes in directory llvm-test/SingleSource/Benchmarks/Misc-C++:

oopack_v1p8.cpp added (r1.1)
---
Log message:

move this out of customchecked


---
Diffs of the changes:  (+707 -0)

 oopack_v1p8.cpp |  707 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 707 insertions(+)


Index: llvm-test/SingleSource/Benchmarks/Misc-C++/oopack_v1p8.cpp
diff -c /dev/null llvm-test/SingleSource/Benchmarks/Misc-C++/oopack_v1p8.cpp:1.1
*** /dev/null	Wed May 16 18:35:49 2007
--- llvm-test/SingleSource/Benchmarks/Misc-C++/oopack_v1p8.cpp	Wed May 16 18:35:39 2007
***************
*** 0 ****
--- 1,707 ----
+ //=============================================================================
+ //
+ //  OOPACK - a benchmark for comparing OOP vs. C-style programming.
+ //  Copyright (C) 1995 Arch D. Robison
+ //
+ //  This program is free software; you can redistribute it and/or modify
+ //  it under the terms of the GNU General Public License as published by
+ //  the Free Software Foundation; either version 2 of the License, or
+ //  (at your option) any later version.
+ //
+ //  This program is distributed in the hope that it will be useful,
+ //  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ //  GNU General Public License for more details.
+ //
+ //  For a copy of the GNU General Public License, write to the Free Software
+ //  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ //
+ //=============================================================================
+ //
+ // OOPACK: a benchmark for comparing OOP vs. C-style programming.
+ // 
+ // Version: 1.7
+ // 
+ // Author: Arch D. Robison (robison at kai.com)
+ //	   Kuck & Associates 
+ //	   1906 Fox Dr.
+ //	   Champaign IL 61820
+ //		
+ // Web Info: http://www.kai.com/oopack/oopack.html
+ //
+ // Code last revised:   November 21, 1995
+ // Comments last revised:  March 23, 1998
+ //
+ // This benchmark program contains a suite of tests that measure the relative 
+ // performance of object-oriented-programming (OOP) in C++ versus just writing
+ // plain C-style code in C++.  All of the tests are written so that a 
+ // compiler can in principle transform the OOP code into the C-style code.  
+ // After you run this benchmark and discover just how much you are paying to 
+ // use object-oriented programming, you will probably say: OOP? ACK!
+ // (Unless, of course, you have Kuck & Associates' C++ compiler.)
+ //
+ // TO COMPILE
+ //
+ //	Compile with your favorite C++ compiler.  E.g. ``CC -O2 oopack.C''.
+ //	On most machines, no special command-line options are required.  
+ // 	For Suns only, you need to define the symbol ``sun4''.  
+ //	E.g. ``g++ -O -Dsun4 oopack.C''.
+ //
+ // TO RUN
+ //
+ //	To run the benchmark, run
+ //
+ //         a.out Max=50000 Matrix=500 Complex=20000 Iterator=50000
+ //
+ //	This runs the four tests for the specified number of iterations.
+ //	E.g., the Max test is run for 50000 iterations.  You may want to 
+ //	adjust the number of iterations to be small enough to get
+ //	an answer in reasonable time, but large enough to get a reasonably
+ //	accurate answer.
+ //
+ // INTERPRETING THE RESULTS
+ //	
+ //	Below is an example command line and the program's output.
+ //      We used an SGI Origin 200 running IRIX 6.4 (64bit).
+ //
+ //      % KCC_3.3a +K3 -O2 oopack.C
+ //
+ //	% a.out Max=100000 Matrix=2000 Complex=200000 Iterator=200000
+ //      OOPACK Version 1.7
+ //      
+ //      For results on various systems and compilers, examine this Web Page:
+ //          http://www.kai.com/oopack/oopack.html
+ //      
+ //      Report your results by sending e-mail to oopack at kai.com.
+ //      For a run to be accepted, adjust the number of iterations for each test
+ //      so that each time reported is greater than 10 seconds.
+ //      
+ //      Send this output, along with:
+ //      
+ //           * your 
+ //              + name ------------------- 
+ //              + company/institution ---- 
+ //      
+ //           * the compiler
+ //              + name ------------------- 
+ //              + version number --------- 
+ //              + options used ----------- 
+ //      
+ //           * the operating system
+ //              + name ------------------- 
+ //              + version number --------- 
+ //      
+ //           * the machine
+ //              + manufacturer ----------- 
+ //              + model number ----------- 
+ //              + processor clock speed -- 
+ //              + cache memory size ------ 
+ //      
+ //                                Seconds       Mflops         
+ //	 Test       Iterations     C    OOP     C    OOP  Ratio
+ //	 ----       ----------  -----------  -----------  -----
+ //	 Max            100000    1.4   1.4   71.4  71.4    1.0
+ //	 Matrix           2000    3.4   3.3  147.9 150.2    1.0
+ //	 Complex        200000    7.8   7.3  204.9 218.9    0.9
+ //	 Iterator       200000    2.2   2.2  177.8 177.8    1.0
+ //
+ //	
+ // 	The ``Test'' column gives the names of the four tests that are run.  
+ //	The ``Iterations'' column gives the number of iterations that a test 
+ //	was run.  The two ``Seconds'' columns give the C-style and OOP-style
+ //      running times for a test.  The two ``Mflops'' columns give the
+ //      corresponding megaflop rates.  The ``Ratio'' column gives the ratio
+ //      between the times.
+ //
+ //	Beware that a low ``Ratio'' could indicate either that the OOP-style
+ //	code is compiled very well, or that the C-style code is compiled poorly.
+ //      OOPACK performance figures for KAI's C++ and some other compilers
+ //	can be found in http://www.kai.com/oopack/oopack.html.
+ //
+ // Revision History
+ //	9/17/93		Version 1.0 released
+ //	10/5/93		Allow results to be printed even if checksums do not match.
+ //	10/5/93		Increased ``Tolerance'' to allow 10-second runs on RS/6000.  
+ //	10/5/93 	Version 1.1 released
+ //      1/10/94		Change author's address from Shell to KAI
+ //	1/13/94		Added #define's for conditional compilation of individual tests
+ //	1/21/94		Converted test functions to virtual members of class Benchmark.
+ //     10/11/94         Added routine to inform user of command-line usage.
+ //     10/11/94		Version 1.5 released.
+ //     11/21/95		V1.6 Added "mail results to oopack at kai.com" message in output
+ //     11/28/95		V1.7 Added company/institution to requested information
+ 
+ //=============================================================================
+ 
+ #include <assert.h>
+ #include <ctype.h>
+ #include <float.h>
+ #include <math.h>
+ #include <stdio.h>
+ #include <time.h>
+ #include <string.h>
+ #include <stdlib.h>
+ 
+ //
+ // The source-code begins with the benchmark computations themselves and
+ // ends with code for collecting statistics.  Each benchmark ``Foo'' is
+ // a class FooBenchmark derived from class Benchmark.  The relevant methods
+ // are:
+ //
+ //	init - Initialize the input data for the benchmark
+ //
+ //	c_style - C-style code
+ //
+ //	oop_style - OOP-style code
+ //
+ //	check - computes number of floating-point operations and a checksum.
+ //
+ const int BenchmarkListMax = 4;
+ 
+ class Benchmark {
+ public:
+     void time_both( int iteration_count ) const;
+     void time_one( void (Benchmark::*function)() const, int iterations, double& sec, double& Mflop, double& checksum ) const;
+     virtual const char * name() const = 0;
+     virtual void init() const = 0;
+     virtual void c_style() const = 0; 
+     virtual void oop_style() const = 0;
+     virtual void check( int iterations, double& flops, double& checksum ) const = 0;
+     static Benchmark * find( const char * name );
+ private:
+     static Benchmark * list[BenchmarkListMax];
+     static int count;
+ protected:
+     Benchmark() {list[count++] = this;}
+ };
+ 
+ // The initializer for Benchmark::count *must* precede the declarations
+ // of derived of class Benchmark.
+ int Benchmark::count = 0;
+ Benchmark * Benchmark::list[BenchmarkListMax];
+ 
+ //
+ // The ``iterations'' argument is the number of times that the benchmark 
+ // computation was called.  The computed checksum that ensures that the
+ // C-style code and OOP code are computing the same result.  This 
+ // variable also prevents really clever optimizers from removing the
+ // the guts of the computations that otherwise would be unused.
+ //
+ 
+ // Each of the following symbols must be defined to enable a test, or
+ // undefined to disable a test.  The reason for doing this with the
+ // preprocessor is that some compilers may choke on specific tests.
+ #define HAVE_MAX 1
+ #define HAVE_MATRIX 1
+ #define HAVE_COMPLEX 1 
+ #define HAVE_ITERATOR 1
+ 
+ const int N = 1000;
+ 
+ #if HAVE_MAX
+ //=============================================================================
+ //
+ // Max benchmark
+ //
+ // This benchmark measures how well a C++ compiler inlines a function that 
+ // returns the result of a comparison.  
+ //
+ // The functions C_Max and OOP_Max compute the maximum over a vector.
+ // The only difference is that C_Max writes out the comparison operation
+ // explicitly, and OOP_Max calls an inline function to do the comparison.
+ //
+ // This benchmark is included because some compilers do not compile 
+ // inline functions into conditional branches as well as they might.  
+ //
+ const int M = 1000;		// Dimension of vector
+ double U[M];			// The vector
+ double MaxResult;		// Result of max computation
+ 
+ class MaxBenchmark: public Benchmark {
+ private:
+     const char * name() const {return "Max";}
+     void init() const;
+     void c_style() const; 
+     void oop_style() const;
+     void check( int iterations, double& flops, double& checksum ) const;
+ } TheMaxBenchmark;
+ 
+ void MaxBenchmark::c_style() const		// Compute max of vector (C-style)
+ {		
+     double max = U[0];
+     for( int k=1; k<M; k++ )			// Loop over vector elements
+ 	if( U[k] > max )  
+ 	    max=U[k];
+     MaxResult = max;
+ }
+ 
+ inline int Greater( double i, double j ) 
+ {
+     return i>j;
+ }
+ 
+ void MaxBenchmark::oop_style() const 		// Compute max of vector (OOP-style)
+ {	
+     double max = U[0];
+     for( int k=1; k<M; k++ )			// Loop over vector elements
+ 	if( Greater( U[k], max ) ) 
+ 	    max=U[k];
+     MaxResult = max;
+ }
+ 
+ void MaxBenchmark::init() const 			
+ {
+     for( int k=0; k<M; k++ ) 
+ 	U[k] = k&1 ? -k : k;
+ }
+ 
+ void MaxBenchmark::check( int iterations, double& flops, double& checksum ) const
+ {
+     flops = (double)M*iterations;
+     checksum = MaxResult;
+ }
+ #endif /* HAVE_MAX */
+ 
+ #if HAVE_MATRIX
+ //=============================================================================
+ //
+ // Matrix benchmark
+ //
+ // This benchmark measures how well a C++ compiler performs constant propagation and 
+ // strength-reduction on classes.  C_Matrix multiplies two matrices using C-style code; 
+ // OOP_Matrix does the same with OOP-style code.  To maximize performance on most RISC 
+ // processors, the benchmark requires that the compiler perform strength-reduction and 
+ // constant-propagation in order to simplify the indexing calculations in the inner loop.
+ //
+ const int L = 50;		// Dimension of (square) matrices.
+ 
+ double C[L*L], D[L*L], E[L*L];	// The matrices to be multiplied.
+ 
+ class MatrixBenchmark: public Benchmark {
+ private:
+     const char * name() const {return "Matrix";}
+     void init() const;
+     void c_style() const; 
+     void oop_style() const;
+     void check( int iterations, double& flops, double& checksum ) const;
+ } TheMatrixBenchmark;
+ 
+ void MatrixBenchmark::c_style() const {		// Compute E=C*D with C-style code.
+     for( int i=0; i<L; i++ )
+ 	for( int j=0; j<L; j++ ) {
+ 	    double sum = 0;
+ 	    for( int k=0; k<L; k++ )
+ 		sum += C[L*i+k]*D[L*k+j];
+ 	    E[L*i+j] = sum;
+ 	}
+ }
+ 
+ class Matrix {	// Class Matrix represents a matrix stored in row-major format (same as C).
+ private:
+     double *data;	// Pointer to matrix data
+ public:
+     int rows, cols;	// Number of rows and columns
+ 
+     Matrix( int rows_, int cols_, double * data_ ) :
+ 	data(data_), rows(rows_), cols(cols_)
+     {}
+ 
+     double& operator()( int i, int j ) {	// Access element at row i, column j
+ 	return data[cols*i+j];
+     }
+ };
+ 
+ void MatrixBenchmark::oop_style() const { 	// Compute E=C*D with OOP-style code.
+     Matrix c( L, L, C );			// Set up three matrices
+     Matrix d( L, L, D );
+     Matrix e( L, L, E );
+     for( int i=0; i<e.rows; i++ )		// Do matrix-multiplication
+ 	for( int j=0; j<e.cols; j++ ) {
+ 	    double sum = 0;
+ 	    for( int k=0; k<e.cols; k++ )
+ 		sum += c(i,k)*d(k,j);
+ 	    e(i,j) = sum;
+ 	}
+ }
+ 
+ void MatrixBenchmark::init() const	
+ {
+     for( int j=0; j<L*L; j++ ) {
+ 	C[j] = j+1;
+ 	D[j] = 1.0/(j+1);
+     }
+ }
+ 
+ void MatrixBenchmark::check( int iterations, double& flops, double& checksum ) const
+ {
+     double sum = 0;
+     for( int k=0; k<L*L; k++ )
+ 	sum += E[k];
+     checksum = sum;
+     flops = 2.0*L*L*L*iterations;
+ }
+ #endif /* HAVE_MATRIX */
+ 
+ #if HAVE_ITERATOR
+ //=============================================================================
+ //
+ // Iterator benchmark 
+ //
+ // Iterators are a common abstraction in object-oriented programming, which
+ // unfortunately may incur a high cost if compiled inefficiently.
+ // The iterator benchmark below computes a dot-product using C-style code
+ // and OOP-style code.  All methods of the iterator are inline, and in 
+ // principle correspond exactly to the C-style code.
+ //
+ // Note that the OOP-style code uses two iterators, but the C-style
+ // code uses a single index.  Good common-subexpression elimination should,
+ // in principle, reduce the two iterators to a single index variable, or
+ // conversely, good strength-reduction should convert the single index into 
+ // two iterators!  
+ //
+ double A[N];
+ double B[N];
+ double IteratorResult;
+ 
+ class IteratorBenchmark: public Benchmark {
+ private:
+     const char * name() const {return "Iterator";}
+     void init() const;
+     void c_style() const; 
+     void oop_style() const;
+     void check( int iterations, double& flops, double& checksum ) const;
+ } TheIteratorBenchmark;
+ 
+ void IteratorBenchmark::c_style() const 		// Compute dot-product with C-style code
+ {
+     double sum = 0;
+     for( int i=0; i<N; i++ )
+ 	sum += A[i]*B[i];
+     IteratorResult = sum;
+ }
+ 
+ class Iterator {		// Iterator for iterating over array of double
+ private:
+     int index;			// Index of current element
+     const int limit;		// 1 + index of last element
+     double * const array;	// Pointer to array
+ public:
+     double look() {return array[index];}	// Get current element
+     void next() {index++;}			// Go to next element
+     int done() {return index>=limit;}		// True iff no more elements
+     Iterator( double * array1, int limit1 ) : 
+ 	index(0),
+ 	limit(limit1), 
+ 	array(array1)
+     {}
+ };
+ 
+ void IteratorBenchmark::oop_style() const 		// Compute dot-product with OOP-style code
+ {
+     double sum = 0;
+     for( Iterator ai(A,N), bi(B,N); !ai.done(); ai.next(), bi.next() )
+ 	sum += ai.look()*bi.look();
+     IteratorResult = sum;
+ }
+ 
+ void IteratorBenchmark::init() const	
+ {
+     for( int i=0; i<N; i++ ) {
+ 	A[i] = i+1;
+ 	B[i] = 1.0/(i+1);
+     }
+ }
+ 
+ void IteratorBenchmark::check( int iterations, double& flops, double& checksum ) const {
+     flops = 2*N*iterations;
+     checksum = IteratorResult;
+ }
+ #endif /* HAVE_ITERATOR */
+ 
+ #if HAVE_COMPLEX
+ //=============================================================================
+ //
+ // Complex benchmark
+ //
+ // Complex numbers are a common abstraction in scientific programming.
+ // This benchmark measures how fast they are in C++ relative to the same
+ // calculation done by explicitly writing out the real and imaginary parts.
+ // The calculation is a complex-valued ``SAXPY'' operation.
+ //
+ // The complex arithmetic is all inlined, so in principle the code should
+ // run as fast as the version using explicit real and imaginary parts.
+ //
+ class ComplexBenchmark: public Benchmark {
+ private:
+     const char * name() const {return "Complex";}
+     void init() const;
+     void c_style() const; 
+     void oop_style() const;
+     void check( int iterations, double& flops, double& checksum ) const;
+ } TheComplexBenchmark;
+ 
+ class Complex {
+ public:
+     double re, im;
+     Complex( double r, double i ) : re(r), im(i) {}
+     Complex() {}
+ };
+ 
+ inline Complex operator+( Complex a, Complex b ) 	// Complex add
+ {
+     return Complex( a.re+b.re, a.im+b.im );
+ }
+ 
+ inline Complex operator*( Complex a, Complex b ) 	// Complex multiply
+ {
+     return Complex( a.re*b.re-a.im*b.im, a.re*b.im+a.im*b.re );
+ }
+ 
+ Complex X[N], Y[N];				// Arrays used by benchmark
+ 
+ void ComplexBenchmark::c_style() const 		// C-style complex-valued SAXPY operation
+ {
+     double factor_re = 0.5;
+     double factor_im = 0.86602540378443864676;
+     for( int k=0; k<N; k++ ) {
+ 	Y[k].re = Y[k].re + factor_re*X[k].re - factor_im*X[k].im;
+ 	Y[k].im = Y[k].im + factor_re*X[k].im + factor_im*X[k].re;
+     }
+ }
+ 
+ void ComplexBenchmark::oop_style() const 	// OOP-style complex-valued SAXPY operation 
+ {
+     Complex factor( 0.5, 0.86602540378443864676 );
+     for( int k=0; k<N; k++ )
+ 	Y[k] = Y[k] + factor*X[k];
+ }
+ 
+ void ComplexBenchmark::init() const	
+ {
+     for( int k=0; k<N; k++ ) {
+ 	X[k] = Complex( k+1, 1.0/(k+1) );
+ 	Y[k] = Complex( 0, 0 );
+     }
+ }
+ 
+ void ComplexBenchmark::check( int iterations, double& flops, double& checksum ) const {
+     double sum = 0;
+     for( int k=0; k<N; k++ )
+ 	sum += Y[k].re + Y[k].im;
+     checksum = sum;
+     flops = 8*N*iterations;
+ }
+ #endif /* HAVE_COMPLEX */
+ 
+ //=============================================================================
+ // End of benchmark computations.  
+ //=============================================================================
+ 
+ // All the code below is for running and timing the benchmarks.						     
+ #if defined(sun4) && !defined(CLOCKS_PER_SEC)
+ // Sun/4 include-files seem to be missing CLOCKS_PER_SEC.
+ #define CLOCKS_PER_SEC 1000000	
+ #endif
+ 
+ //
+ // TimeOne
+ //
+ // Time a single benchmark computation.
+ //
+ // Inputs
+ //	function = pointer to function to be run and timed.
+ //	iterations = number of times to call function.
+ //
+ // Outputs
+ //	sec = Total number of seconds for calls of function.
+ //	Mflop = Megaflop rate of function.
+ //	checksum = checksum computed by function.
+ //     
+ void Benchmark::time_one( void (Benchmark::*function)() const, int iterations, double& sec, double& Mflop, double& checksum ) const
+ {
+     // Initialize and run code once to load caches
+     init();
+     (this->*function)();
+ 
+     // Initialize and run code.
+     init();
+     clock_t t0 = clock();
+     for( int k=0; k<iterations; k++ ) 
+         (this->*function)();
+     clock_t t1 = clock();
+ 
+     // Update checksum and compute number of floating-point operations.
+     double flops;
+     check( iterations, flops, checksum );
+ 
+     sec = (t1-t0) / (double)CLOCKS_PER_SEC;
+     Mflop = flops/sec*1e-6;
+ 
+ }
+ 
+ //
+ // The variable ``C_Seconds'' is the time in seconds in which to run the 
+ // C-style benchmarks.
+ //
+ double C_Seconds = 1;	
+ 
+ //
+ // The variable ``Tolerance'' is the maximum allowed relative difference 
+ // between the C and OOP checksums.  Machines with multiply-add 
+ // instructions may produce different answers when they use those 
+ // instructions rather than separate instructions.
+ //
+ // There is nothing magic about the 32, it's just the result of tweaking.
+ //
+ const double Tolerance = 64*DBL_EPSILON;
+ 
+ Benchmark * Benchmark::find( const char * name ) {
+     for( int i=0; i<count; i++ )
+ 	if( strcmp( name, list[i]->name() )== 0 )
+ 	    return list[i];
+     return NULL;	
+ }
+ 
+ //
+ // Benchmark::time_both
+ //
+ // Runs the C and Oop versions of a benchmark computation, and print the 
+ // results.
+ //
+ // Inputs
+ //	name = name of the benchmark
+ //	c_style = benchmark written in C-style code
+ //	oop_style = benchmark written in OOP-style code
+ //	check = routine to compute checksum on answer
+ //
+ void Benchmark::time_both( int iterations ) const {
+     // Run the C-style code. 
+     double c_sec, c_Mflop, c_checksum;
+     time_one( &Benchmark::c_style, iterations, c_sec, c_Mflop, c_checksum );
+    
+     // Run the OOP-style code. 
+     double oop_sec, oop_Mflop, oop_checksum;
+     time_one( &Benchmark::oop_style, iterations, oop_sec, oop_Mflop, oop_checksum );
+ 
+     // Compute execution-time ratio of OOP to C.  This is also the 
+     // reciprocal of the Megaflop ratios.                                
+     double ratio = oop_sec/c_sec;
+  
+     // Compute the absolute and relative differences between the checksums
+     // for the two codes.
+     double diff = c_checksum - oop_checksum;
+     double min = c_checksum < oop_checksum ? c_checksum : oop_checksum;
+     double rel = diff/min;
+ 
+     // If the relative difference exceeds the tolerance, print an error-message,
+     // otherwise print the statistics.
+     if( rel > Tolerance || rel < -Tolerance ) {
+ 	printf( "%-10s: warning: relative checksum error of %g between C (%g) and oop (%g)\n",
+ 	        name(), rel, c_checksum, oop_checksum );
+     } 
+     
+ #if 0
+     // original, useful for getting timings
+     printf( "%-10s %10d  %5.1f %5.1f  %5.1f %5.1f  %5.1f\n", 
+ 	    name(), iterations, c_sec, oop_sec, c_Mflop, oop_Mflop, ratio );
+ #else
+     // hacked to not produce output.
+     printf( "%-10s %10d\n", 
+ 	    name(), iterations);
+ #endif
+ }
+ 
+ const char * Version = "Version 1.7"; // The OOPACK version number 
+ 
+ void Usage( int /*argc*/, char * argv[] ) {
+     printf( "Usage:\t%s test1=iterations1 test2=iterations2 ...\n", argv[0] ); 
+     printf( "E.g.:\ta.out  Max=5000 Matrix=50 Complex=2000  Iterator=5000\n" );
+     exit(1);
+ }
+ 
+ int main( int argc, char **argv ) 
+ {
+     // The available benchmarks are automatically put into the list of available benchmarks
+     // by the constructor for Benchmark.
+     char str1[] = "a.out";
+     char str2[] = "Max=15000";
+     char str3[] = "Matrix=200";
+     char str4[] = "Complex=2000";
+     char str5[] = "Iterator=20000";
+     const char *ActualArgs[] = { str1, str2, str3, str4, str5, 0 };
+     argv = (char**)ActualArgs;
+     argc = 5;
+ 
+     // Check if user does not know command-line format.
+     if( argc==1 ) {
+ 	Usage( argc, argv );
+     }
+     int i;
+     for( i=1; i<argc; i++ ) {
+ 	if( !isalpha(argv[i][0]) )
+ 	    Usage( argc, argv );
+     }
+ 
+     // Print the request for results
+ #if 0
+     printf("\n");
+     printf("OOPACK %s\n",Version);
+     printf("\n");
+     printf("For results on various systems and compilers, examine this Web Page:\n");
+     printf("    http://www.kai.com/oopack/oopack.html\n");
+     printf("\n");
+     printf("Report your results by sending e-mail to oopack at kai.com.\n");
+     printf("For a run to be accepted, adjust the number of iterations for each test\n");
+     printf("so that each time reported is greater than 10 seconds.\n");
+     printf("\n");
+     printf("Send this output, along with:\n");
+     printf("\n");
+     printf("     * your\n");
+     printf("        + name ------------------- \n");
+     printf("        + company/institution ---- \n");
+     printf("\n");
+     printf("     * the compiler\n");
+     printf("        + name ------------------- \n");
+     printf("        + version number --------- \n");
+     printf("        + options used ----------- \n");
+     printf("\n");
+     printf("     * the operating system\n");
+     printf("        + name ------------------- \n");
+     printf("        + version number --------- \n");
+     printf("\n");
+     printf("     * the machine\n");
+     printf("        + manufacturer ----------- \n");
+     printf("        + model number ----------- \n");
+     printf("        + processor clock speed -- \n");
+     printf("        + cache memory size ------ \n");
+     printf("\n");
+ #endif
+ 
+     // Print header.
+     printf("%-10s %10s  %11s  %11s  %5s\n", "", "", "Seconds  ", "Mflops  ", "" );
+     printf("%-10s %10s  %5s %5s  %5s %5s  %5s\n",
+ 	   "Test", "Iterations", " C ", "OOP", " C ", "OOP", "Ratio" );
+     printf("%-10s %10s  %11s  %11s  %5s\n", "----", "----------", "-----------", "-----------", "-----" );
+ 
+     for( i=1; i<argc; i++ ) {
+ 	const char * test_name = strtok( argv[i], "=" );
+ 	const char * rhs =  strtok( NULL, "" );
+ 	if( rhs==NULL ) {
+ 	    printf("missing iteration count for test '%s'\n", test_name );
+ 	} else {
+ 	    int test_count = (int)strtol( rhs, 0, 0 );
+ 	    Benchmark * b = Benchmark::find( test_name );
+ 	    if( b==NULL ) {
+ 		printf("skipping non-existent test = '%s'\n", test_name );
+ 		abort();
+ 	    } else {
+ 		b->time_both( test_count );
+ 	    }
+ 	}
+     }
+ 
+     /* Print blank line. */
+     printf("\nDONE!\n");
+ 
+     return 0;
+ }






More information about the llvm-commits mailing list