columnar::TestUtils Namespace Reference

Classes
class	Benchmark
	this is a simple benchmarking helper class wrapping timers from std::chrono More...
class	ColumnarTestToolHandle
	a handle to a columnar tool for running tests More...
struct	ColumnMapType
struct	UserConfiguration
	a struct holding user configuration for the PHYSLITE tests More...
struct	TestDefinition
	the general configuration for a single test More...
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	BranchPerfData
	the performance data for reading a single branch/column 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	RNTupleBackend
class	BranchReader
class	BranchReaderArray
class	LinkColumnVector
class	RNTFieldReader
class	IColumnData
struct	ColumnDataEventCount
struct	ColumnDataScalar
struct	ColumnDataVector
struct	ColumnDataOutVector
struct	ColumnDataVectorVector
struct	ColumnDataVectorVectorLink
struct	ColumnDataVectorVectorVector
struct	ColumnDataVectorLink
struct	ColumnDataVectorRLink
struct	ColumnDataVectorSplitLink
struct	ColumnDataVectorVectorVariantLink
struct	ColumnDataMetNames
struct	ColumnDataOutputMet
struct	ColumnDataSamplingPattern

Typedefs
using	Backend = std::variant<TTree*, RNTupleBackend*>

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	runXaodTest (const UserConfiguration &userConfiguration, std::span< const TestDefinition > testDefinitions, TFile *file)
void	runXaodArrayTest (const UserConfiguration &userConfiguration, const TestDefinition &testDefinition, TFile *file)

Typedef Documentation

Backend

using columnar::TestUtils::Backend = std::variant<TTree*, RNTupleBackend*>

Definition at line 84 of file ColumnarPhysliteTest.cxx.

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,
		TFile *	file )

Definition at line 317 of file PhysliteTestXaodArray.cxx.

    {
      using namespace asg::msgUserCode;
 
      xAOD::TEvent event;
      xAOD::TStore store;
      ANA_CHECK_THROW (event.readFrom (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 == eventRangeColumnName)
          {
            data.reader = std::make_shared<TestUtils::ColumnDataXAEventInfo> (data.info);
          } else if (data.info.offsetName == eventRangeColumnName)
          {
            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 (tick=" << Benchmark::getTickDuration() << "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;
        }
      }
    }

runXaodTest()

void columnar::TestUtils::runXaodTest	(	const UserConfiguration &	userConfiguration,
		std::span< const TestDefinition >	testDefinitions,
		TFile *	file )

Definition at line 267 of file PhysliteTestXaod.cxx.

    {
      using namespace asg::msgUserCode;
 
      auto eventReader = makeEventReader();
      ANA_CHECK_THROW(eventReader->readFrom(file));
 
      std::vector<ToolData> toolDataVec;
      for (const auto& testDefinition : testDefinitions)
      {
        if (testDefinition.xAODToolCaller != nullptr)
        {
          ToolData toolData;
          toolData.name = testDefinition.name;
          toolData.xAODToolCaller = testDefinition.xAODToolCaller;
          toolData.noRepeatCall = testDefinition.noRepeatCall;
          toolDataVec.push_back(std::move(toolData));
        }
      }
 
      IXAODToolCaller::EventStoreType* evtStore = nullptr;
      if (!testDefinitions.empty() && testDefinitions[0].tool)
        evtStore = &*testDefinitions[0].tool->evtStore();
 
      Benchmark benchmarkEmpty;
 
      const std::uint64_t numberOfEvents = eventReader->getEntries();
      if (numberOfEvents == 0){
        throw std::runtime_error ("ColumnarPhysLiteTest: numberOfEvents == 0");
      }
      std::uint64_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();
        ANA_CHECK_THROW(eventReader->getEntry(entry % numberOfEvents));
        if (eventReader->hasClearStore())
        {
          static const std::string prepPostfix = "Prep";
          for (auto& toolData : toolDataVec)
            ASSERT_SUCCESS (toolData.retrieve (0, *evtStore));
          for (auto& toolData : toolDataVec)
            ASSERT_SUCCESS (toolData.copyRecord (0, *evtStore, prepPostfix));
          for (auto& toolData : toolDataVec)
            ASSERT_SUCCESS (toolData.call (0));
          for (auto& toolData : toolDataVec)
            toolData.clear (0);
          eventReader->clearStore();
        }
        static const std::string callPostfix = "Call";
        for (auto& toolData : toolDataVec)
          ASSERT_SUCCESS (toolData.retrieve (1, *evtStore));
        for (auto& toolData : toolDataVec)
          ASSERT_SUCCESS (toolData.copyRecord (1, *evtStore, callPostfix));
        for (auto& toolData : toolDataVec)
        {
          ASSERT_SUCCESS (toolData.call (1));
          // a second call, immediately after, to have the tool in
          // instruction cache and simulate it being run on multi-event
          // batches. this is a bit too good, as it will run on exactly
          // the same event, instead of different events as would happen
          // in a real multi-event batch.
          if (userConfiguration.runToolTwice && !toolData.noRepeatCall)
          {
            ASSERT_SUCCESS (toolData.call (2));
          }
        }
        for (auto& toolData : toolDataVec)
          toolData.clear (1);
        if (eventReader->hasClearStore())
          eventReader->clearStore();
      }
      std::cout << "Total entries read: " << entry << std::endl;
      const float emptyTime = benchmarkEmpty.getEntryTime(0).value();
      std::cout << "Empty benchmark time: " << emptyTime << "ns (tick=" << Benchmark::getTickDuration() << "ns)" << std::endl;
      eventReader->printBenchmarkTable(emptyTime);
 
      // Fill vector of ToolPerfData pairs from benchmarks
      std::vector<std::pair<ToolPerfData, ToolPerfData>> toolPerfData;
      for (auto& toolData : toolDataVec)
      {
        ToolPerfData prepPerfData;
        prepPerfData.name = toolData.name;
        if (eventReader->hasClearStore()) {
          prepPerfData.timeRetrieve = toolData.benchmarkRetrieve[0].getEntryTime(emptyTime);
          prepPerfData.timeCopyRecord = toolData.benchmarkCopyRecord[0].getEntryTime(emptyTime);
          prepPerfData.timeCall = toolData.benchmarkCall[0].getEntryTime(emptyTime);
          prepPerfData.timeClear = toolData.benchmarkClear[0].getEntryTime(emptyTime);
          toolData.benchmarkRetrieve[0].setSilence();
          toolData.benchmarkCopyRecord[0].setSilence();
          toolData.benchmarkCall[0].setSilence();
          toolData.benchmarkClear[0].setSilence();
        }
 
        ToolPerfData callPerfData;
        callPerfData.name = toolData.name;
        callPerfData.timeRetrieve = toolData.benchmarkRetrieve[1].getEntryTime(emptyTime);
        callPerfData.timeCopyRecord = toolData.benchmarkCopyRecord[1].getEntryTime(emptyTime);
        callPerfData.timeCall = toolData.benchmarkCall[1].getEntryTime(emptyTime);
        callPerfData.timeClear = toolData.benchmarkClear[1].getEntryTime(emptyTime);
        if (userConfiguration.runToolTwice) {
          callPerfData.timeCall2 = toolData.benchmarkCall[2].getEntryTime(emptyTime);
          toolData.benchmarkCall[2].setSilence();
        }
        toolData.benchmarkRetrieve[1].setSilence();
        toolData.benchmarkCopyRecord[1].setSilence();
        toolData.benchmarkCall[1].setSilence();
        toolData.benchmarkClear[1].setSilence();
 
        toolPerfData.emplace_back(std::move(prepPerfData), std::move(callPerfData));
      }
 
      // Helper lambda for printing optional time values
      auto printOptionalTime = [](std::optional<float> time, int width, bool trailingBar = true) {
        if (time)
          std::cout << std::format("{:>{}.0f}", time.value(), width);
        else
          std::cout << std::format("{:>{}}", "", width);
        if (trailingBar)
          std::cout << " |";
      };
 
      // Calculate name width from all entries
      std::size_t nameWidth = std::string_view("tool name").size();
      for (const auto& [prep, call] : toolPerfData)
        nameWidth = std::max(nameWidth, prep.name.size());
 
      // Print tool performance table with grouped columns
      std::string groupHeader = std::format("{:{}} |{:^42}|{:^52}",
        "", nameWidth, "prep", "call");
      std::string colHeader = std::format("{:{}} | retr(ns) | copy(ns) | call(ns) | clr(ns) | retr(ns) | copy(ns) | call(ns) | 2nd(ns) | clr(ns)",
        "tool name", nameWidth);
 
      std::cout << "\ntool benchmarks:" << std::endl;
      std::cout << groupHeader << std::endl;
      std::cout << colHeader << std::endl;
      std::cout << std::string(colHeader.size(), '-') << std::endl;
 
      // Print data rows
      for (const auto& [prep, call] : toolPerfData)
      {
        std::cout << std::format("{:{}} |", prep.name, nameWidth);
        printOptionalTime(prep.timeRetrieve, 9);
        printOptionalTime(prep.timeCopyRecord, 9);
        printOptionalTime(prep.timeCall, 9);
        printOptionalTime(prep.timeClear, 8);
        printOptionalTime(call.timeRetrieve, 9);
        printOptionalTime(call.timeCopyRecord, 9);
        printOptionalTime(call.timeCall, 9);
        printOptionalTime(call.timeCall2, 8);
        printOptionalTime(call.timeClear, 8, false);
        std::cout << std::endl;
      }
 
      // Print total line only when there are multiple tools
      if (toolPerfData.size() > 1)
      {
        std::optional<float> totalPrepRetrieve, totalPrepCopyRecord, totalPrepCall, totalPrepClear;
        std::optional<float> totalCallRetrieve, totalCallCopyRecord, totalCallCall, totalCallClear, totalRepeat;
        for (const auto& [prep, call] : toolPerfData)
        {
          if (prep.timeRetrieve)
            totalPrepRetrieve = totalPrepRetrieve.value_or(0) + prep.timeRetrieve.value();
          if (prep.timeCopyRecord)
            totalPrepCopyRecord = totalPrepCopyRecord.value_or(0) + prep.timeCopyRecord.value();
          if (prep.timeCall)
            totalPrepCall = totalPrepCall.value_or(0) + prep.timeCall.value();
          if (prep.timeClear)
            totalPrepClear = totalPrepClear.value_or(0) + prep.timeClear.value();
          if (call.timeRetrieve)
            totalCallRetrieve = totalCallRetrieve.value_or(0) + call.timeRetrieve.value();
          if (call.timeCopyRecord)
            totalCallCopyRecord = totalCallCopyRecord.value_or(0) + call.timeCopyRecord.value();
          if (call.timeCall)
            totalCallCall = totalCallCall.value_or(0) + call.timeCall.value();
          if (call.timeClear)
            totalCallClear = totalCallClear.value_or(0) + call.timeClear.value();
          if (call.timeCall2)
            totalRepeat = totalRepeat.value_or(0) + call.timeCall2.value();
        }
 
        std::cout << std::string(colHeader.size(), '-') << std::endl;
        std::cout << std::format("{:{}} |", "total", nameWidth);
        printOptionalTime(totalPrepRetrieve, 9);
        printOptionalTime(totalPrepCopyRecord, 9);
        printOptionalTime(totalPrepCall, 9);
        printOptionalTime(totalPrepClear, 8);
        printOptionalTime(totalCallRetrieve, 9);
        printOptionalTime(totalCallCopyRecord, 9);
        printOptionalTime(totalCallCall, 9);
        printOptionalTime(totalRepeat, 8);
        printOptionalTime(totalCallClear, 8, false);
        std::cout << std::endl;
      }
    }