BenchmarkAlg.h

Go to the documentation of this file.

/*
    Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef EFTRACKING_FPGA_INTEGRATION_BENCHMARKALG_H
#define EFTRACKING_FPGA_INTEGRATION_BENCHMARKALG_H
 
// EFTracking include
#include "EFTrackingFPGAPipeline/IntegrationBase.h"
#include "EFTrackingFPGAUtility/xAODClusterMaker.h"
#include "EFTrackingFPGAUtility/TestVectorTool.h"
#include "EFTrackingFPGAUtility/FPGADataFormatTool.h"
 
// Athena include
#include "InDetRawData/PixelRDO_Container.h"
#include "InDetRawData/SCT_RDO_Container.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/IChronoSvc.h"
 
namespace EFTrackingFPGAIntegration
{
    class BenchmarkAlg : public IntegrationBase
    {
    public:
        using IntegrationBase::IntegrationBase;
        virtual StatusCode initialize() override final;
        virtual StatusCode execute(const EventContext &ctx) const override final;
        virtual StatusCode finalize() override final;
        StatusCode runPassThrough(std::vector<uint64_t> &pixelChainOutput, std::vector<uint64_t> &stripChainOutput, const EventContext &ctx) const;
        StatusCode runDataPrep(std::vector<uint64_t> &pixelChainOutput, std::vector<uint64_t> &stripChainOutput, const EventContext &ctx) const;
 
    private:
        ServiceHandle<IChronoSvc> m_chronoSvc{
            "ChronoStatSvc", name()}; 
 
        ToolHandle<xAODClusterMaker> m_xaodClusterMaker{
            this,
            "xAODClusterMaker",
            "xAODClusterMaker",
            "Tool for creating xAOD cluster containers"}; 
 
        ToolHandle<TestVectorTool> m_testVectorTool{
            this, "TestVectorTool", "TestVectorTool", "Tool for preparing test vectors"}; 
 
        ToolHandle<FPGADataFormatTool> m_FPGADataFormatTool{
            this, "FPGADataFormatTool", "FPGADataFormatTool", "Tool for formatting FPGA data"}; 
 
        SG::ReadHandleKey<xAOD::PixelClusterContainer> m_inputPixelClusterKey{
            this, "InputPixelClusterKey", "ITkPixelClusters", "Key to access input pixel clusters"}; 
 
        SG::ReadHandleKey<xAOD::StripClusterContainer> m_inputStripClusterKey{
            this, "InputStripClusterKey", "ITkStripClusters", "Key to access input strip clusters"}; 
 
        SG::ReadHandleKey<PixelRDO_Container> m_pixelRDOKey{this, "PixelRDO", "ITkPixelRDOs"};
 
        SG::ReadHandleKey<SCT_RDO_Container> m_stripRDOKey{this, "StripRDO", "ITkStripRDOs"};
 
        Gaudi::Property<std::string> m_xclbin{
            this, "xclbin", "", "xclbin path and name"}; 
 
        Gaudi::Property<std::string> m_edmKernelName{
            this, "EDMPrepKernelName", "", "Name of the FPGA kernel"}; 
 
        Gaudi::Property<std::string> m_pixelClusterKernelName{
            this, "PixelClusterKernelName", "", "Name of the pixel clustering kernel"}; 
 
        Gaudi::Property<std::string> m_stripClusterKernelName{
            this, "StripClusterKernelName", "", "Name of the strip clustering kernel"}; 
 
        Gaudi::Property<std::string> m_pixelL2GKernelName{
            this, "PixelL2GKernelName", "", "Name of the pixel L2G kernel"}; 
 
        Gaudi::Property<std::string> m_stripL2GKernelName{
            this, "StripL2GKernelName", "", "Name of the strip L2G kernel"}; 
 
        Gaudi::Property<bool> m_runPassThrough{
            this, "runPassThrough", true, "Run the pass-through kernel"}; 
 
        mutable std::atomic<ulonglong> m_numEvents{0};          
        mutable std::atomic<cl_ulong> m_pixelInputTime{0};      
        mutable std::atomic<cl_ulong> m_stripInputTime{0};      
        mutable std::atomic<cl_ulong> m_pixelClusteringTime{0}; 
        mutable std::atomic<cl_ulong> m_stripClusteringTime{0}; 
        mutable std::atomic<cl_ulong> m_pixelL2GTime{0};        
        mutable std::atomic<cl_ulong> m_stripL2GTime{0};        
        mutable std::atomic<cl_ulong> m_edmPrepTime{0};         
        mutable std::atomic<cl_ulong> m_pixelOutputTime{0};     
        mutable std::atomic<cl_ulong> m_stripOutputTime{0};     
        mutable std::atomic<cl_ulong> m_kernelTime{0};          
    };
}
 
#endif // EFTRACKING_FPGA_INTEGRATION_BENCHMARKALG_H