Tools/Xabsl2/GT/GTXabsl2Profiler/GTXabsl2ProfilerLog.cpp

Go to the documentation of this file.

#include "GTXabsl2ProfilerLog.h"

/**
 * LogEntry Stuff
 */
int GTXabsl2LogEntry::differsInParameters(GTXabsl2LogEntry& entry)
{
  if(this->activeOptions.size() != entry.activeOptions.size())
    return 0;
  for(unsigned int i = 0; i < this->activeOptions.size(); ++i)
    if(this->activeOptions[i].optionNumber != entry.activeOptions[i].optionNumber)
      return 0;
    else if(this->activeOptions[i].stateNumber != entry.activeOptions[i].stateNumber)
      return 0;
  return 1;
}
In& operator>>(In& in, GTXabsl2LogEntry& logEntry)
{
  logEntry.activeOptions.clear();
  logEntry.inputSymbolValues.clear();
  
  // frame
  in >> logEntry.frameNumber;
  
  
  // inputSymbols
  int nrOfSymbols;
  double inputSymbolValue;
  in >> nrOfSymbols;
  std::vector<double> inputSymbolValues;
  for(;nrOfSymbols > 0; --nrOfSymbols)
  {
    in >> inputSymbolValue;
    logEntry.inputSymbolValues.push_back(inputSymbolValue);
  }
  
  // option-graph
  int nrofoptions;
  in >> nrofoptions;
  std::vector<GTXabsl2ActiveOption> activeOptions;
  for(;nrofoptions > 0; --nrofoptions){
    int optionnumber;
    int statenumber;
    in >> optionnumber;
    in >> statenumber;
    
    int nrofparams;
    in >> nrofparams;
    std::vector<double> params;
    for(;nrofparams > 0; -- nrofparams){
      double param;
      in >> param;
      params.push_back(param);
    }
    
    logEntry.activeOptions.push_back(GTXabsl2ActiveOption(optionnumber, statenumber, params));
  }
  
  return in;
}

Out& operator<<(Out& out, const GTXabsl2LogEntry& logEntry)
{
 
  out << logEntry.frameNumber;
  out << logEntry.inputSymbolValues.size();
  for(unsigned int m = 0; m < logEntry.inputSymbolValues.size(); ++m)
  {
    out << logEntry.inputSymbolValues[m];
  }
  out << logEntry.activeOptions.size();
  for(unsigned int k = 0; k <logEntry.activeOptions.size(); ++k)
  {
    out << logEntry.activeOptions[k].optionNumber;
    out << logEntry.activeOptions[k].stateNumber;
    out << logEntry.activeOptions[k].parameters.size();
    for(unsigned l = 0; l < logEntry.activeOptions[k].parameters.size(); ++l){
      out << logEntry.activeOptions[k].parameters[l];
    }
  }
  
  return out;
  
}

/**
* GTXabsl2Log
*/
void GTXabsl2Log::init(Xabsl2Engine& pEngine)
{
  nameTable.init(pEngine);
  
  int i;
  for(i = 0; i < pEngine.numberOfDecimalInputSymbols();++i)
    inputSymbolNames.push_back(pEngine.getDecimalInputSymbol(i)->n);
  for(i = 0; i < pEngine.numberOfBooleanInputSymbols();++i)
    inputSymbolNames.push_back(pEngine.getBooleanInputSymbol(i)->n);
  for(i = 0; i < pEngine.numberOfEnumeratedInputSymbols();++i)
    inputSymbolNames.push_back(pEngine.getEnumeratedInputSymbol(i)->n);
}

In& operator>>(In& in, GTXabsl2Log& log)
{
  log.clear();
  if(in.eof())
    return in;
  
  // inputSymbols
  int inputSymbolTableSize = 0;
  char inputSymbolName[300];
  in >> inputSymbolTableSize;
  for(;inputSymbolTableSize > 0; --inputSymbolTableSize)
  {
    in >> inputSymbolName;
    log.inputSymbolNames.push_back(inputSymbolName);
    
  }
  
  // nametable
  in >> log.nameTable;
  
  // logs
  while(!in.eof()){
    GTXabsl2LogEntry entry;
    in >> entry;
    log.push_back(entry);
  }
  // check if log has non ascending frame numbers
  for(int i = 0; i < (int) log.size(); ++i){
    if(i > 0 && log[i-1].frameNumber > log[i].frameNumber)
      {
       log.clearAll();
       return in;
      }
  }
  return in;
}

Out& operator<<(Out& out, const GTXabsl2Log& log)
{
  unsigned int i;

  // inputsymbols
  out << log.inputSymbolNames.size();
  for(i = 0;i < log.inputSymbolNames.size(); ++i)
  {
    out << log.inputSymbolNames[i].c_str();
  }

  //nameTable
  out << log.nameTable;

  // logentries
  for(i = 0; i < log.size();++i){
    out << log[i];
 
  }
  return out;
}


void GTXabsl2Log::clearAll()
{
  clear();
  nameTable.clear();
  inputSymbolNames.clear();
}

/**
 * specific functions for log-access
 */
int GTXabsl2Log::getIndexOfFrameNumber(unsigned int frameNumber)
{
  for(unsigned int i = 0; i < this->size(); ++i)
  {
    if((*this)[i].frameNumber == unsigned(frameNumber))
      return int(i);
  }
  return -1;
}

int GTXabsl2Log::getActiveOptionNumberAtFrameNumber(unsigned int frameNumber, int optionMaxDepth)
{
  for(unsigned int i = 0; i < this->size(); ++i)
  {
    if((*this)[i].frameNumber == unsigned(frameNumber))
    {
      for(unsigned int j = 0; j < ((*this)[i]).activeOptions.size();++j)
      {
        if(nameTable[(((*this)[i]).activeOptions[j].optionNumber)].maxDepth == optionMaxDepth)
          return ((*this)[i]).activeOptions[j].optionNumber;
        else if(nameTable[(((*this)[i]).activeOptions[j].optionNumber)].maxDepth > optionMaxDepth)
          return -1;
      }

    }
  }
  return -1;
}

GTXabsl2ActiveOption GTXabsl2Log::getOption(int index, int optionMaxDepth)
{
  for(unsigned int j = 0; j < ((*this)[index]).activeOptions.size();++j)
  {
    if(nameTable[(((*this)[index]).activeOptions[j].optionNumber)].maxDepth == optionMaxDepth)
      return (*this)[index].activeOptions[j];
    else if(nameTable[(((*this)[index]).activeOptions[j].optionNumber)].maxDepth > optionMaxDepth)
      return GTXabsl2ActiveOption();
  }

  return GTXabsl2ActiveOption();
}

---