[Compbench-devel] CompBenchmarks++/Benchmark Benchmark-BENCHPPLINUX.cpp, NONE, 1.1 Benchmark-BENCHPPLINUX.h, NONE, 1.1 benchmarks.list, 1.1, 1.2

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

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

Modified Files:
	benchmarks.list 
Added Files:
	Benchmark-BENCHPPLINUX.cpp Benchmark-BENCHPPLINUX.h 
Log Message:
Supports of a few benchmarks providen in benchpplinux.

Index: benchmarks.list
===================================================================
RCS file: /cvsroot/compbench/CompBenchmarks++/Benchmark/benchmarks.list,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** benchmarks.list	1 Nov 2006 13:13:12 -0000	1.1
--- benchmarks.list	4 Dec 2006 19:17:13 -0000	1.2
***************
*** 24,30 ****
  benchpp-whetstone:BENCHPP:BENCHPP_WHETSTONE
  benchpp-stepanov-al12:BENCHPP:BENCHPP_STEPANOV_AL12
  linpackc-sp-unroll:LINPACKC:LINPACKC_SP_UNROLL
  linpackc-sp-roll:LINPACKC:LINPACKC_SP_ROLL
  linpackc-dp-unroll:LINPACKC:LINPACKC_DP_UNROLL
  linpackc-dp-roll:LINPACKC:LINPACKC_DP_ROLL
- 
--- 24,31 ----
  benchpp-whetstone:BENCHPP:BENCHPP_WHETSTONE
  benchpp-stepanov-al12:BENCHPP:BENCHPP_STEPANOV_AL12
+ benchpplinux-dhrystone:BENCHPPLINUX:BENCHPPLINUX_DHRYSTONE
+ benchpplinux-whetstone:BENCHPPLINUX:BENCHPPLINUX_WHETSTONE
  linpackc-sp-unroll:LINPACKC:LINPACKC_SP_UNROLL
  linpackc-sp-roll:LINPACKC:LINPACKC_SP_ROLL
  linpackc-dp-unroll:LINPACKC:LINPACKC_DP_UNROLL
  linpackc-dp-roll:LINPACKC:LINPACKC_DP_ROLL

--- 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 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 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();
};

lib_declare();

#endif

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

#include <config.h>

#include <fstream>

#include "Benchmark/Benchmark-BENCHPPLINUX.libwrapper.h"

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

std::string CBMBenchmarkBENCHPPLINUX::downloadURL(void)
{
  return("http://downloads.sourceforge.net/benchpplinux/bench_plus_plus_1.1_linux5.tgz");
}

std::string CBMBenchmarkBENCHPPLINUX::expectedMD5(void)
{
  return("003deea400b98ec0bc14f4227a99f2c5");
}

std::string CBMBenchmarkBENCHPPLINUX::packageName(void)
{
  return("benchpp-linux");
}

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

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

  return(comment);
}

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

int CBMBenchmarkBENCHPPLINUX::packageSize(void)
{
  return(83702);
}

std::string CBMBenchmarkBENCHPPLINUX::packageComments(void)
{
  return("Bench++ for Linux was initially a port of Bench++ (based on" \
	 "ADA PIWG suite) to Linux.");
}

std::string CBMBenchmarkBENCHPPLINUX::localPackageName(void)
{
  return("bench_plus_plus_1.1_linux5.tgz");
}

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

char* CBMBenchmarkBENCHPPLINUX::extractDirectory(void)
{
  return("bench++-linux");
}

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

  cmd+="cd ";
  cmd+=system->temporaryDirectory(CBMSystem::Extract);
  cmd+=" && ";
  cmd+=CBM_PROG_MKDIR;
  cmd+=" bench++-linux-tmp && ";
  cmd+=CBM_PROG_ZCAT;
  cmd+=" ";
  cmd+=localFile;
  cmd+=" | ";
  cmd+=CBM_PROG_TAR;
  cmd+=" xvf - -C bench++-linux-tmp && mv bench++-linux-tmp/bench++ bench++-linux && rm -rf bench++-linux-tmp";

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

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

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

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  
  cmd+="CC=\"";
  cmd+=_currentCompiler->Binary();
  cmd+="\" ";
  if (_currentOptions->Options() != "") {
    cmd+="CCFLAGS=\"";
    cmd+=_currentOptions->Options();
    cmd+="\"";
  }

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

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

  cmd="cd ";
  cmd+=localPackageAbsoluteDirectory();
  cmd+=" && ";
  cmd+=CBM_PROG_MAKE;
  cmd+=" a000091 a000092"; // !!! #5a;

  cmd+=" CC=\"";
  cmd+=currentCompiler->Binary();
  cmd+="\" ";
  cmd+=" CCFLAGS=\'-DHAS_BOOL=1 -DGETTIMEOFDAY_UNDEF=0 ";
  cmd+=currentOptions->Options();
  cmd+="' 2> /dev/null";

  printf("%s\n", cmd.c_str());
  return(system->exec(cmd, sstdout)==0);
}

std::string CBMBenchmarkBENCHPPLINUX::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 CBMBenchmarkBENCHPPLINUX::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 CBMBenchmarkBENCHPPLINUX::license(void)
{
  return("Public domain");
}

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

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

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

CBMBenchmarkBENCHPPLINUX::~CBMBenchmarkBENCHPPLINUX()
{
}

CBMBenchmarkBENCHPPLINUX_DHRYSTONE::CBMBenchmarkBENCHPPLINUX_DHRYSTONE(CBMSystem *_system)
  : CBMBenchmarkBENCHPPLINUX(_system)
{
}

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

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

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

CBMBenchmarkBENCHPPLINUX_DHRYSTONE::~CBMBenchmarkBENCHPPLINUX_DHRYSTONE()
{
}

CBMBenchmarkBENCHPPLINUX_WHETSTONE::CBMBenchmarkBENCHPPLINUX_WHETSTONE(CBMSystem *_system)
  : CBMBenchmarkBENCHPPLINUX(_system)
{
}

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

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

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

CBMBenchmarkBENCHPPLINUX_WHETSTONE::~CBMBenchmarkBENCHPPLINUX_WHETSTONE()
{
}