PerfPlot.C

Go to the documentation of this file.

#include "PerfPlot.H"


void SetupOptions(CommandLineType &inComLine)
{
  inComLine.AddOption('c',"config",2,"configfile");
  inComLine.AddOption('d',"display");
  inComLine.AddOption('e',"efficiency");
  inComLine.AddOption('f',"files");
  inComLine.AddOption('g',"gnuplot",2,"batfile");
  inComLine.AddOption('h',"help");
  inComLine.AddOption('o',"outfile",2,"outfile");
  inComLine.AddOption('p',"plot",2,"batfile");
  inComLine.AddOption('s',"scalability",2,"outfile");
  inComLine.AddOption('m',"gridmode");
  inComLine.AddOption('w',"weak");
  inComLine.AddOption('l',"linear");
  inComLine.AddArgument("timing_output_list",1);
  inComLine.AddHelp('c',"Set configuration file name to <configfile>.");
  inComLine.AddHelp('d',"Use GNUPlot to display plots to screen.");
  inComLine.AddHelp('e',"Set efficiency mode for plotting parallel efficiency.");
  inComLine.AddHelp('f',"Use GNUPlot to create plot image files.");
  inComLine.AddHelp('g',"Set output gnuplot bat file root name to <batfile>.");
  inComLine.AddHelp('h',"This long, detailed help message.");
  inComLine.AddHelp('l',"Sets linear scale on scalability plots.");
  inComLine.AddHelp('m',"Sets \"grid mode\"; performance based on number of points in grid.");
  inComLine.AddHelp('o',"Set output data file name to <outfile>.");
  inComLine.AddHelp('p',"Set output gnuplot scalability bat file root name to <batfile>.");
  inComLine.AddHelp('s',"Set output scalability data file name to <outfile>.");
  inComLine.AddHelp('w',"Sets weak mode for scalability plots.");
  inComLine.AddArgHelp("timing_output_list","Space-delimited list of PlasComCM timer outputs.");
  inComLine.SetDescription("Utility for creating performance data and plots for parallel applications.");  
}

int main(int argc,char *argv[])
{
  CommandLineType timingCommandLine((const char **)argv);
  SetupOptions(timingCommandLine);
  int comLineError = timingCommandLine.ProcessOptions();

  if(!argv[1]){
    std::cout << timingCommandLine.ShortUsage() << std::endl;
    return(1);
  } else if(!timingCommandLine.GetOption("help").empty()){
    std::cout << timingCommandLine.LongUsage() << std::endl;
    return(0);
  } else if (comLineError){
    std::cout << timingCommandLine.ErrorReport() << std::endl
              << timingCommandLine.ShortUsage() << std::endl;
    return(1);
  }
  
  bool displayPlots    = !timingCommandLine.GetOption("display").empty();
  bool createPlotFiles = !timingCommandLine.GetOption("files").empty();
  bool linearScale     = !timingCommandLine.GetOption("linear").empty();
  bool weakMode        = !timingCommandLine.GetOption("weak").empty();
  bool gridMode        = !timingCommandLine.GetOption("gridmode").empty();
  bool effMode         = !timingCommandLine.GetOption("efficiency").empty();

  std::string configFileName(timingCommandLine.GetOption("config"));
  ConfigType timingConfig;
  //  SetConfigurationDefaults(timingConfig);
  if(!configFileName.empty()){
    std::ifstream configFile;
    if(OpenFile(configFile,configFileName)){
      std::cerr << "Could not open configuration file, "
                << configFileName << "." << std::endl;
      return(1);
    }
    configFile >> timingConfig;
    configFile.close();
  }
  std::string platformName(timingConfig.GetValue("PlatformName"));

  std::string outFileName(timingCommandLine.GetOption("outfile"));
  if(outFileName.empty())
    outFileName = "TimingData.txt";

  std::string scalaFileName(timingCommandLine.GetOption("scalability"));
  if(scalaFileName.empty())
    scalaFileName = "ScalabilityData.txt";

  std::string batFileName(timingCommandLine.GetOption("gnuplot"));
  if(batFileName.empty())
    batFileName = "plottiming.gp";

  std::string scalaBatFileName(timingCommandLine.GetOption("plot"));
  if(scalaBatFileName.empty())
    scalaBatFileName = "plotscalability.gp";

  std::vector<std::string> timingFileNames(timingCommandLine.GetArgs());
  int numRuns = timingFileNames.size();

  derivedtimers derivedTimers;
  SetupDerivedTimers(derivedTimers,timingConfig);
  int numDerivedTimers = derivedTimers.size();

  timerlist excludedTimers;
  SetupExcludedTimers(excludedTimers,timingConfig);

  timersettings timerSettings;
  SetupTimerSettings(timerSettings,timingConfig);
  int dataColumn = timerSettings.dataColumn;
  if(weakMode)
    timerSettings.weakMode = true;
  if(gridMode)
    timerSettings.gridMode = true;
  if(effMode)
    timerSettings.effMode = true;

  std::vector<struct pcrun> pcRuns(numRuns);
  timerlist allRoutineNames;

  // Loop through all input timing file names
  std::vector<std::string>::iterator timingFileIterator = timingFileNames.begin();
  while(timingFileIterator != timingFileNames.end()){

    int runIndex = timingFileIterator - timingFileNames.begin();
    std::string &timingFileName(*timingFileIterator++);

    // open timing file
    std::ifstream timingFile;
    if(OpenFile(timingFile,timingFileName)){
      std::cerr << "Could not open timing file, "
                <<  timingFileName << "." << std::endl;
      return(1);
    }

    // get info about the specific run in the timing file
    PopulateRunInfo(pcRuns[runIndex].pcRunInfo,timingFile);
    // if(pcRuns[runIndex].pcRunInfo.platformName.empty())
    //   pcRuns[runIndex].pcRunInfo.platformName = platformName;

    // populate the timer values
    pcruntimes runTimes;
    ReadTimers(runTimes,timingFile,dataColumn);
    timingFile.close();
    
    // massage the timers according to the derived/excluded 
    // timers and settings 
    pctimervalue timingDelta;
    pcRuns[runIndex].pcRunTimes = ProcessRun(pcRuns[runIndex].pcRunInfo,runTimes,derivedTimers,
                                             excludedTimers,timerSettings,timingDelta);
    
    // Keep track of all important routine names across all runs
    pcruntimes::iterator runIt = pcRuns[runIndex].pcRunTimes.begin();
    while(runIt != pcRuns[runIndex].pcRunTimes.end())
      allRoutineNames.push_back(runIt++->first);
    allRoutineNames.sort();
    allRoutineNames.unique();
    
    // report the difference between the tracked timers
    // and the application runtime
    std::cout << "Timing delta for " << timingFileName 
              << " = (" << timingDelta.min << "," 
              << timingDelta.max << ","
              << timingDelta.mean << ")" << std::endl;
  }

  std::ofstream outFile;
  outFile.open(outFileName.c_str());
  std::ostringstream outStream;
  SummarizeTimingData(outStream,pcRuns,allRoutineNames,timerSettings);
  outFile << outStream.str();
  outFile.close();

  if(pcRuns.size() > 1){

    outStream.clear();
    outStream.str("");
    std::ofstream scalaFile;
    scalaFile.open(scalaFileName.c_str());
    SummarizeScalabilityData(outStream,pcRuns,allRoutineNames,timerSettings);
    scalaFile << outStream.str();
    scalaFile.close();
    
    outStream.clear();
    outStream.str("");
    MultiRunPlotCommands(outStream,outFileName,pcRuns,timerSettings);
    outFile.open(batFileName.c_str());
    outFile << outStream.str();
    outFile.close();

    if(createPlotFiles)
      apptools::GNUPlot(outStream.str());

    if(displayPlots){
      outStream.clear();
      outStream.str("");
      MultiRunPlotCommands(outStream,outFileName,pcRuns,timerSettings,true);
      apptools::GNUPlot(outStream.str());
    }

    std::ofstream scalaBatFile;
    scalaBatFile.open(scalaBatFileName.c_str());
    outStream.clear();
    outStream.str("");
    SpeedUpPlotCommands(outStream,scalaFileName,allRoutineNames,pcRuns,timerSettings,false,linearScale);
    scalaBatFile << outStream.str();
    scalaBatFile.close();
    
    if(createPlotFiles)
      apptools::GNUPlot(outStream.str());
    
    if(displayPlots){
      outStream.clear();
      outStream.str("");
      SpeedUpPlotCommands(outStream,scalaFileName,allRoutineNames,pcRuns,timerSettings,true,linearScale);
      apptools::GNUPlot(outStream.str());
    }
  } else {

    outStream.clear();
    outStream.str("");
    SingleRunPlotCommands(outStream,outFileName,pcRuns,0,timerSettings);
    outFile.open(batFileName.c_str());
    outFile << outStream.str();
    outFile.close();

    if(createPlotFiles)
      apptools::GNUPlot(outStream.str());

    if(displayPlots){
      outStream.clear();
      outStream.str("");
      SingleRunPlotCommands(outStream,outFileName,pcRuns,0,timerSettings,true);
      apptools::GNUPlot(outStream.str());
    }

  }

  return(0);
}