ALPAKA_ACCELERATOR_NAMESPACE::HGCalLayerClustersSoAAlgoWrapper Class Reference

#include <HGCalLayerClustersSoAAlgoWrapper.h>

Public Member Functions
void	run (Queue &queue, const unsigned int numer_of_clusters, float thresholdW0, float positionDeltaRho2, const HGCalSoARecHitsDeviceCollection::ConstView input_rechits_soa, const HGCalSoARecHitsExtraDeviceCollection::ConstView input_clusters_soa, HGCalSoAClustersDeviceCollection::View outputs, HGCalSoAClustersExtraDeviceCollection::View outputs_service) const

Detailed Description

Definition at line 17 of file HGCalLayerClustersSoAAlgoWrapper.h.

Member Function Documentation

run()

void ALPAKA_ACCELERATOR_NAMESPACE::HGCalLayerClustersSoAAlgoWrapper::run	(	Queue &	queue,
		const unsigned int	numer_of_clusters,
		float	thresholdW0,
		float	positionDeltaRho2,
		const HGCalSoARecHitsDeviceCollection::ConstView	input_rechits_soa,
		const HGCalSoARecHitsExtraDeviceCollection::ConstView	input_clusters_soa,
		HGCalSoAClustersDeviceCollection::View	outputs,
		HGCalSoAClustersExtraDeviceCollection::View	outputs_service
	)		const

Definition at line 150 of file HGCalLayerClustersSoAAlgoWrapper.dev.cc.

References hgcalTBTopologyTester_cfi::cells, cms::alpakatools::divide_up_by(), hcalRecHitTable_cff::energy, mps_monitormerge::items, hgcal::constants::kInvalidIndexByte, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, hltHgcalLayerClustersEE_cfi::positionDeltaRho2, createBeamHaloJobs::queue, fileCollector::seed, hltHgcalLayerClustersEE_cfi::thresholdW0, and x.

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::HGCalSoALayerClustersProducer::produce().

                                                                                                              {
    auto x = cms::alpakatools::make_device_view<float>(alpaka::getDev(queue), outputs.x(), size);
    alpaka::memset(queue, x, 0x0);
    auto y = cms::alpakatools::make_device_view<float>(alpaka::getDev(queue), outputs.y(), size);
    alpaka::memset(queue, y, 0x0);
    auto z = cms::alpakatools::make_device_view<float>(alpaka::getDev(queue), outputs.z(), size);
    alpaka::memset(queue, z, 0x0);
    auto seed = cms::alpakatools::make_device_view<int>(alpaka::getDev(queue), outputs.seed(), size);
    alpaka::memset(queue, seed, 0x0);
    auto energy = cms::alpakatools::make_device_view<float>(alpaka::getDev(queue), outputs.energy(), size);
    alpaka::memset(queue, energy, 0x0);
    auto cells = cms::alpakatools::make_device_view<int>(alpaka::getDev(queue), outputs.cells(), size);
    alpaka::memset(queue, cells, 0x0);
    auto total_weight =
        cms::alpakatools::make_device_view<float>(alpaka::getDev(queue), outputs_service.total_weight(), size);
    alpaka::memset(queue, total_weight, 0x0);
    auto total_weight_log =
        cms::alpakatools::make_device_view<float>(alpaka::getDev(queue), outputs_service.total_weight_log(), size);
    alpaka::memset(queue, total_weight_log, 0x0);
    auto maxEnergyValue =
        cms::alpakatools::make_device_view<float>(alpaka::getDev(queue), outputs_service.maxEnergyValue(), size);
    alpaka::memset(queue, maxEnergyValue, 0x0);
    auto maxEnergyIndex =
        cms::alpakatools::make_device_view<int>(alpaka::getDev(queue), outputs_service.maxEnergyIndex(), size);
    alpaka::memset(queue, maxEnergyIndex, kInvalidIndexByte);

    // use 64 items per group (this value is arbitrary, but it's a reasonable starting point)
    uint32_t items = 64;

    // use as many groups as needed to cover the whole problem
    uint32_t groups = divide_up_by(input_rechits_soa.metadata().size(), items);

    // map items to
    //   - threads with a single element per thread on a GPU backend
    //   - elements within a single thread on a CPU backend
    auto workDiv = make_workdiv<Acc1D>(groups, items);

    alpaka::exec<Acc1D>(
        queue, workDiv, HGCalLayerClustersSoAAlgoKernelEnergy{}, size, input_rechits_soa, input_clusters_soa, outputs);
    alpaka::exec<Acc1D>(queue,
                        workDiv,
                        HGCalLayerClustersSoAAlgoKernelPositionByHits{},
                        size,
                        thresholdW0,
                        positionDeltaRho2,
                        input_rechits_soa,
                        input_clusters_soa,
                        outputs,
                        outputs_service);
    alpaka::exec<Acc1D>(queue,
                        workDiv,
                        HGCalLayerClustersSoAAlgoKernelPositionByHits2{},
                        size,
                        thresholdW0,
                        positionDeltaRho2,
                        input_rechits_soa,
                        input_clusters_soa,
                        outputs,
                        outputs_service);
    uint32_t group_clusters = divide_up_by(size, items);
    auto workDivClusters = make_workdiv<Acc1D>(group_clusters, items);
    alpaka::exec<Acc1D>(queue,
                        workDivClusters,
                        HGCalLayerClustersSoAAlgoKernelPositionByHits3{},
                        size,
                        thresholdW0,
                        positionDeltaRho2,
                        input_rechits_soa,
                        input_clusters_soa,
                        outputs,
                        outputs_service);
  }