TestPerf.cc

Go to the documentation of this file.

#include <iostream> //System includes
#include <fstream>
#include <vector>

#include "TVector3.h" //ROOT includes
#include "TStopwatch.h"

#include "BField/BfldValidate.h" //headers for the rectilinear stuff
#include "BField/BfldLoanPool.h"
#include "MessageService/MsgService.h"

#include "TestConstants.h"

CVSID("$Id: TestPerf.cc,v 1.3 2001/08/21 19:42:54 agoldst Exp $");

const int kDefaultNumPerfTestPts = 1224;

class PerfTestFile {
public:
  PerfTestFile(const char *name);
  ~PerfTestFile(void);

  bool IsGood(void);
  void Store(int numPoints,float timeTaken,int algorithm,
             BfldInterpMethod::InterpMethod_t interp);

private:
  ofstream *outFile;
  static const char kHeader[40] = "BField Performance Test Results";

};

void BenchmarkPerformance(const char *outFileName,const char *rectMapFileName,
                          const char *vorMapFileName,
                          const char *vorMeshFileName,
                          const char *vorBFldFileName,
                          const char *testPtsFileName);
double RectPerformanceTest(const char *mapFileName,
                           BfldInterpMethod::InterpMethod_t interpMethod,
                           vector<TVector3> &testPts);
double VorPerformanceTest(const char *vorMapFileName,const char *meshFileName,
                          const char *vorBFieldFileName,
                          BfldInterpMethod::InterpMethod_t interpMethod,
                          vector<TVector3> &testPts);

int GetNumPointsRect(const char *fileName);
int GetNumPointsVor(const char *fileName);
BField *NewBFieldRect(const char *mapFileName);
BField *NewBFieldVor(const char *vorMapFileName,const char *meshFileName,
                     const char *vorBFieldFileName);

void GetPerfTestPts(vector<TVector3> &pts,const char *fileName);

void BenchmarkPerformance(const char *outFileName,const char *rectMapFileName,
                          const char *vorMapFileName,
                          const char *vorMeshFileName,
                          const char *vorBFldFileName,
                          const char *testPtsFileName) {
  //For each algorithm and interpolation method, compute the time to calculate
  //the B field as a function of number of points in the map used. This gives
  //a rough picture of the relation between performance and memory usage for
  //each interpolation algorithm.

  PerfTestFile outFile(outFileName);

  int numPoints;
  double timeTaken;

  //Read the test points into memory so that reading from the disk doesn't
  //affect the outcome of the test...is that what we want?
  vector<TVector3> testPts(kDefaultNumPerfTestPts);
  GetPerfTestPts(testPts,testPtsFileName);
  
  MSG("Bfldtest",Msg::kDebug) << "Testing rect2d algorithm..." << endl;
  MSG("Bfldtest",Msg::kDebug)
    << "At the moment, does not use file specified but instead" << endl;
  MSG("Bfldtest",Msg::kDebug)
    << "reverts to default file $BMAPPATH/bfld_142.dat" << endl;
  
  numPoints = GetNumPointsRect(rectMapFileName);
  
  //Iterate through the rectilinear interpolation methods.
  int j;  
  for(j = 0;j < kNumRectInterpMethods;j++) {
    MSG("Bfldtest",Msg::kDebug) << "Testing interpolation method: "
         << BfldInterpMethod::AsString(kRectInterpMethods[j]) << endl;
    timeTaken = RectPerformanceTest(rectMapFileName,kRectInterpMethods[j],
                                    testPts);
      
    outFile.Store(numPoints,timeTaken,kAlgRect,kRectInterpMethods[j]);
  }
  
  //Voronoi algorithm performance test

  MSG("Bfldtest",Msg::kDebug) << "Testing Voronoi algorithm..." << endl;
  MSG("Bfldtest",Msg::kDebug)
    << "At the moment does not use files specified but instead" << endl;
  MSG("Bfldtest",Msg::kDebug)
    << "reverts to default files BField/*.default" << endl;
  
  MSG("Bfldtest",Msg::kDebug) << "Using the following files:" << endl;
  MSG("Bfldtest",Msg::kDebug)
    << "Voronoi diagram file: " << vorMapFileName << endl;
  MSG("Bfldtest",Msg::kDebug)
    << "Voronoi mesh file: " << vorMeshFileName << endl;
  MSG("Bfldtest",Msg::kDebug)
    << "Generator BField data file: " << vorBFldFileName << endl;
  
  numPoints = GetNumPointsVor(vorMapFileName);
  
  for(j = 0;j < kNumVorInterpMethods;j++) {
    MSG("Bfldtest",Msg::kDebug) << "Testing interpolation method: "
         << BfldInterpMethod::AsString(kVorInterpMethods[j]) << endl;
    
    timeTaken = VorPerformanceTest(vorMapFileName,vorMeshFileName,
                                   vorBFldFileName,kVorInterpMethods[j],
                                   testPts);
    
    outFile.Store(numPoints,timeTaken,kAlgVor,kVorInterpMethods[j]);
  }
  
  MSG("Bfldtest",Msg::kInfo) << "Done with performance test." << endl;
  MSG("Bfldtest",Msg::kInfo) << "Output written to " << outFileName << endl;
}

double RectPerformanceTest(const char *mapFileName,
                           BfldInterpMethod::InterpMethod_t interpMethod,
                           vector<TVector3> &testPts) {
  //For the given mapFile, time how long it takes to compute the B field
  //by rectilinear interpolation at the points given in the performance test
  //point file--typically consisting of a number of plausible paths of muons
  //through the detectors.

  //Here should set up the rect interpolator (BField theField) using mapFile.
  //Will have to rewrite Bfld package to accept an arbitrary file in this form.
  //This should not take too much work. Otherwise, can be kludged.

  MSG("Bfldtest",Msg::kDebug) << "Beginning performance test..." << endl;

  BField *theField = NewBFieldRect(mapFileName);
  theField->SetInterpMethod(interpMethod);

  TVector3 b;
  int i;
  TStopwatch timer;

  theField->GetBField(testPts[0]);
  //We make a dummy call because the first call on GetBField has
  //lots of overhead (allocating maps, etc.)

  timer.Start();
  for(i = 0;i < testPts.size();++i)
    b = theField->GetBField(testPts[i]);
  timer.Stop();

  delete theField; //NewBFieldRect allocates memory!

  MSG("Bfldtest",Msg::kDebug) << "Test done." << endl;

  return timer.CpuTime();
}

double VorPerformanceTest(const char *vorMapFileName,const char *meshFileName,
                          const char *vorBFieldFileName,
                          BfldInterpMethod::InterpMethod_t interpMethod,
                          vector<TVector3> &testPts) {
  //For the given mapFile, compute the time needed to calculate the B field
  //at the points given in the performance test point file using the method
  //of the team from Athens, with the given interpolation method.

  BField *theField =  NewBFieldVor(vorMapFileName,meshFileName,
                                   vorBFieldFileName);
  theField->SetInterpMethod(interpMethod);
  TVector3 v,b;
  int i;

  theField->GetBField(testPts[0]);
  //We make a dummy call because the first call on GetBField has
  //lots of overhead (allocating maps, etc.)

  MSG("Bfldtest",Msg::kDebug) << "Beginning performance test..." << endl;

  TStopwatch timer;
  timer.Start();
  for(i = 0;i < testPts.size();++i)
    b = theField->GetBField(testPts[i]);
  timer.Stop();

  delete theField;

  MSG("Bfldtest",Msg::kDebug) << "Test done." << endl;

  return timer.CpuTime();
}

void GetPerfTestPts(vector<TVector3> &pts,const char *fileName) {
  //Read fileName into pts
  //For now, assume the file has the format of NuMuEventHits.dat
  //To wit, each line is int id, float x, float y, float z.
  //And the units are cm.
  //What does Swimmer output look like? This should really be isolated out.

  MSG("Bfldtest",Msg::kDebug) << "Reading in performance test points file "
                              << fileName << endl;

  ifstream inFile(fileName,ios::in);
  if(!inFile.good()) {
    MSG("Bfldtest",Msg::kWarning)
      << "Error opening file " << fileName << endl;
    return;
  }

  int n = pts.size();
  int i = 0;

  int id_ignored;
  float x,y,z;

  while(!inFile.eof()) {
    inFile >> id_ignored >> x >> y >> z;
    if(i >= n) {
      n *= 2;
      pts.resize(n);
    }

    pts[i].SetXYZ(x / 100.0,y / 100.0,z / 100.0);
    i++;
  }
  
  pts.resize(i);
}

PerfTestFile::PerfTestFile(const char*fileName) {
  outFile = 0;
  outFile = new ofstream(fileName,ios::out);
  if(outFile->good())
    (*outFile) << kHeader << endl << endl;
}

PerfTestFile::~PerfTestFile(void) {
  if(outFile)
    delete outFile;
}

bool PerfTestFile::IsGood(void) {
  return (!outFile) ? false : outFile->good();
}

void PerfTestFile::Store(int numPoints,float timeTaken,int algorithm,
                         BfldInterpMethod::InterpMethod_t interp) {

  if(algorithm == kAlgRect)
    (*outFile) << "Algorithm: Rect2d" << endl;
  else
    (*outFile) << "Algorithm: Voronoi" << endl;

  (*outFile) << "Interpolation: " << BfldInterpMethod::AsString(interp)
             << endl;
  (*outFile) << "CPU time taken: " << timeTaken << endl;
  // (*outFile) << "Estimated memory usage: " << numPoints << endl;
  // Currently we don't have a valid way of estimating this at runtime.
  (*outFile) << " --- " << endl;
}

---