[Compbench-devel] CompBenchmarks++/SupportedBenchmarks Benchmark-BENCHPP.cpp, NONE, 1.1 Benchmark-BENCHPP.h, NONE, 1.1 Benchmark-BENCHPP.libwrapper.h, NONE, 1.1 Benchmark-BENCHPPLINUX.cpp, NONE, 1.1 Benchmark-BENCHPPLINUX.h, NONE, 1.1 Benchmark-BENCHPPLINUX.libwrapper.h, NONE, 1.1 Benchmark-BZIP2.cpp, NONE, 1.1 Benchmark-BZIP2.h, NONE, 1.1 Benchmark-BZIP2.libwrapper.h, NONE, 1.1 Benchmark-GZIP.cpp, NONE, 1.1 Benchmark-GZIP.h, NONE, 1.1 Benchmark-GZIP.libwrapper.h, NONE, 1.1 Benchmark-LINPACKC.cpp, NONE, 1.1 Benchmark-LINPACKC.h, NONE, 1.1 Benchmark-LINPACKC.libwrapper.h, NONE, 1.1 Benchmark-NBENCH.cpp, NONE, 1.1 Benchmark-NBENCH.h, NONE, 1.1 Benchmark-NBENCH.libwrapper.h, NONE, 1.1 Benchmark-SCIMARK2.cpp, NONE, 1.1 Benchmark-SCIMARK2.h, NONE, 1.1 Benchmark-SCIMARK2.libwrapper.h, NONE, 1.1 Benchmark-Selector.cpp, NONE, 1.1 Benchmark-Selector.h, NONE, 1.1 benchmarks-genlibwrapper.sh, NONE, 1.1 benchmarks.list, NONE, 1.1 Makefile.am, NONE, 1.1

[Frederic T. <xf...@us...>]

Update of /cvsroot/compbench/CompBenchmarks++/SupportedBenchmarks
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv17554

Added Files:
	Benchmark-BENCHPP.cpp Benchmark-BENCHPP.h 
	Benchmark-BENCHPP.libwrapper.h Benchmark-BENCHPPLINUX.cpp 
	Benchmark-BENCHPPLINUX.h Benchmark-BENCHPPLINUX.libwrapper.h 
	Benchmark-BZIP2.cpp Benchmark-BZIP2.h 
	Benchmark-BZIP2.libwrapper.h Benchmark-GZIP.cpp 
	Benchmark-GZIP.h Benchmark-GZIP.libwrapper.h 
	Benchmark-LINPACKC.cpp Benchmark-LINPACKC.h 
	Benchmark-LINPACKC.libwrapper.h Benchmark-NBENCH.cpp 
	Benchmark-NBENCH.h Benchmark-NBENCH.libwrapper.h 
	Benchmark-SCIMARK2.cpp Benchmark-SCIMARK2.h 
	Benchmark-SCIMARK2.libwrapper.h Benchmark-Selector.cpp 
	Benchmark-Selector.h benchmarks-genlibwrapper.sh 
	benchmarks.list Makefile.am 
Log Message:
Sources have been re-organised.

--- NEW FILE: Benchmark-BENCHPP.cpp ---
#include <SupportedBenchmarks/Benchmark-BENCHPP.h>
#include <System/System.h>

#include <config.h>

#include <fstream>

#include <SupportedBenchmarks/Benchmark-BENCHPP.libwrapper.h>

CBMBenchmarkBENCHPP::CBMBenchmarkBENCHPP(CBMSystem *_system)
  : CBMBenchmark(_system)
{
}

std::string CBMBenchmarkBENCHPP::downloadURL(void)
{
  return("");
}

std::string CBMBenchmarkBENCHPP::expectedMD5(void)
{
  return("61f961031fd3ca116787fffd442ef872");
}

std::string CBMBenchmarkBENCHPP::packageName(void)
{
  return("benchpp");
}

std::string CBMBenchmarkBENCHPP::benchmarkComments(void)
{
  std::string comment;

  comment+=benchmarkBENCHPPComments();
  comment+=" (Comment from README file)";

  return(comment);
}

std::string CBMBenchmarkBENCHPP::packageVersion(void)
{
  return("1.1");
}

int CBMBenchmarkBENCHPP::packageSize(void)
{
  return(177532);
}

std::string CBMBenchmarkBENCHPP::packageComments(void)
{
  return("The suite is based on the Ada PIWG suite, and therefore is " \
	 "designed to test individual language features, with some small " \
	 "applications and \"traditional\" benchmarks thrown in." \
	 "The \"optimizer\" tests are based on: "\
	 "Benchmark Test to Estimate Optimization Quality of Compilers " \
	 "By Klerer & Liu.  SIGPLAN NOT. Oct 1988 " \
	 ". The Style tests are based on: " \
	 "OOPACK: a benchmark for comparing OOP vs. C-style programming "\
	 "Kuck & Associates "
	 "http://www.kai.com/oopack/oopack.html "
	 "Stepanov Benchmarks: measuring the data abstraction penalty " \
	 "Written by Alexander Stepanov, the author of the STL " \
	 "http://www.kai.com/benchmarks/stepanov/ . Comments from mirror http://web.archive.org/web/20050307095704/www.research.att.com/~orost/bench_plus_plus.html, since official site http://paul.rutgers.edu/~orost/bench_plus_plus.html is down.");

}

std::string CBMBenchmarkBENCHPP::localPackageName(void)
{
  return("bench_plus_plus_1.1.tar.Z");
}

std::string CBMBenchmarkBENCHPP::language(void)
{
  return("C++");
}

char* CBMBenchmarkBENCHPP::extractDirectory(void)
{
  return("bench++");
}

int CBMBenchmarkBENCHPP::hasPatch(void)
{
  return(1);
}

int CBMBenchmarkBENCHPP::patch(int _force)
{
  std::string cmd;
  std::string sstdout;
  int         r;
  std::string patch;

  patch+=system->temporaryDirectory(CBMSystem::Patches);
  patch+="/benchpp.patch.gz";

  cmd+="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && if test ! -f ";
  cmd+=patch;
  cmd+="; then exit 1; fi";
  cmd+=" && ";
  cmd+=CBM_PROG_GZIP;
  cmd+=" -dc ";
  cmd+=patch;
  cmd+=" | ";
  cmd+=CBM_PROG_PATCH;
  cmd+=" -p0 Configure";
  r=system->exec(cmd, sstdout);
  return(!r);
}

int CBMBenchmarkBENCHPP::extract(int _force)
{
  std::string localFile = localPackageAbsoluteName();
  std::string cmd;
  std::string sstdout;

  cmd+="cd ";
  cmd+=system->temporaryDirectory(CBMSystem::Extract);
  cmd+=" && ";
  cmd+=CBM_PROG_ZCAT;
  cmd+=" ";
  cmd+=localFile;
  cmd+=" | ";
  cmd+=CBM_PROG_TAR;
  cmd+=" xvf -";

  return(system->exec(cmd, sstdout)==0);
}

int CBMBenchmarkBENCHPP::preConfigure(int _force)
{
  return(1);
}

int CBMBenchmarkBENCHPP::configure(CBMCompiler        *_currentCompiler,
				   CBMCompilerOptions *_currentOptions)
{
  std::string cmd;
  std::string sstdout;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  
  cmd+="echo -e \"";
  cmd+=_currentCompiler->Binary();
  cmd+="\n";
  if (_currentOptions->Options() != "") {
    cmd+=_currentOptions->Options();
  } else {
    cmd+="none";
  }
  cmd+="\n\n\n\"";
  cmd+=" | ./Configure";

  return(system->exec(cmd, sstdout)==0);
}

int CBMBenchmarkBENCHPP::make(void)
{
  std::string cmd;
  std::string sstdout;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  cmd+=CBM_PROG_MAKE;
  cmd+=" a000091 a000092 s000005a s000005m ";

  if (language()=="C") {
    cmd+="CC=";
  } else {
    if (language()=="C++") {
      cmd+="CXX=";
    } else {
      /* !!! */
    }
  }
  cmd+=currentCompiler->Binary();
  if (language()=="C") {
    cmd+=" CFLAGS=";
  } else {
    if (language()=="C++") {
      cmd+=" CXXFLAGS=";
    } else {
      /* !!! */
    }
  }

  cmd+="'";
  cmd+=currentOptions->Options();
  cmd+="' 2> /dev/null";

  return(system->exec(cmd, sstdout)==0);
}

std::string CBMBenchmarkBENCHPP::bench(void)
{
  std::string cmd;
  std::string result;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && echo $(./";
  cmd+=benchppBenchmark();
  cmd+=" | ";
  cmd+=CBM_PROG_TAIL;
  cmd+=" -1 | ";
  cmd+=CBM_PROG_CUT;
  cmd+=" -f2 -d':')";
  
  if (system->exec(cmd, result)==0) {
    return(result);
  } else {
    return("0");
  }

}

int CBMBenchmarkBENCHPP::release(void)
{
  std::string cmd;
  std::string sstdout;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  cmd+=CBM_PROG_MAKE;
  cmd+=" clean 2> /dev/null";

  return(system->exec(cmd, sstdout)==0);
}

std::string CBMBenchmarkBENCHPP::license(void)
{
  return("Public domain");
}

std::string CBMBenchmarkBENCHPP::homePage(void)
{
  return("http://web.archive.org/web/20050307095704/www.research.att.com/~orost/bench_plus_plus.html");
}

std::string CBMBenchmarkBENCHPP::author(void)
{
  return("Joseph M. Orost");
}

int CBMBenchmarkBENCHPP::benchmarkSize(void)
{
  return(packageSize());
}

CBMBenchmarkBENCHPP::~CBMBenchmarkBENCHPP()
{
}

CBMBenchmarkBENCHPP_DHRYSTONE::CBMBenchmarkBENCHPP_DHRYSTONE(CBMSystem *_system)
  : CBMBenchmarkBENCHPP(_system)
{
}

std::string CBMBenchmarkBENCHPP_DHRYSTONE::benchmarkName(void)
{
  return("benchpp-dhrystone");
}

std::string CBMBenchmarkBENCHPP_DHRYSTONE::benchppBenchmark(void)
{
  return("a000091");
}

std::string CBMBenchmarkBENCHPP_DHRYSTONE::benchmarkBENCHPPComments(void)
{
  return("C++ implementation of the Dhrystone benchmark (see http://www.cs.wisc.edu/~thomas/comp.benchmarks.FAQ.html).");
}

CBMBenchmarkBENCHPP_DHRYSTONE::~CBMBenchmarkBENCHPP_DHRYSTONE()
{
}

CBMBenchmarkBENCHPP_WHETSTONE::CBMBenchmarkBENCHPP_WHETSTONE(CBMSystem *_system)
  : CBMBenchmarkBENCHPP(_system)
{
}

std::string CBMBenchmarkBENCHPP_WHETSTONE::benchmarkName(void)
{
  return("benchpp-whetstone");
}

std::string CBMBenchmarkBENCHPP_WHETSTONE::benchppBenchmark(void)
{
  return("a000092");
}

std::string CBMBenchmarkBENCHPP_WHETSTONE::benchmarkBENCHPPComments(void)
{
  return("C++ implementation of the Whetstone benchmark (see http://www.cs.wisc.edu/~thomas/comp.benchmarks.FAQ.html).");
}

CBMBenchmarkBENCHPP_WHETSTONE::~CBMBenchmarkBENCHPP_WHETSTONE()
{
}


CBMBenchmarkBENCHPP_STEPANOV::CBMBenchmarkBENCHPP_STEPANOV(CBMSystem *_system)
  : CBMBenchmarkBENCHPP(_system)
{
}

std::string CBMBenchmarkBENCHPP_STEPANOV::bench(void)
{
  std::string cmd;
  std::string result;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && echo $(./";
  cmd+=benchppBenchmark();
  cmd+=" | ";
  cmd+=CBM_PROG_GREP;
  cmd+=" 'Iteration Count' | ";
  cmd+=CBM_PROG_CUT;
  cmd+=" -f3 -d':')";
  
  if (system->exec(cmd, result)==0) {
    return(result);
  } else {
    return("0");
  }
}

CBMBenchmarkBENCHPP_STEPANOV::~CBMBenchmarkBENCHPP_STEPANOV()
{
}

CBMBenchmarkBENCHPP_STEPANOV_AL12::CBMBenchmarkBENCHPP_STEPANOV_AL12(CBMSystem *_system)
  : CBMBenchmarkBENCHPP_STEPANOV(_system)
{
}

std::string CBMBenchmarkBENCHPP_STEPANOV_AL12::benchmarkName(void)
{
  return("benchpp-stepanov-al12");
}

std::string CBMBenchmarkBENCHPP_STEPANOV_AL12::benchppBenchmark(void)
{
  return("s000005a");
}

std::string CBMBenchmarkBENCHPP_STEPANOV_AL12::benchmarkBENCHPPComments(void)
{
  return("Stepanov AL-12 benchmark. Measures C++ overhead in a code which extensively uses abstraction.");
}

CBMBenchmarkBENCHPP_STEPANOV_AL12::~CBMBenchmarkBENCHPP_STEPANOV_AL12()
{
}

--- NEW FILE: Benchmark-LINPACKC.h ---
/* ----------------------------------------------------------------------------
   $Id: Benchmark-LINPACKC.h,v 1.1 2006/12/28 17:41:03 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */

#ifndef H_CBMBENCHMARKLINPACKC
#define H_CBMBENCHMARKLINPACKC

#include <Benchmark/Benchmark.h>

/** \brief Defines the linpackc package.
 */
class CBMBenchmarkLINPACKC : public CBMBenchmark
{
 public:
 private:
  virtual std::string downloadURL(void);
  virtual std::string expectedMD5(void);

  virtual std::string packageName(void);
  virtual std::string benchmarkComments(void);

  virtual std::string packageVersion(void);
  virtual int packageSize(void); /* in bytes */

  /** Compairs previous compilation context to current one. Local options
   *  are also taken in context.
   *  \return 1 if they match.
   *  \sa contextID()
   *  \sa storeContext()
   *  \sa Make()
   */
  virtual int         ContextMatches(CBMCompiler        *_currentCompiler,
				     CBMCompilerOptions *_currentOptions);

  virtual std::string packageComments(void);
  virtual std::string localPackageName(void);
		

 protected:
  virtual std::string linpackPrecisionFlags(void) = 0;
  virtual std::string linpackRollFlags(void) = 0;

  CBMBenchmarkLINPACKC(class CBMSystem *_system);

  virtual std::string language(void);

  virtual std::string benchmarkLINPACKCComments(void) = 0;

  virtual char* extractDirectory(void);
  virtual int hasPatch(void);
  virtual int patch(int _force = 0);


  virtual int extract(int _force = 0);
  virtual int preConfigure(int _force);
  virtual int configure(CBMCompiler        *_currentCompiler,
			CBMCompilerOptions *_currentOptions);

  virtual int make(void);
  virtual std::string bench(void);
  virtual int release(void);

 public:
  virtual std::string license(void);
  virtual std::string homePage(void);
  virtual std::string author(void);

  virtual int benchmarkSize(void);
  virtual ~CBMBenchmarkLINPACKC();
};

/** \brief Defines the single precision unrolled benchmark within linpackc package.
 */
class CBMBenchmarkLINPACKC_SP_UNROLL : public CBMBenchmarkLINPACKC
{
 public:
 private:
 protected:
  virtual std::string linpackPrecisionFlags(void);
  virtual std::string linpackRollFlags(void);


  virtual std::string benchmarkLINPACKCComments(void);

 public:
  CBMBenchmarkLINPACKC_SP_UNROLL(class CBMSystem *_system);

  virtual std::string benchmarkName(void);

  virtual ~CBMBenchmarkLINPACKC_SP_UNROLL();
};

/** \brief Defines the single precision 'rolled' benchmark within linpackc package.
 */
class CBMBenchmarkLINPACKC_SP_ROLL : public CBMBenchmarkLINPACKC
{
 public:
 private:
 protected:
  virtual std::string linpackPrecisionFlags(void);
  virtual std::string linpackRollFlags(void);


  virtual std::string benchmarkLINPACKCComments(void);

 public:
  CBMBenchmarkLINPACKC_SP_ROLL(class CBMSystem *_system);

  virtual std::string benchmarkName(void);

  virtual ~CBMBenchmarkLINPACKC_SP_ROLL();
		
};

/** \brief Defines the double precision unrolled benchmark within linpackc package.
 */
class CBMBenchmarkLINPACKC_DP_UNROLL : public CBMBenchmarkLINPACKC
{
 public:
 private:
 protected:
  virtual std::string linpackPrecisionFlags(void);
  virtual std::string linpackRollFlags(void);


  virtual std::string benchmarkLINPACKCComments(void);

 public:
  CBMBenchmarkLINPACKC_DP_UNROLL(class CBMSystem *_system);

  virtual std::string benchmarkName(void);

  virtual ~CBMBenchmarkLINPACKC_DP_UNROLL();
};

/** \brief Defines the double precision 'rolled' benchmark within linpackc package.
 */
class CBMBenchmarkLINPACKC_DP_ROLL : public CBMBenchmarkLINPACKC
{
 public:
 private:
 protected:
  virtual std::string linpackPrecisionFlags(void);
  virtual std::string linpackRollFlags(void);


  virtual std::string benchmarkLINPACKCComments(void);

 public:
  CBMBenchmarkLINPACKC_DP_ROLL(class CBMSystem *_system);

  virtual std::string benchmarkName(void);

  virtual ~CBMBenchmarkLINPACKC_DP_ROLL();
		
};

lib_declare();

#endif

--- NEW FILE: Benchmark-SCIMARK2.h ---
/* ----------------------------------------------------------------------------
   $Id: Benchmark-SCIMARK2.h,v 1.1 2006/12/28 17:41:04 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */
#ifndef H_CBMBENCHMARKSCIMARK2
#define H_CBMBENCHMARKSCIMARK2

#include <Benchmark/Benchmark.h>


/** \brief Defines the scimark2 package.
 */
class CBMBenchmarkSCIMARK2 : public CBMBenchmark
{
 public:
 private:
  virtual std::string downloadURL(void);
  virtual std::string expectedMD5(void);

  virtual std::string packageName(void);
  virtual std::string benchmarkName(void) = 0;
  virtual std::string benchmarkComments(void);

  virtual std::string packageVersion(void);
  virtual int packageSize(void); /* in bytes */
  virtual std::string packageComments(void);
  virtual std::string localPackageName(void);
		

 protected:

  CBMBenchmarkSCIMARK2(class CBMSystem *_system);

  virtual std::string language(void);
  virtual std::string benchmarkSCIMARK2Comments(void) = 0;
  virtual std::string scimark2BenchmarkLabel(void) = 0;

  virtual char* extractDirectory(void);
  virtual int hasPatch(void);
  virtual int patch(int _force = 0);

  virtual int extract(int _force = 0);
  virtual int preConfigure(int _force);
  virtual int configure(CBMCompiler        *_currentCompiler,
			CBMCompilerOptions *_currentOptions);

  virtual int make(void);
  virtual std::string bench(void);
  virtual int release(void);

 public:
  virtual std::string license(void);
  virtual std::string homePage(void);
  virtual std::string author(void);

  virtual int benchmarkSize(void);
  virtual ~CBMBenchmarkSCIMARK2();
		
};

/** \brief Defines the fourier benchmark within scimark2 package.
 */
class CBMBenchmarkSCIMARK2_FOURIER : public CBMBenchmarkSCIMARK2
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkSCIMARK2Comments(void);

  virtual std::string scimark2BenchmarkLabel(void);

 public:
  CBMBenchmarkSCIMARK2_FOURIER(class CBMSystem *_system);
  virtual ~CBMBenchmarkSCIMARK2_FOURIER();
};

/** \brief Defines the sor benchmark within scimark2 package.
 */
class CBMBenchmarkSCIMARK2_SOR : public CBMBenchmarkSCIMARK2
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkSCIMARK2Comments(void);

  virtual std::string scimark2BenchmarkLabel(void);

 public:
  CBMBenchmarkSCIMARK2_SOR(class CBMSystem *_system);
  virtual ~CBMBenchmarkSCIMARK2_SOR();
};

/** \brief Defines the mc benchmark within scimark2 package.
 */
class CBMBenchmarkSCIMARK2_MC : public CBMBenchmarkSCIMARK2
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkSCIMARK2Comments(void);

  virtual std::string scimark2BenchmarkLabel(void);

 public:
  CBMBenchmarkSCIMARK2_MC(class CBMSystem *_system);
  virtual ~CBMBenchmarkSCIMARK2_MC();
};

/** \brief Defines the smm benchmark within scimark2 package.
 */
class CBMBenchmarkSCIMARK2_SMM : public CBMBenchmarkSCIMARK2
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkSCIMARK2Comments(void);

  virtual std::string scimark2BenchmarkLabel(void);

 public:
  CBMBenchmarkSCIMARK2_SMM(class CBMSystem *_system);
  virtual ~CBMBenchmarkSCIMARK2_SMM();
};

/** \brief Defines the lu benchmark within scimark2 package.
 */
class CBMBenchmarkSCIMARK2_LU : public CBMBenchmarkSCIMARK2
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkSCIMARK2Comments(void);

  virtual std::string scimark2BenchmarkLabel(void);

 public:
  CBMBenchmarkSCIMARK2_LU(class CBMSystem *_system);
  virtual ~CBMBenchmarkSCIMARK2_LU();
};

lib_declare();

#endif

--- NEW FILE: Benchmark-BZIP2.cpp ---
#include <SupportedBenchmarks/Benchmark-BZIP2.h>
#include <System/System.h>

#include <config.h>

#include <fstream>


#include <SupportedBenchmarks/Benchmark-BZIP2.libwrapper.h>

CBMBenchmarkBZIP2::CBMBenchmarkBZIP2(CBMSystem *_system)
  : CBMBenchmarkxZIP(_system)
{
}

std::string CBMBenchmarkBZIP2::downloadURL(void)
{
  return("http://www.bzip.org/1.0.3/bzip2-1.0.3.tar.gz");
}

std::string CBMBenchmarkBZIP2::expectedMD5(void)
{
  return("8a716bebecb6e647d2e8a29ea5d8447f");
}

std::string CBMBenchmarkBZIP2::packageName(void)
{
  return("bzip2");
}

std::string CBMBenchmarkBZIP2::packageVersion(void)
{
  return("1.0.3");
}

int CBMBenchmarkBZIP2::packageSize(void)
{
  return(669075);
}

std::string CBMBenchmarkBZIP2::packageComments(void)
{
  return("Official bzip2-1.0.3 source package.");
}

std::string CBMBenchmarkBZIP2::localPackageName(void)
{
  return("bzip2-1.0.3.tar.Z");
}

std::string CBMBenchmarkBZIP2::language(void)
{
  return("C");
}

int CBMBenchmarkBZIP2::configure(CBMCompiler        *_currentCompiler,
				 CBMCompilerOptions *_currentOptions)
{
  return(1);
}

int CBMBenchmarkBZIP2::make(void)
{
  std::string cmd;
  std::string sstdout;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  cmd+=CBM_PROG_MAKE;
  cmd+=" bzip2 ";

  if (language()=="C") {
    cmd+="CC=";
  } else {
    if (language()=="C++") {
      cmd+="CXX=";
    } else {
      /* !!! */
    }
  }
  cmd+=currentCompiler->Binary();
  if (language()=="C") {
    cmd+=" CFLAGS=";
  } else {
    if (language()=="C++") {
      cmd+="CXXFLAGS=";
    } else {
      /* !!! */
    }
  }

  cmd+="'";
  cmd+=currentOptions->Options();
  cmd+="'";

  return(system->exec(cmd, sstdout)==0);
}

int CBMBenchmarkBZIP2::hasTest(void)
{
  return(1);
}

int CBMBenchmarkBZIP2::test(void)
{
  std::string cmd;
  std::string sstdout;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  cmd+=CBM_PROG_MAKE;
  cmd+=" check 2> /dev/null";

  return(system->exec(cmd, sstdout)==0);
}

char* CBMBenchmarkBZIP2::extractDirectory(void)
{
  return("bzip2-1.0.3");
}

std::string CBMBenchmarkBZIP2::benchmarkProgram(void)
{
  return("bzip2");
}

std::string CBMBenchmarkBZIP2::license(void)
{
  return("BSD-style");
}

std::string CBMBenchmarkBZIP2::homePage(void)
{
  return("http://www.bzip.org");
}

std::string CBMBenchmarkBZIP2::author(void)
{
  return("Written by Julian Seward");
}

int CBMBenchmarkBZIP2::benchmarkSize(void)
{
  return(76546048);
}

CBMBenchmarkBZIP2::~CBMBenchmarkBZIP2()
{
}
  
CBMBenchmarkBZIP21::CBMBenchmarkBZIP21(CBMSystem *_system)
  : CBMBenchmarkBZIP2(_system)
{
}

std::string CBMBenchmarkBZIP21::benchmarkName(void)
{
  return("bzip2-1c");
}

char* CBMBenchmarkBZIP21::compressionLevel(void)
{
  return("1");
}

std::string CBMBenchmarkBZIP21::benchmarkComments(void)
{
  return("Uses generated bzip2 binary with fastest compression");
}

CBMBenchmarkBZIP21::~CBMBenchmarkBZIP21()
{
}

CBMBenchmarkBZIP29::CBMBenchmarkBZIP29(CBMSystem *_system)
  : CBMBenchmarkBZIP2(_system)
{
}

std::string CBMBenchmarkBZIP29::benchmarkName(void)
{
  return("bzip2-9c");
}

char* CBMBenchmarkBZIP29::compressionLevel(void)
{
  return("9");
}

std::string CBMBenchmarkBZIP29::benchmarkComments(void)
{
  return("Uses generated bzip2 binary with maximum compression");
}

CBMBenchmarkBZIP29::~CBMBenchmarkBZIP29()
{
}

--- NEW FILE: Benchmark-Selector.cpp ---
#include <Benchmark/Benchmark-Selector.h>
#include <UI/UI.h>

#include <Benchmark/Benchmark-DLLoader.h>

CBMBenchmarkSelector::CBMBenchmarkSelector(CBMSystem *_system)
{
  system=_system;
}

CBMBenchmark *CBMBenchmarkSelector::select(char *benchmarkName)
{
  CBMBenchmark *result;
  std::string  tmp;

  result=cbmlib_bench_load(benchmarkName, system);
  if (!result) {
    tmp="Unknown benchmark '";
    tmp+=benchmarkName;
    tmp+="'";
    UI->Fatal(tmp);
    return(0);
  } else
    return(result);
}


void CBMBenchmarkSelector::displayList(void)
{
  CBMBenchmark *B;
  #include "Benchmark/Benchmark-Selector.liblist.h"
}


CBMBenchmarkSelector::~CBMBenchmarkSelector()
{
}


--- NEW FILE: Benchmark-Selector.h ---
/* ----------------------------------------------------------------------------
   $Id: Benchmark-Selector.h,v 1.1 2006/12/28 17:41:04 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */

#ifndef H_CBMBENCHMARKSELECTOR
#define H_CBMBENCHMARKSELECTOR

#include <Benchmark/Benchmark.h>

/** \brief Gives a benchmark object according to internal benchmark's name.
 *
 *  This class creates CBMBenchmark objects. It is only instancied once, and I
 *  currently see no need to derivate it.
 *  \sa CBMBenchmark::benchmarkName()
 */
class CBMBenchmarkSelector
{
 private:
 protected:
  class CBMSystem *system;

 public:
  /** Constructor */
  CBMBenchmarkSelector(class CBMSystem *_system);
  
  /** Main method.
   *  Returns a CBMBenchmarks object.
   *  \param benchmarkName Internal name of the benchmark object to get
   *  \sa CBMBenchmark::benchmarkName()
   */
  virtual CBMBenchmark *select(char *benchmarkName);

  /** Display all benchmarks.
   *  Display all known benchmarks regardless of their status.
   *  \sa CBMBenchmark::display()
   */  
  virtual void displayList(void);

  /** Virtual destructor */
  virtual ~CBMBenchmarkSelector();

};

#endif

--- NEW FILE: Benchmark-BENCHPPLINUX.h ---
#ifndef H_CBMBENCHMARKBENCHPPLINUX
#define H_CBMBENCHMARKBENCHPPLINUX

#include <Benchmark/Benchmark.h>

/** \brief Defines the benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX : public CBMBenchmark
{
 public:
 private:
  virtual std::string downloadURL(void);
  virtual std::string expectedMD5(void);

  virtual std::string packageName(void);
  virtual std::string benchmarkName(void) = 0;
  virtual std::string benchmarkComments(void);

  virtual std::string packageVersion(void);
  virtual int packageSize(void); /* in bytes */
  virtual std::string packageComments(void);

  virtual std::string language(void);
  virtual std::string localPackageName(void);
		

 protected:

  CBMBenchmarkBENCHPPLINUX(class CBMSystem *_system);

  virtual std::string benchppBenchmark(void) = 0;

  virtual std::string benchmarkBENCHPPLINUXComments(void) = 0;

  virtual char* extractDirectory(void);

  virtual int preConfigure(int _force);
  virtual int extract(int _force = 0);
  virtual int configure(CBMCompiler        *_currentCompiler,
			CBMCompilerOptions *_currentOptions);

  virtual int make(void);
  virtual std::string bench(void);
  virtual int release(void);

 public:
  virtual std::string license(void);
  virtual std::string homePage(void);
  virtual std::string author(void);

  virtual int benchmarkSize(void);
  virtual ~CBMBenchmarkBENCHPPLINUX();
		
};

/** \brief Defines the dhrystone benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_DHRYSTONE : public CBMBenchmarkBENCHPPLINUX
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);

  virtual std::string benchppBenchmark(void);


 public:
  CBMBenchmarkBENCHPPLINUX_DHRYSTONE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_DHRYSTONE();
};

/** \brief Defines the whetstone benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_WHETSTONE : public CBMBenchmarkBENCHPPLINUX
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);

  virtual std::string benchppBenchmark(void);


 public:
  CBMBenchmarkBENCHPPLINUX_WHETSTONE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_WHETSTONE();
};

/** \brief Defines a generic class to get benchmark in benchpp-linux according
 *  to an iteration number and the internal compbenchmarks' timer. */
class CBMBenchmarkBENCHPPLINUX_IterationsPerSec : public CBMBenchmarkBENCHPPLINUX
{
 protected:
  CBMBenchmarkBENCHPPLINUX_IterationsPerSec(class CBMSystem *_system);

  virtual std::string bench(void);
  virtual ~CBMBenchmarkBENCHPPLINUX_IterationsPerSec();
};


/** \brief Defines the boolean assignment benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_BOOL_ASSIGN : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_BOOL_ASSIGN(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_BOOL_ASSIGN();
};


/** \brief Defines the 'boolean if' benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_BOOL_IF : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_BOOL_IF(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_BOOL_IF();
};

/** \brief Defines the 'two-way if/else' benchmark within benchpp-linux
 *   package.
 */
class CBMBenchmarkBENCHPPLINUX_2WAY_IFELSE : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_2WAY_IFELSE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_2WAY_IFELSE();
};


/** \brief Defines the 'two-way switch' benchmark within benchpp-linux
 *   package.
 */
class CBMBenchmarkBENCHPPLINUX_2WAY_SWITCH : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_2WAY_SWITCH(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_2WAY_SWITCH();
};


/** \brief Defines the '10-way if/else' benchmark within benchpp-linux
 *   package.
 */
class CBMBenchmarkBENCHPPLINUX_10WAY_IFELSE : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_10WAY_IFELSE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_10WAY_IFELSE();
};


/** \brief Defines the '10-way switch' benchmark within benchpp-linux
 *   package.
 */
class CBMBenchmarkBENCHPPLINUX_10WAY_SWITCH : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_10WAY_SWITCH(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_10WAY_SWITCH();
};

/** \brief Defines the '10-way sparse switch' benchmark within benchpp-linux
 *   package.
 */
class CBMBenchmarkBENCHPPLINUX_10WAY_SPARSE_SWITCH : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_10WAY_SPARSE_SWITCH(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_10WAY_SPARSE_SWITCH();
};

/** \brief Defines the '10-way virtual function call' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_10WAY_VFC : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_10WAY_VFC(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_10WAY_VFC();
};

/** \brief Defines the 'packed bit arrays' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_PACKEDBITARRAY : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_PACKEDBITARRAY(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_PACKEDBITARRAY();
};

/** \brief Defines the 'bit-fields' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_BITFIELDS : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_BITFIELDS(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_BITFIELDS();
};

/** \brief Defines the 'bit-fields and packed bit arrray' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_BITFIELDS_PBA : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_BITFIELDS_PBA(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_BITFIELDS_PBA();
};

/** \brief Defines the 'pack and unpack class object' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_PACKUNPACKOBJ : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_PACKUNPACKOBJ(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_PACKUNPACKOBJ();
};

/** \brief Defines the 'Constant Propagation' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_CONSTPROP : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_CONSTPROP(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_CONSTPROP();
};

/** \brief Defines the 'Constant Propagation' (hand optimized) benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_CONSTPROP_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_CONSTPROP_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_CONSTPROP_HO();
};

/** \brief Defines the 'Local Common Sub-expression' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_LOCALCSE : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_LOCALCSE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_LOCALCSE();
};

/** \brief Defines the 'Local Common Sub-expression' (hand optimized) benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_LOCALCSE_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_LOCALCSE_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_LOCALCSE_HO();
};


/** \brief Defines the 'Global Common Sub-expression' benchmark within
 *   benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_GLOBALCSE : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_GLOBALCSE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_GLOBALCSE();
};

/** \brief Defines the 'Global Common Sub-expression' (Hand optimized)
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_GLOBALCSE_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_GLOBALCSE_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_GLOBALCSE_HO();
};

/** \brief Defines the 'Unnecessary Copy'
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_UNNECCOPY : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_UNNECCOPY(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_UNNECCOPY();
};

/** \brief Defines the 'Unnecessary Copy' (Hand optimized)
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_UNNECCOPY_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_UNNECCOPY_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_UNNECCOPY_HO();
};

/** \brief Defines the 'Code Motion (including math functions)'
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_CODEMOTION : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_CODEMOTION(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_CODEMOTION();
};

/** \brief Defines the 'Code Motion (including math functions)',
 *  hand optimized, benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_CODEMOTION_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_CODEMOTION_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_CODEMOTION_HO();
};

/** \brief Defines the 'Induction Variable',
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_INDUCVAR : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_INDUCVAR(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_INDUCVAR();
};

/** \brief Defines the 'Induction Variable' (hand optimized)
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_INDUCVAR_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_INDUCVAR_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_INDUCVAR_HO();
};

/** \brief Defines the 'Reduction in Strength (including math functions)',
 *  hand optimized, benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_REDUCSTRENGTH_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_REDUCSTRENGTH_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_REDUCSTRENGTH_HO();
};

/** \brief Defines the 'Dead Code'
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_DEADCODE : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_DEADCODE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_DEADCODE();
};

/** \brief Defines the 'Dead Code', hand optimized,
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_DEADCODE_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_DEADCODE_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_DEADCODE_HO();
};

/** \brief Defines the 'Loop Jamming'
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_LOOPJAMMING : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_LOOPJAMMING(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_LOOPJAMMING();
};


/** \brief Defines the 'Loop Jamming', hand optimized,
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_LOOPJAMMING_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_LOOPJAMMING_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_LOOPJAMMING_HO();
};

/** \brief Defines the 'Redundant Code'
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_REDUNCODE : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_REDUNCODE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_REDUNCODE();
};


/** \brief Defines the 'Redundant Code' hand optimized
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_REDUNCODE_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_REDUNCODE_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_REDUNCODE_HO();
};

/** \brief Defines the 'String Ops'
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_STRINGOPS : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_STRINGOPS(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_STRINGOPS();
};

/** \brief Defines the 'String Ops', hand optimized,
 *  benchmark within benchpp-linux package.
 */
class CBMBenchmarkBENCHPPLINUX_STRINGOPS_HO : public CBMBenchmarkBENCHPPLINUX_IterationsPerSec
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPLINUXComments(void);


  virtual std::string benchppBenchmark(void);

 public:
  CBMBenchmarkBENCHPPLINUX_STRINGOPS_HO(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPPLINUX_STRINGOPS_HO();
};

lib_declare();

#endif

--- NEW FILE: Benchmark-GZIP.libwrapper.h ---
CBMBenchmark *cbmlib_getBenchmark(int idx, CBMSystem *_system)
{
  switch(idx) {
  case 0:
    return(new CBMBenchmarkGZIP1(_system));
    ;;
  case 1:
    return(new CBMBenchmarkGZIP9(_system));
    ;;
  default:
    return(0);
    ;;
  }
}

 CBMBenchmark *cbmlib_getBenchmarkByName(char *bench_id, CBMSystem *_system)
{
    std::string tmp = bench_id;

    if (tmp=="gzip-1c") {
       return(new CBMBenchmarkGZIP1(_system));
    }

    if (tmp=="gzip-9c") {
       return(new CBMBenchmarkGZIP9(_system));
    }

    return(0);
}
int cbmlib_getBenchmarkNumber(void)
{
  return(2);
}
std::vector<std::string> cbmlib_getBenchmarks(void)
{
  std::vector<std::string> result;

  result.push_back("gzip-1c");
  result.push_back("gzip-9c");

  return(result);
}



--- NEW FILE: Benchmark-LINPACKC.libwrapper.h ---
CBMBenchmark *cbmlib_getBenchmark(int idx, CBMSystem *_system)
{
  switch(idx) {
  case 0:
    return(new CBMBenchmarkLINPACKC_SP_UNROLL(_system));
    ;;
  case 1:
    return(new CBMBenchmarkLINPACKC_SP_ROLL(_system));
    ;;
  case 2:
    return(new CBMBenchmarkLINPACKC_DP_UNROLL(_system));
    ;;
  case 3:
    return(new CBMBenchmarkLINPACKC_DP_ROLL(_system));
    ;;
  default:
    return(0);
    ;;
  }
}

 CBMBenchmark *cbmlib_getBenchmarkByName(char *bench_id, CBMSystem *_system)
{
    std::string tmp = bench_id;

    if (tmp=="linpackc-sp-unroll") {
       return(new CBMBenchmarkLINPACKC_SP_UNROLL(_system));
    }

    if (tmp=="linpackc-sp-roll") {
       return(new CBMBenchmarkLINPACKC_SP_ROLL(_system));
    }

    if (tmp=="linpackc-dp-unroll") {
       return(new CBMBenchmarkLINPACKC_DP_UNROLL(_system));
    }

    if (tmp=="linpackc-dp-roll") {
       return(new CBMBenchmarkLINPACKC_DP_ROLL(_system));
    }

    return(0);
}
int cbmlib_getBenchmarkNumber(void)
{
  return(4);
}
std::vector<std::string> cbmlib_getBenchmarks(void)
{
  std::vector<std::string> result;

  result.push_back("linpackc-sp-unroll");
  result.push_back("linpackc-sp-roll");
  result.push_back("linpackc-dp-unroll");
  result.push_back("linpackc-dp-roll");

  return(result);
}



--- NEW FILE: Benchmark-GZIP.cpp ---
#include <SupportedBenchmarks/Benchmark-GZIP.h>
#include <System/System.h>

#include <fstream>

#include <config.h>

#include <SupportedBenchmarks/Benchmark-GZIP.libwrapper.h>

CBMBenchmarkGZIP::CBMBenchmarkGZIP(CBMSystem *_system)
  : CBMBenchmarkxZIP(_system)
{
}

std::string CBMBenchmarkGZIP::downloadURL(void)
{
  return("ftp://ftp.netscape.com/pub/unsupported/gnu/gzip-1.2.4.tar.Z");
}

std::string CBMBenchmarkGZIP::expectedMD5(void)
{
  return("bfc104a6eaf1704be524c879bc9d29bc");
}

std::string CBMBenchmarkGZIP::packageName(void)
{
  return("gzip");
}

std::string CBMBenchmarkGZIP::packageVersion(void)
{
  return("1.2.4");
}

int CBMBenchmarkGZIP::packageSize(void)
{
  return(327865);
}

std::string CBMBenchmarkGZIP::packageComments(void)
{
  return("Official gzip-1.2.4 source package.");
}

std::string CBMBenchmarkGZIP::localPackageName(void)
{
  return("gzip-1.2.4.tar.Z");
}

std::string CBMBenchmarkGZIP::language(void)
{
  return("C");
}

int CBMBenchmarkGZIP::hasTest(void)
{
  return(1);
}

int CBMBenchmarkGZIP::test(void)
{
  std::string cmd;
  std::string sstdout;

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  cmd+=CBM_PROG_MAKE;
  cmd+=" test 2> /dev/null";

  return(system->exec(cmd, sstdout)==0);
}

char* CBMBenchmarkGZIP::extractDirectory(void)
{
  return("gzip-1.2.4");
}

std::string CBMBenchmarkGZIP::benchmarkProgram(void)
{
  return("gzip");
}

std::string CBMBenchmarkGZIP::license(void)
{
  return("GPL v2");
}

std::string CBMBenchmarkGZIP::homePage(void)
{
  return("http://www.gzip.org");
}

std::string CBMBenchmarkGZIP::author(void)
{
  return("Written by Jean-loup Gailly & Mark Adler");
}

int CBMBenchmarkGZIP::benchmarkSize(void)
{
  return(76546048);
}

CBMBenchmarkGZIP::~CBMBenchmarkGZIP()
{
}
  
CBMBenchmarkGZIP1::CBMBenchmarkGZIP1(CBMSystem *_system)
  : CBMBenchmarkGZIP(_system)
{
}

std::string CBMBenchmarkGZIP1::benchmarkName(void)
{
  return("gzip-1c");
}

char* CBMBenchmarkGZIP1::compressionLevel(void)
{
  return("1");
}

std::string CBMBenchmarkGZIP1::benchmarkComments(void)
{
  return("Uses generated gzip binary with fastest compression");
}

CBMBenchmarkGZIP1::~CBMBenchmarkGZIP1()
{
}

CBMBenchmarkGZIP9::CBMBenchmarkGZIP9(CBMSystem *_system)
  : CBMBenchmarkGZIP(_system)
{
}

std::string CBMBenchmarkGZIP9::benchmarkName(void)
{
  return("gzip-9c");
}

char* CBMBenchmarkGZIP9::compressionLevel(void)
{
  return("9");
}

std::string CBMBenchmarkGZIP9::benchmarkComments(void)
{
  return("Uses generated gzip binary with maximum compression");
}

CBMBenchmarkGZIP9::~CBMBenchmarkGZIP9()
{
}

--- NEW FILE: Makefile.am ---
# SupportedBenchmarks

lib_LTLIBRARIES				=	libcompbenchmarks-bm-gzip.la \
						libcompbenchmarks-bm-bzip2.la \
						libcompbenchmarks-bm-nbench.la \
						libcompbenchmarks-bm-scimark2.la \
						libcompbenchmarks-bm-benchpp.la \
						libcompbenchmarks-bm-benchpplinux.la \
						libcompbenchmarks-bm-linpackc.la

../libcompbenchmarks.la:
	make -C .. libcompbenchmarks.la

libcompbenchmarks_bm_gzip_la_LIBADD		= ../libcompbenchmarks.la
libcompbenchmarks_bm_bzip2_la_LIBADD		= ../libcompbenchmarks.la
libcompbenchmarks_bm_nbench_la_LIBADD		= ../libcompbenchmarks.la
libcompbenchmarks_bm_scimark2_la_LIBADD 	= ../libcompbenchmarks.la
libcompbenchmarks_bm_benchpp_la_LIBADD 		= ../libcompbenchmarks.la
libcompbenchmarks_bm_benchpplinux_la_LIBADD	= ../libcompbenchmarks.la
libcompbenchmarks_bm_linpackc_la_LIBADD 	= ../libcompbenchmarks.la

Benchmark-GZIP.cpp: $(top_srcdir)/SupportedBenchmarks/Benchmark-GZIP.libwrapper.h
libcompbenchmarks_bm_gzip_la_SOURCES	=	Benchmark-GZIP.cpp Benchmark-GZIP.h

Benchmark-BZIP2.cpp: $(top_srcdir)/SupportedBenchmarks/Benchmark-BZIP2.libwrapper.h
libcompbenchmarks_bm_bzip2_la_SOURCES	=	Benchmark-BZIP2.cpp Benchmark-BZIP2.h

Benchmark-NBENCH.cpp: $(top_srcdir)/SupportedBenchmarks/Benchmark-NBENCH.libwrapper.h
libcompbenchmarks_bm_nbench_la_SOURCES	=	Benchmark-NBENCH.cpp Benchmark-NBENCH.h

Benchmark-SCIMARK2.cpp: $(top_srcdir)/SupportedBenchmarks/Benchmark-SCIMARK2.libwrapper.h
libcompbenchmarks_bm_scimark2_la_SOURCES	=	Benchmark-SCIMARK2.cpp Benchmark-SCIMARK2.h

Benchmark-BENCHPP.cpp: $(top_srcdir)/SupportedBenchmarks/Benchmark-BENCHPP.libwrapper.h
libcompbenchmarks_bm_benchpp_la_SOURCES	=	Benchmark-BENCHPP.cpp Benchmark-BENCHPP.h

Benchmark-BENCHPPLINUX.cpp: $(top_srcdir)/SupportedBenchmarks/Benchmark-BENCHPPLINUX.libwrapper.h
libcompbenchmarks_bm_benchpplinux_la_SOURCES	=	Benchmark-BENCHPPLINUX.cpp Benchmark-BENCHPPLINUX.h

Benchmark-LINPACKC.cpp: $(top_srcdir)/SupportedBenchmarks/Benchmark-LINPACKC.libwrapper.h
libcompbenchmarks_bm_linpackc_la_SOURCES   =	Benchmark-LINPACKC.cpp Benchmark-LINPACKC.h

# libBenchmark_la_LIBADD			=	Compiler/libBenchmarkCompiler.la

INCLUDES				=	-I $(top_srcdir)

CBM_GENLIBWRAPPER			=	$(top_srcdir)/SupportedBenchmarks/benchmarks-genlibwrapper.sh


EXTRA_DIST				=	benchmarks-genlibwrapper.sh benchmarks.list

%.libwraXpper.h: $(top_srcdir)/SupportedBenchmarks/benchmarks.list $(CBM_GENLIBWRAPPER)
	echo ">>>>>>>>>>>>>>>> $@"
	@(doit=0; echo -n "Checking $@ : "; if test ! -f $(top_srcdir)/SupportedBenchmarks/$@; then \
	doit=1; \
	fi; \
	$(CBM_GENLIBWRAPPER) $@ $(top_srcdir)/SupportedBenchmarks > $@.tmp; \
	if test $$doit = "1"; then \
	mv $@.tmp $@ && echo "created."; \
	else \
	diff $@.tmp $@ > /dev/null; \
	if test ! $$? == 0; then mv $@.tmp $@ && echo "updated."; else \
	echo "up-to-date."; \
	fi; \
	fi; \
	rm $@.tmp 2> /dev/null; exit 0)

$(top_srcdir)/SupportedBenchmarks/%.libwrapper.h: $(top_srcdir)/SupportedBenchmarks/benchmarks.list $(CBM_GENLIBWRAPPER)
	$(CBM_GENLIBWRAPPER) $@ $(top_srcdir)/SupportedBenchmarks > $@

clean-all: rm *.libwrapper.h
--- NEW FILE: Benchmark-BENCHPP.h ---
/* ----------------------------------------------------------------------------
   $Id: Benchmark-BENCHPP.h,v 1.1 2006/12/28 17:41:02 xfred Exp $

   This is free software.
   For details, see the GNU Public License in the COPYING file, or
   Look http://www.fsf.org
   ------------------------------------------------------------------------- */

#ifndef H_CBMBENCHMARKBENCHPP
#define H_CBMBENCHMARKBENCHPP

#include <Benchmark/Benchmark.h>

/** \brief Defines the benchpp package.
 */
class CBMBenchmarkBENCHPP : public CBMBenchmark
{
 public:
 private:
  virtual std::string downloadURL(void);
  virtual std::string expectedMD5(void);

  virtual std::string packageName(void);
  virtual std::string benchmarkName(void) = 0;
  virtual std::string benchmarkComments(void);

  virtual std::string packageVersion(void);
  virtual int packageSize(void); /* in bytes */
  virtual std::string packageComments(void);
  virtual std::string localPackageName(void);
		

 protected:

  CBMBenchmarkBENCHPP(class CBMSystem *_system);

  virtual std::string language(void);
  virtual std::string benchppBenchmark(void) = 0;

  virtual std::string benchmarkBENCHPPComments(void) = 0;

  virtual char* extractDirectory(void);
  virtual int hasPatch(void);
  virtual int patch(int _force = 0);

  virtual int extract(int _force = 0);
  virtual int preConfigure(int _force);
  virtual int configure(CBMCompiler        *_currentCompiler,
			CBMCompilerOptions *_currentOptions);

  virtual int make(void);
  virtual std::string bench(void);
  virtual int release(void);

 public:
  virtual std::string license(void);
  virtual std::string homePage(void);
  virtual std::string author(void);

  virtual int benchmarkSize(void);
  virtual ~CBMBenchmarkBENCHPP();
		
};

/** \brief Defines the dhrystone benchmark within benchpp package.
 */
class CBMBenchmarkBENCHPP_DHRYSTONE : public CBMBenchmarkBENCHPP
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPComments(void);

  virtual std::string benchppBenchmark(void);


 public:
  CBMBenchmarkBENCHPP_DHRYSTONE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPP_DHRYSTONE();
};

/** \brief Defines the whetstone benchmark within benchpp package.
 */
class CBMBenchmarkBENCHPP_WHETSTONE : public CBMBenchmarkBENCHPP
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPComments(void);

  virtual std::string benchppBenchmark(void);


 public:
  CBMBenchmarkBENCHPP_WHETSTONE(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPP_WHETSTONE();
};

/** \brief Defines base stuff for stephanov benchmarks within benchpp package.
 */
class CBMBenchmarkBENCHPP_STEPANOV : public CBMBenchmarkBENCHPP
{
 protected:
  virtual std::string bench(void);
 public:
  CBMBenchmarkBENCHPP_STEPANOV(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPP_STEPANOV();
};

/** \brief Defines the stephanov-al12 benchmark within benchpp package.
 */
class CBMBenchmarkBENCHPP_STEPANOV_AL12 : public CBMBenchmarkBENCHPP_STEPANOV
{
 protected:
  virtual std::string benchmarkName(void);
  virtual std::string benchmarkBENCHPPComments(void);

  virtual std::string benchppBenchmark(void);
 public:
  CBMBenchmarkBENCHPP_STEPANOV_AL12(class CBMSystem *_system);
  virtual ~CBMBenchmarkBENCHPP_STEPANOV_AL12();
};

lib_declare();

#endif

--- NEW FILE: Benchmark-BENCHPPLINUX.libwrapper.h ---
CBMBenchmark *cbmlib_getBenchmark(int idx, CBMSystem *_system)
{
  switch(idx) {
  case 0:
    return(new CBMBenchmarkBENCHPPLINUX_DHRYSTONE(_system));
    ;;
  case 1:
    return(new CBMBenchmarkBENCHPPLINUX_WHETSTONE(_system));
    ;;
  case 2:
    return(new CBMBenchmarkBENCHPPLINUX_BOOL_ASSIGN(_system));
    ;;
  case 3:
    return(new CBMBenchmarkBENCHPPLINUX_BOOL_IF(_system));
    ;;
  case 4:
    return(new CBMBenchmarkBENCHPPLINUX_2WAY_IFELSE(_system));
    ;;
  case 5:
    return(new CBMBenchmarkBENCHPPLINUX_2WAY_SWITCH(_system));
    ;;
  case 6:
    return(new CBMBenchmarkBENCHPPLINUX_10WAY_IFELSE(_system));
    ;;
  case 7:
    return(new CBMBenchmarkBENCHPPLINUX_10WAY_SWITCH(_system));
    ;;
  case 8:
    return(new CBMBenchmarkBENCHPPLINUX_10WAY_SPARSE_SWITCH(_system));
    ;;
  case 9:
    return(new CBMBenchmarkBENCHPPLINUX_10WAY_VFC(_system));
    ;;
  case 10:
    return(new CBMBenchmarkBENCHPPLINUX_PACKEDBITARRAY(_system));
    ;;
  case 11:
    return(new CBMBenchmarkBENCHPPLINUX_BITFIELDS(_system));
    ;;
  case 12:
    return(new CBMBenchmarkBENCHPPLINUX_BITFIELDS_PBA(_system));
    ;;
  case 13:
    return(new CBMBenchmarkBENCHPPLINUX_PACKUNPACKOBJ(_system));
    ;;
  case 14:
    return(new CBMBenchmarkBENCHPPLINUX_CONSTPROP(_system));
    ;;
  case 15:
    return(new CBMBenchmarkBENCHPPLINUX_CONSTPROP_HO(_system));
    ;;
  case 16:
    return(new CBMBenchmarkBENCHPPLINUX_LOCALCSE(_system));
    ;;
  case 17:
    return(new CBMBenchmarkBENCHPPLINUX_LOCALCSE_HO(_system));
    ;;
  case 18:
    return(new CBMBenchmarkBENCHPPLINUX_GLOBALCSE(_system));
    ;;
  case 19:
    return(new CBMBenchmarkBENCHPPLINUX_GLOBALCSE_HO(_system));
    ;;
  case 20:
    return(new CBMBenchmarkBENCHPPLINUX_UNNECCOPY(_system));
    ;;
  case 21:
    return(new CBMBenchmarkBENCHPPLINUX_UNNECCOPY_HO(_system));
    ;;
  case 22:
    return(new CBMBenchmarkBENCHPPLINUX_CODEMOTION(_system));
    ;;
  case 23:
    return(new CBMBenchmarkBENCHPPLINUX_CODEMOTION_HO(_system));
    ;;
  case 24:
    return(new CBMBenchmarkBENCHPPLINUX_INDUCVAR(_system));
    ;;
  case 25:
    return(new CBMBenchmarkBENCHPPLINUX_INDUCVAR_HO(_system));
    ;;
  case 26:
    return(new CBMBenchmarkBENCHPPLINUX_REDUCSTRENGTH_HO(_system));
    ;;
  case 27:
    return(new CBMBenchmarkBENCHPPLINUX_DEADCODE(_system));
    ;;
  case 28:
    return(new CBMBenchmarkBENCHPPLINUX_DEADCODE_HO(_system));
    ;;
  case 29:
    return(new CBMBenchmarkBENCHPPLINUX_LOOPJAMMING(_system));
    ;;
  case 30:
    return(new CBMBenchmarkBENCHPPLINUX_LOOPJAMMING_HO(_system));
    ;;
  case 31:
    return(new CBMBenchmarkBENCHPPLINUX_REDUNCODE(_system));
    ;;
  case 32:
    return(new CBMBenchmarkBENCHPPLINUX_REDUNCODE_HO(_system));
    ;;
  case 33:
    return(new CBMBenchmarkBENCHPPLINUX_STRINGOPS(_system));
    ;;
  case 34:
    return(new CBMBenchmarkBENCHPPLINUX_STRINGOPS_HO(_system));
    ;;
  default:
    return(0);
    ;;
  }
}

 CBMBenchmark *cbmlib_getBenchmarkByName(char *bench_id, CBMSystem *_system)
{
    std::string tmp = bench_id;

    if (tmp=="benchpplinux-dhrystone") {
       return(new CBMBenchmarkBENCHPPLINUX_DHRYSTONE(_system));
    }

    if (tmp=="benchpplinux-whetstone") {
       return(new CBMBenchmarkBENCHPPLINUX_WHETSTONE(_system));
    }

    if (tmp=="benchpplinux-bool-assign") {
       return(new CBMBenchmarkBENCHPPLINUX_BOOL_ASSIGN(_system));
    }

    if (tmp=="benchpplinux-bool-if") {
       return(new CBMBenchmarkBENCHPPLINUX_BOOL_IF(_system));
    }

    if (tmp=="benchpplinux-2wifelse") {
       return(new CBMBenchmarkBENCHPPLINUX_2WAY_IFELSE(_system));
    }

    if (tmp=="benchpplinux-2wswitch") {
       return(new CBMBenchmarkBENCHPPLINUX_2WAY_SWITCH(_system));
    }

    if (tmp=="benchpplinux-10wifelse") {
       return(new CBMBenchmarkBENCHPPLINUX_10WAY_IFELSE(_system));
    }

    if (tmp=="benchpplinux-10wswitch") {
       return(new CBMBenchmarkBENCHPPLINUX_10WAY_SWITCH(_system));
    }

    if (tmp=="benchpplinux-10wsparseswitch") {
       return(new CBMBenchmarkBENCHPPLINUX_10WAY_SPARSE_SWITCH(_system));
    }

    if (tmp=="benchpplinux-10wvfc") {
       return(new CBMBenchmarkBENCHPPLINUX_10WAY_VFC(_system));
    }

    if (tmp=="benchpplinux-packedbitarray") {
       return(new CBMBenchmarkBENCHPPLINUX_PACKEDBITARRAY(_system));
    }

    if (tmp=="benchpplinux-bitfields") {
       return(new CBMBenchmarkBENCHPPLINUX_BITFIELDS(_system));
    }

    if (tmp=="benchpplinux-bitfields-pba") {
       return(new CBMBenchmarkBENCHPPLINUX_BITFIELDS_PBA(_system));
    }

    if (tmp=="benchpplinux-packunpackobjets") {
       return(new CBMBenchmarkBENCHPPLINUX_PACKUNPACKOBJ(_system));
    }

    if (tmp=="benchpplinux-constantpropagation") {
       return(new CBMBenchmarkBENCHPPLINUX_CONSTPROP(_system));
    }

    if (tmp=="benchpplinux-constantpropagation-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_CONSTPROP_HO(_system));
    }

    if (tmp=="benchpplinux-localcommonse") {
       return(new CBMBenchmarkBENCHPPLINUX_LOCALCSE(_system));
    }

    if (tmp=="benchpplinux-localcommonse-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_LOCALCSE_HO(_system));
    }

    if (tmp=="benchpplinux-globalcommonse") {
       return(new CBMBenchmarkBENCHPPLINUX_GLOBALCSE(_system));
    }

    if (tmp=="benchpplinux-globalcommonse-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_GLOBALCSE_HO(_system));
    }

    if (tmp=="benchpplinux-unneccopy") {
       return(new CBMBenchmarkBENCHPPLINUX_UNNECCOPY(_system));
    }

    if (tmp=="benchpplinux-unneccopy-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_UNNECCOPY_HO(_system));
    }

    if (tmp=="benchpplinux-codemotion") {
       return(new CBMBenchmarkBENCHPPLINUX_CODEMOTION(_system));
    }

    if (tmp=="benchpplinux-codemotion-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_CODEMOTION_HO(_system));
    }

    if (tmp=="benchpplinux-inducvar") {
       return(new CBMBenchmarkBENCHPPLINUX_INDUCVAR(_system));
    }

    if (tmp=="benchpplinux-inducvar-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_INDUCVAR_HO(_system));
    }

    if (tmp=="benchpplinux-reducstrength-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_REDUCSTRENGTH_HO(_system));
    }

    if (tmp=="benchpplinux-deadcode") {
       return(new CBMBenchmarkBENCHPPLINUX_DEADCODE(_system));
    }

    if (tmp=="benchpplinux-deadcode-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_DEADCODE_HO(_system));
    }

    if (tmp=="benchpplinux-loopjamming") {
       return(new CBMBenchmarkBENCHPPLINUX_LOOPJAMMING(_system));
    }

    if (tmp=="benchpplinux-loopjamming-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_LOOPJAMMING_HO(_system));
    }

    if (tmp=="benchpplinux-reduncode") {
       return(new CBMBenchmarkBENCHPPLINUX_REDUNCODE(_system));
    }

    if (tmp=="benchpplinux-reduncode-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_REDUNCODE_HO(_system));
    }

    if (tmp=="benchpplinux-stringops") {
       return(new CBMBenchmarkBENCHPPLINUX_STRINGOPS(_system));
    }

    if (tmp=="benchpplinux-stringops-ho") {
       return(new CBMBenchmarkBENCHPPLINUX_STRINGOPS_HO(_system));
    }

    return(0);
}
int cbmlib_getBenchmarkNumber(void)
{
  return(35);
}
std::vector<std::string> cbmlib_getBenchmarks(void)
{
  std::vector<std::string> result;

  result.push_back("benchpplinux-dhrystone");
  result.push_back("benchpplinux-whetstone");
  result.push_back("benchpplinux-bool-assign");
  result.push_back("benchpplinux-bool-if");
  result.push_back("benchpplinux-2wifelse");
  result.push_back("benchpplinux-2wswitch");
  result.push_back("benchpplinux-10wifelse");
  result.push_back("benchpplinux-10wswitch");
  result.push_back("benchpplinux-10wsparseswitch");
  result.push_back("benchpplinux-10wvfc");
  result.push_back("benchpplinux-packedbitarray");
  result.push_back("benchpplinux-bitfields");
  result.push_back("benchpplinux-bitfields-pba");
  result.push_back("benchpplinux-packunpackobjets");
  result.push_back("benchpplinux-constantpropagation");
  result.push_back("benchpplinux-constantpropagation-ho");
  result.push_back("benchpplinux-localcommonse");
  result.push_back("benchpplinux-localcommonse-ho");
  result.push_back("benchpplinux-globalcommonse");
  result.push_back("benchpplinux-globalcommonse-ho");
  result.push_back("benchpplinux-unneccopy");
  result.push_back("benchpplinux-unneccopy-ho");
  result.push_back("benchpplinux-codemotion");
  result.push_back("benchpplinux-codemotion-ho");
  result.push_back("benchpplinux-induc...
 
[truncated message content]