CDCTriggerTSFFirmwareWorker.cc

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2017 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Tzu-An Sheng                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#include "trg/cdc/xsi_loader.h"
 
#include <trg/cdc/Cosim.h>
 
#include <string>
#include <iostream>
#include <array>
#include <algorithm>
#include <tuple>
 
#include <cstdio>
#include <cstring>
#include <unistd.h>
 
 
int Xsi::Loader::get_port_number_or_exit(std::string name)
{
  int portNumber = get_port_number(name.c_str());
  if (portNumber < 0) {
    std::cerr << "ERROR: " << name << " not found" << std::endl;
    throw;
  }
  return portNumber;
}
 
class CDCTriggerTSFFirmwareWorker {
public:
  CDCTriggerTSFFirmwareWorker(std::string design, std::string waveform, int nMergersIn):
    design_libname{design}, wdbName{waveform},
    loader{design, simengine_libname}, nMergers{nMergersIn}
  {
    inputWidth = nMergers * mergerWidth;
    inputToTSF.fill(Cosim::zero_val);
    outputToTracker.fill(0);
  };
  void initialize();
  void clock();
  void terminate();
  bool setInput(FILE*);
  void setInput(char*);
 
  static constexpr int mergerWidth = 256;
  static constexpr int maxInputWidth = 24 * mergerWidth;
  static constexpr int outputWidth = 429;
  static constexpr int nTrackers = 429;
 
  inline char* getInput()
  {
    return inputToTSF.data();
  }
 
  inline std::array<char, outputWidth * 4> getOutput()
  {
    return outputToTracker;
  }
 
  // inline std::array<char, outputWidth * nTrackers> getFlatOutput()
  // {
  //   std::array<char, outputWidth * nTrackers> flatOutput;
  //   auto itr = flatOutput.begin();
  //   for (const auto& out : outputToTracker) {
  //     copy(out.begin(), out.end(), itr);
  //     itr += outputWidth;
  //   }
  //   return flatOutput;
  // }
 
  inline std::string getStrOutput()
  {
    return std::string(outputToTracker.data());
  }
 
protected:
  std::string simengine_libname = "librdi_simulator_kernel.so";
  std::string design_libname;
  std::string wdbName;
  Xsi::Loader loader;
  s_xsi_setup_info info;
 
  int clk = 0;
  int inPort = 0;
  int outPort = 0;
  int enableIn = 0;
  int enableOutTracker = 0;
  int enableOutEVT = 0;
 
  int nMergers;
  int inputWidth;
 
  std::array<char, maxInputWidth> inputToTSF;
  std::array<char, outputWidth * 4> outputToTracker;
  char outputArray[429] = {};
 
};
 
using namespace Belle2;
using namespace Cosim;
using namespace std;
 
 
bool CDCTriggerTSFFirmwareWorker::setInput(FILE* stream)
{
  // array<char, 16384> buffer;
  // strangly, using 16384 or smaller for buffer size doesn't work.
  array<char, 32768> buffer;
  buffer.fill(1);
  // if (fgets(buffer.data(), maxInputWidth + 10, stream) != NULL) {
  if (fgets(buffer.data(), buffer.size(), stream) != NULL) {
    // if (LogSystem::Instance().getLogConfig()->getDebugLevel() > 100) {
    if (false) {
      cout << "received input to "  << wdbName << ":\n";
      for (int i = 0; i < inputWidth; ++i) {
        cout << static_cast<int>(buffer[i]);
      }
      cout << endl;
    }
    copy(buffer.begin(), buffer.begin() + inputWidth, inputToTSF.begin());
    return true;
  } else {
    return false;
  }
}
 
void CDCTriggerTSFFirmwareWorker::setInput(char* input)
{
  string buffer(input);
  copy(buffer.begin(), buffer.begin() + inputWidth, inputToTSF.begin());
}
 
void CDCTriggerTSFFirmwareWorker::initialize()
{
  std::cout << "Design DLL     : " << design_libname << std::endl;
  std::cout << "Sim Engine DLL : " << simengine_libname << std::endl;
 
  cout << getpid() << "\n";
  sleep(1);
  // try {
  memset(&info, 0, sizeof(info));
  info.logFileName = NULL;
  info.wdbFileName = const_cast<char*>(wdbName.c_str());
  loader.open(&info);
  loader.trace_all();
  string clkName = "user_clk_127";
  string inName = "data_in";
  string outName = "TSF_TRACKER_OUT";
  string enableInName = "valid_in";
  string enableTrackerName = "valid_tracker";
  string enableEVTName = "valid_evttime";
  // get I/O port signals
  clk = loader.get_port_number_or_exit(clkName);
  inPort = loader.get_port_number_or_exit(inName);
  outPort = loader.get_port_number_or_exit(outName);
  enableIn = loader.get_port_number_or_exit(enableInName);
  enableOutTracker = loader.get_port_number_or_exit(enableTrackerName);
  enableOutEVT = loader.get_port_number_or_exit(enableEVTName);
  int dataClock = loader.get_port_number_or_exit("user_clk_3175");
  // Start low clock
  loader.put_value(dataClock, &zero_val);
  loader.put_value(enableIn, &zero_val);
  loader.put_value(inPort, inputToTSF.data());
  for (int i = 0; i < 32; ++i) {
    if (i == 1) {
      loader.put_value(enableIn, &one_val);
    }
    loader.put_value(clk, &one_val);
    loader.run(10);
    loader.put_value(clk, &zero_val);
    loader.run(10);
  }
  cout << "worker " << design_libname << " initialized \n";
  // } catch (std::exception& e) {
  //   std::cerr << "ERROR: An exception occurred: " << e.what() << std::endl;
  // } catch (...) {
  //   std::cerr << "ERROR: An unknown exception occurred." << std::endl;
  //   // Xsi_Instance.get_error_info();
  //   throw;
  // }
}
 
void CDCTriggerTSFFirmwareWorker::terminate()
{
  loader.close();
}
 
void CDCTriggerTSFFirmwareWorker::clock()
{
  int status = 0;
  // assign input signals
  try {
    // Put clk to one
    // write the input
    loader.put_value(inPort, inputToTSF.data());
 
    loader.put_value(enableIn, &one_val);
    for (int j = 0; j < 4; j++) {
      // if (j == 0) {
      //   loader.put_value(enableIn, &one_val);
      // } else {
      //   loader.put_value(enableIn, &zero_val);
      // }
 
      loader.put_value(clk, &one_val);
      loader.run(10);
 
      // read the output
      loader.get_value(outPort, outputToTracker.data());
      // cout << "clk " << j << "\n";
      // for (int i2d=0; i2d < 4; ++i2d) {
      //   for (int i = outputWidth * i2d; i < outputWidth * (i2d + 1); ++i ) {
      //     cout << std_logic_literal[static_cast<int>(outputToTracker[i])];
      //   }
      //   cout << endl << flush;
      // }
      // Put clk to zero
      loader.put_value(clk, &zero_val);
      loader.run(10);
    }
  } catch (std::exception& e) {
    std::cerr << "ERROR: An exception occurred: " << e.what() << std::endl;
    status = 2;
  } catch (...) {
    std::cerr << "ERROR: An unknown exception occurred." << std::endl;
    status = 3;
  }
  ignore = status;
}
 
int main(int argc, char* argv[])
{
  if (argc < 6) {
    cerr << "too few arguments!" << "\n";
    throw;
  }
  int inputFileDescriptor = stoi(argv[1]);
  int outputFileDescriptor = stoi(argv[2]);
  FILE* instream = fdopen(inputFileDescriptor, "r");
  // FILE * outstream = fdopen(outputFileDescriptor, "w");
  ostream* outstream = createOutStreamFromFD(outputFileDescriptor);
  CDCTriggerTSFFirmwareWorker worker(argv[3], argv[4], stoi(argv[5]));
  worker.initialize();
  (*outstream) << "init" << endl;
  // read from pipe and put input to array
  while (!feof(instream) && !ferror(instream) && worker.setInput(instream)) {
    // while (!feof(instream) && !ferror(instream) &&
    //        fgets(buffer, sizeof (buffer), instream) != NULL) {
    // drive the simulation
    worker.clock();
 
    // cout << "sending tsf output:\n";
    // for (int i2d = 0; i2d < 4; ++i2d) {
    //   for (int i = worker.outputWidth * i2d; i < worker.outputWidth * (i2d + 1); ++i ) {
    //     cout << std_logic_literal[static_cast<int>(worker.getOutput()[i])];
    //   }
    //   cout << endl;
    // }
 
    // send output to the module
    // string constructor from buffer of fixed size.
    (*outstream) << string(worker.getOutput().data(), worker.outputWidth * 4) << endl;
 
    // fprintf(outstream, "%s\n" , con.data());
  }
  close(inputFileDescriptor);
  close(outputFileDescriptor);
  worker.terminate();
  return 0;
}