columnar::TestUtils Namespace Reference

Classes
class	Benchmark
	this is a simple benchmarking helper class wrapping timers from std::chrono More...
struct	BranchPerfData
	the performance data for reading a single branch/column More...
class	BranchReader
class	BranchReaderArray
class	ColumnarTestToolHandle
	a handle to a columnar tool for running tests More...
struct	ColumnDataEventCount
struct	ColumnDataMetNames
struct	ColumnDataOutputMet
struct	ColumnDataOutVector
struct	ColumnDataSamplingPattern
struct	ColumnDataScalar
struct	ColumnDataVector
struct	ColumnDataVectorLink
struct	ColumnDataVectorSplitLink
struct	ColumnDataVectorVector
struct	ColumnDataVectorVectorLink
struct	ColumnDataVectorVectorVariantLink
struct	ColumnDataVectorVectorVector
struct	ColumnMapType
class	IColumnData
class	IXAODToolCaller
	a wrapper around a CP tool in xAOD mdoe to call it in the PHYSLITE test More...
class	ManualColumnData
	a class that holds manually specified column data More...
struct	TestDefinition
	the general configuration for a single test More...
struct	ToolPerfData
	the performance data for running a single tool More...
class	ToolWrapperData
	a class that holds a reference to a ToolColumnVectorMap and a ColumnVectorData More...
struct	UserConfiguration
	a struct holding user configuration for the PHYSLITE tests More...

Functions
void	checkExpectation (const std::string &columnName, const std::type_info &outputType, std::size_t outputSize, const void *outputData, const std::type_info &expectationType, std::size_t expectationSize, const void *expectationData)
void	printExpectedOutput (const std::string &columnName, const std::type_info &outputType, std::size_t outputSize, const void *outputData)
void	runXaodArrayTest (const UserConfiguration &userConfiguration, const TestDefinition &testDefinition)

Variables
static const std::unordered_map< std::string, SG::sgkey_t >	knownKeys

Function Documentation

checkExpectation()

void columnar::TestUtils::checkExpectation	(	const std::string &	columnName,
		const std::type_info &	outputType,
		std::size_t	outputSize,
		const void *	outputData,
		const std::type_info &	expectationType,
		std::size_t	expectationSize,
		const void *	expectationData )

Definition at line 46 of file ExpectationCompare.cxx.

    {
      SCOPED_TRACE (columnName);
      ASSERT_EQ (outputType, expectationType);
      if (outputType == typeid(float))
        checkExpectationTyped (columnName, std::span<const float> (static_cast<const float*> (outputData), outputSize), std::span<const float> (static_cast<const float*> (expectationData), expectationSize));
      else if (outputType == typeid(char))
        checkExpectationTyped (columnName, std::span<const char> (static_cast<const char*> (outputData), outputSize), std::span<const char> (static_cast<const char*> (expectationData), expectationSize));
      else if (outputType == typeid(int))
        checkExpectationTyped (columnName, std::span<const int> (static_cast<const int*> (outputData), outputSize), std::span<const int> (static_cast<const int*> (expectationData), expectationSize));
      else if (outputType == typeid(std::uint8_t))
        checkExpectationTyped (columnName, std::span<const std::uint8_t> (static_cast<const std::uint8_t*> (outputData), outputSize), std::span<const std::uint8_t> (static_cast<const std::uint8_t*> (expectationData), expectationSize));
      else if (outputType == typeid(std::uint16_t))
        checkExpectationTyped (columnName, std::span<const std::uint16_t> (static_cast<const std::uint16_t*> (outputData), outputSize), std::span<const std::uint16_t> (static_cast<const std::uint16_t*> (expectationData), expectationSize));
      else if (outputType == typeid(std::uint32_t))
        checkExpectationTyped (columnName, std::span<const std::uint32_t> (static_cast<const std::uint32_t*> (outputData), outputSize), std::span<const std::uint32_t> (static_cast<const std::uint32_t*> (expectationData), expectationSize));
      else if (outputType == typeid(std::uint64_t))
        checkExpectationTyped (columnName, std::span<const std::uint64_t> (static_cast<const std::uint64_t*> (outputData), outputSize), std::span<const std::uint64_t> (static_cast<const std::uint64_t*> (expectationData), expectationSize));
      else if (outputType == typeid(std::size_t))
        checkExpectationTyped (columnName, std::span<const std::size_t> (static_cast<const std::size_t*> (outputData), outputSize), std::span<const std::size_t> (static_cast<const std::size_t*> (expectationData), expectationSize));
      else
        throw std::logic_error ("received unsupported type " + boost::core::demangle(outputType.name()) + " for column compare, cast value or extend test handler to support it");
    }

printExpectedOutput()

void columnar::TestUtils::printExpectedOutput	(	const std::string &	columnName,
		const std::type_info &	outputType,
		std::size_t	outputSize,
		const void *	outputData )

Definition at line 93 of file ExpectationCompare.cxx.

    {
      if (outputType == typeid(float))
        printExpectedOutputTyped (columnName, std::span<const float> (static_cast<const float*> (outputData), outputSize));
      else if (outputType == typeid(char))
        printExpectedOutputTyped (columnName, std::span<const char> (static_cast<const char*> (outputData), outputSize));
      else if (outputType == typeid(int))
        printExpectedOutputTyped (columnName, std::span<const int> (static_cast<const int*> (outputData), outputSize));
      else if (outputType == typeid(std::uint8_t))
        printExpectedOutputTyped (columnName, std::span<const std::uint8_t> (static_cast<const std::uint8_t*> (outputData), outputSize));
      else if (outputType == typeid(std::uint16_t))
        printExpectedOutputTyped (columnName, std::span<const std::uint16_t> (static_cast<const std::uint16_t*> (outputData), outputSize));
      else if (outputType == typeid(std::uint32_t))
        printExpectedOutputTyped (columnName, std::span<const std::uint32_t> (static_cast<const std::uint32_t*> (outputData), outputSize));
      else if (outputType == typeid(std::uint64_t))
        printExpectedOutputTyped (columnName, std::span<const std::uint64_t> (static_cast<const std::uint64_t*> (outputData), outputSize));
      else if (outputType == typeid(std::size_t))
        printExpectedOutputTyped (columnName, std::span<const std::size_t> (static_cast<const std::size_t*> (outputData), outputSize));
      else
        throw std::logic_error ("received unsupported type " + boost::core::demangle(outputType.name()) + " for column printout, cast value or extend test handler to support it");
    }

runXaodArrayTest()

void columnar::TestUtils::runXaodArrayTest	(	const UserConfiguration &	userConfiguration,
		const TestDefinition &	testDefinition )

Definition at line 316 of file PhysliteTestXaodArray.cxx.

    {
      using namespace asg::msgUserCode;
 
      xAOD::TEvent event;
      xAOD::TStore store;
      ANA_CHECK_THROW (event.readFrom (testDefinition.file));
 
      auto *myTool = dynamic_cast<ColumnarTool<ColumnarModeXAODArray>*>(testDefinition.tool);
      if (!myTool)
        throw std::runtime_error ("tool is not a ColumnarTool<ColumnarModeXAODArray>");
      if (!testDefinition.containerRenames.empty())
        renameContainers (*myTool, testDefinition.containerRenames);
      ColumnVectorHeader columnHeader;
      ToolColumnVectorMap toolWrapper (columnHeader, *myTool);
 
      std::unordered_map<std::string,TestUtils::ColumnDataXA> requestedColumns;
      for (auto& column : myTool->getColumnInfo())
        requestedColumns[column.name].info = std::move (column);
      for (auto& [name, data] : requestedColumns)
      {
        if (data.info.isOffset)
        {
          if (*data.info.type != typeid(ColumnarOffsetType))
            throw std::runtime_error ("unexpected type for offset column: " + name + " " + data.info.type->name());
          if (name == numberOfEventsName)
          {
            data.reader = std::make_shared<TestUtils::ColumnDataXAEventInfo> (data.info);
          } else if (data.info.offsetName == numberOfEventsName)
          {
            if (name == "AnalysisMuons")
              data.reader = std::make_shared<TestUtils::ColumnDataXARetrieve<xAOD::MuonContainer>> (data.info, userConfiguration);
            else if (name == "AnalysisElectrons")
              data.reader = std::make_shared<TestUtils::ColumnDataXARetrieve<xAOD::ElectronContainer>> (data.info, userConfiguration);
            else if (name == "AnalysisPhotons")
              data.reader = std::make_shared<TestUtils::ColumnDataXARetrieve<xAOD::PhotonContainer>> (data.info, userConfiguration);
            else if (name == "egammaClusters")
              data.reader = std::make_shared<TestUtils::ColumnDataXARetrieve<xAOD::CaloClusterContainer>> (data.info, userConfiguration);
            else if (name == "GSFTrackParticles")
              data.reader = std::make_shared<TestUtils::ColumnDataXARetrieve<xAOD::TrackParticleContainer>> (data.info, userConfiguration);
            else if (name == "GSFConversionVertices")
              data.reader = std::make_shared<TestUtils::ColumnDataXARetrieve<xAOD::VertexContainer>> (data.info, userConfiguration);
          }
        } else
        {
          if (*data.info.type == typeid(float))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<float>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(double))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<double>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(char))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<char>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::uint8_t))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::uint8_t>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::uint16_t))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::uint16_t>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::uint32_t))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::uint32_t>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::uint64_t))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::uint64_t>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::vector<float>))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::vector<float>>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::vector<ElementLink<xAOD::CaloClusterContainer>>))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::vector<ElementLink<xAOD::CaloClusterContainer>>>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::vector<ElementLink<xAOD::TrackParticleContainer>>))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::vector<ElementLink<xAOD::TrackParticleContainer>>>> (data.info, userConfiguration);
          else if (*data.info.type == typeid(std::vector<ElementLink<xAOD::VertexContainer>>))
            data.reader = std::make_shared<TestUtils::ColumnDataXAAccessor<std::vector<ElementLink<xAOD::VertexContainer>>>> (data.info, userConfiguration);
        }
      }
 
      bool allColumnsHandled = true;
      for (auto& [name, data] : requestedColumns)
      {
        if (!data.reader)
        {
          allColumnsHandled = false;
          std::cout << "WARNING: no handling for requested column: name=" << name << " offset=" << data.info.offsetName << " type=" << boost::core::demangle(data.info.type->name()) << std::endl;
        }
      }
      if (!allColumnsHandled)
      {
        ADD_FAILURE() << "not all requested columns could be handled";
        return;
      }
 
      for (auto& [name, data]: requestedColumns)
      {
        data.reader->connect (data, requestedColumns);
      }
 
      Benchmark benchmarkEmptyClear (testDefinition.name + " empty clear");
      Benchmark benchmarkCallClear (testDefinition.name + " call clear");
      Benchmark benchmarkGetEntry (testDefinition.name + " getEntry");
      Benchmark benchmarkCheck (testDefinition.name + " check");
      Benchmark benchmarkCall2 (testDefinition.name + " call2");
      Benchmark benchmarkCall (testDefinition.name + " call");
      Benchmark benchmarkEmpty ("empty");
 
      const auto numberOfEvents = event.getEntries();
      if (numberOfEvents == 0){
        throw std::runtime_error ("ColumnarPhysLiteTest: numberOfEvents == 0");
      }
      Long64_t entry = 0;
 
      // Instead of running for a fixed number of events, we run for a
      // fixed amount of time.  That is because individual tools can
      // vary wildly in how long they take to run, and we mostly want to
      // make sure that we ran the tool enough to get a precise
      // performance estimate.
      const auto startTime = std::chrono::high_resolution_clock::now();
      for (; (std::chrono::high_resolution_clock::now() - startTime) < userConfiguration.targetTime; ++entry)
      {
        benchmarkEmpty.startTimer ();
        benchmarkEmpty.stopTimer ();
 
        benchmarkGetEntry.startTimer ();
        event.getEntry (entry % numberOfEvents);
        benchmarkGetEntry.stopTimer ();
 
        ColumnVectorData columnData (&columnHeader);
        for (auto& [name, data] : requestedColumns)
          ASSERT_SUCCESS (data.reader->retrieveContainer (event, store, columnData));
        for (auto& [name, data] : requestedColumns)
          data.reader->retrieveAuxData (columnData);
 
        benchmarkCheck.startTimer ();
        columnData.checkData ();
        benchmarkCheck.stopTimer ();
        benchmarkCall.startTimer ();
        columnData.callNoCheck (*myTool);
        benchmarkCall.stopTimer ();
        if (userConfiguration.runToolTwice)
        {
          benchmarkCall2.startTimer ();
          columnData.callNoCheck (*myTool);
          benchmarkCall2.stopTimer ();
        }
 
        benchmarkCallClear.startTimer ();
        store.clear ();
        benchmarkCallClear.stopTimer ();
        benchmarkEmptyClear.startTimer ();
        store.clear ();
        benchmarkEmptyClear.stopTimer ();
      }
      std::cout << "Total entries read: " << entry << std::endl;
      const float emptyTime = benchmarkEmpty.getEntryTime(0).value();
      std::cout << "Empty benchmark time: " << emptyTime << "ns" << std::endl;
      benchmarkEmpty.setSilence();
      std::cout << "Average getEntry time: " << benchmarkGetEntry.getEntryTime(emptyTime).value() << "ns" << std::endl;
      benchmarkGetEntry.setSilence();
      std::cout << "Average clear time: " << benchmarkCallClear.getEntryTime(emptyTime).value() << "ns" << " (empty=" << benchmarkEmptyClear.getEntryTime(emptyTime).value() << "ns)" << std::endl;
      benchmarkCallClear.setSilence();
      benchmarkEmptyClear.setSilence();
 
      // Column performance table
      {
        std::vector<BranchPerfData> columnPerfData;
        BranchPerfData summary;
        summary.name = "total";
        summary.timeRead = 0;
        summary.timeReadAgain = 0;
        summary.timeShallowCopy = 0;
        summary.timeShallowRegister = 0;
        for (auto& [name, data] : requestedColumns)
        {
          auto perfData = data.reader->getPerfData(emptyTime);
          if (perfData.timeRead.has_value() || perfData.timeReadAgain.has_value())
          {
            columnPerfData.push_back(perfData);
            summary.timeRead.value() += perfData.timeRead.value_or(0);
            summary.timeReadAgain.value() += perfData.timeReadAgain.value_or(0);
            summary.timeShallowCopy.value() += perfData.timeShallowCopy.value_or(0);
            summary.timeShallowRegister.value() += perfData.timeShallowRegister.value_or(0);
          }
        }
        std::sort(columnPerfData.begin(), columnPerfData.end(), [](const auto& a, const auto& b) { return a.name < b.name; });
        columnPerfData.push_back(summary);
 
        const std::size_t nameWidth = std::max_element(columnPerfData.begin(), columnPerfData.end(), [](const auto& a, const auto& b) { return a.name.size() < b.name.size(); })->name.size();
        std::string header = std::format("{:{}} | 1st(ns) | 2nd(ns) | shallow copy(ns)", "column name", nameWidth);
        std::cout << "\n" << header << std::endl;
        std::cout << std::string(header.size(), '-') << std::endl;
        for (auto& data : columnPerfData)
        {
          if (data.name == "total")
            std::cout << std::string(header.size(), '-') << std::endl;
          std::cout << std::format("{:{}} |", data.name, nameWidth);
          if (data.timeRead)
            std::cout << std::format("{:>8.0f} |", data.timeRead.value());
          else
            std::cout << "         |";
          if (data.timeReadAgain)
            std::cout << std::format("{:>8.1f} |", data.timeReadAgain.value());
          else
            std::cout << "         |";
          if (data.timeShallowCopy || data.timeShallowRegister)
            std::cout << std::format("{:>10.0f} +{:>5.0f}", data.timeShallowCopy.value_or(-1), data.timeShallowRegister  .value_or(-1));
          std::cout << std::endl;
        }
      }
 
      // Tool performance table
      {
        std::vector<ToolPerfData> toolPerfData;
        toolPerfData.emplace_back();
        toolPerfData.back().name = testDefinition.name;
        toolPerfData.back().timeCall = benchmarkCall.getEntryTime(emptyTime);
        if (userConfiguration.runToolTwice)
          toolPerfData.back().timeCall2 = benchmarkCall2.getEntryTime(emptyTime);
        toolPerfData.back().timeCheck = benchmarkCheck.getEntryTime(emptyTime);
        benchmarkCall.setSilence();
        benchmarkCall2.setSilence();
        benchmarkCheck.setSilence();
 
        const std::size_t nameWidth = std::max_element(toolPerfData.begin(), toolPerfData.end(), [](const auto& a, const auto& b) { return a.name.size() < b.name.size(); })->name.size();
        std::string header = std::format("{:{}} | call(ns) | call2(ns) | check(ns)", "tool name", nameWidth);
        std::cout << "\n" << header << std::endl;
        std::cout << std::string(header.size(), '-') << std::endl;
        for (auto& data : toolPerfData)
        {
          std::cout << std::format("{:{}} |", data.name, nameWidth);
          if (data.timeCall)
            std::cout << std::format("{:>9.0f} |", data.timeCall.value());
          else
            std::cout << "          |";
          if (data.timeCall2)
            std::cout << std::format("{:>10.0f} |", data.timeCall2.value());
          else
            std::cout << "           |";
          if (data.timeCheck)
            std::cout << std::format("{:>10.1f}", data.timeCheck.value());
          std::cout << std::endl;
        }
      }
    }

Variable Documentation

knownKeys

const std::unordered_map<std::string,SG::sgkey_t> columnar::TestUtils::knownKeys

static

Initial value:

=
    {
      {"AnalysisMuons", 0x3a6b126f},
      {"AnalysisElectrons", 0x3902fec0},
      {"AnalysisPhotons", 0x35d1472f},
      {"AnalysisJets", 0x1afd1919},
      {"egammaClusters", 0x15788d1f},
      {"GSFConversionVertices", 0x1f3e85c9},
      {"InDetTrackParticles", 0x1d3890db},
      {"CombinedMuonTrackParticles", 0x340d9196},
      {"ExtrapolatedMuonTrackParticles", 0x14e35e9f},
      {"GSFTrackParticles", 0x2e42db0b},
      {"InDetForwardTrackParticles", 0x143c6846},
      {"MuonSpectrometerTrackParticles", 0x3993c8f3},
    }

Definition at line 85 of file ColumnarPhysliteTest.cxx.

    {
      {"AnalysisMuons", 0x3a6b126f},
      {"AnalysisElectrons", 0x3902fec0},
      {"AnalysisPhotons", 0x35d1472f},
      {"AnalysisJets", 0x1afd1919},
      {"egammaClusters", 0x15788d1f},
      {"GSFConversionVertices", 0x1f3e85c9},
      {"InDetTrackParticles", 0x1d3890db},
      {"CombinedMuonTrackParticles", 0x340d9196},
      {"ExtrapolatedMuonTrackParticles", 0x14e35e9f},
      {"GSFTrackParticles", 0x2e42db0b},
      {"InDetForwardTrackParticles", 0x143c6846},
      {"MuonSpectrometerTrackParticles", 0x3993c8f3},
    };