ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo Class Reference

#include <TestAlgo.h>

Public Member Functions
void	fill (Queue &queue, portabletest::TestDeviceCollection &collection, double xvalue=0.) const
void	fillMulti2 (Queue &queue, portabletest::TestDeviceMultiCollection2 &collection, double xvalue=0.) const
void	fillMulti3 (Queue &queue, portabletest::TestDeviceMultiCollection3 &collection, double xvalue=0.) const
void	fillObject (Queue &queue, portabletest::TestDeviceObject &object, double x, double y, double z, int32_t id) const
portabletest::TestDeviceCollection	update (Queue &queue, portabletest::TestDeviceCollection const &input, AlpakaESTestDataEDevice const &esData) const
portabletest::TestDeviceMultiCollection2	updateMulti2 (Queue &queue, portabletest::TestDeviceMultiCollection2 const &input, AlpakaESTestDataEDevice const &esData) const
portabletest::TestDeviceMultiCollection3	updateMulti3 (Queue &queue, portabletest::TestDeviceMultiCollection3 const &input, AlpakaESTestDataEDevice const &esData) const

Detailed Description

Definition at line 11 of file TestAlgo.h.

Member Function Documentation

fill()

void ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::fill	(	Queue &	queue,
		portabletest::TestDeviceCollection &	collection,
		double	xvalue = 0.
	)		const

Definition at line 83 of file TestAlgo.dev.cc.

References universalConfigTemplate::collection, cms::alpakatools::divide_up_by(), mps_monitormerge::items, and createBeamHaloJobs::queue.

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaGlobalProducerOffset::produce(), ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaProducer::produce(), ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaGlobalProducer::produce(), and ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaStreamProducer::produce().

                                                                                                     {
    // 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(collection->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, TestAlgoKernel{}, collection.view(), xvalue);
  }

fillMulti2()

void ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::fillMulti2	(	Queue &	queue,
		portabletest::TestDeviceMultiCollection2 &	collection,
		double	xvalue = 0.
	)		const

Definition at line 98 of file TestAlgo.dev.cc.

References universalConfigTemplate::collection, cms::alpakatools::divide_up_by(), mps_monitormerge::items, and createBeamHaloJobs::queue.

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaProducer::produce(), ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaGlobalProducer::produce(), and ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaStreamProducer::produce().

                                                                                                                 {
    // 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(collection->metadata().size(), items);
    uint32_t groups2 = divide_up_by(collection.view<1>().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);
    auto workDiv2 = make_workdiv<Acc1D>(groups2, items);

    alpaka::exec<Acc1D>(queue, workDiv, TestAlgoKernel{}, collection.view<portabletest::TestSoA>(), xvalue);
    alpaka::exec<Acc1D>(queue, workDiv2, TestAlgoMultiKernel2{}, collection.view<portabletest::TestSoA2>(), xvalue);
  }

fillMulti3()

void ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::fillMulti3	(	Queue &	queue,
		portabletest::TestDeviceMultiCollection3 &	collection,
		double	xvalue = 0.
	)		const

Definition at line 143 of file TestAlgo.dev.cc.

References universalConfigTemplate::collection, cms::alpakatools::divide_up_by(), mps_monitormerge::items, and createBeamHaloJobs::queue.

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaProducer::produce(), ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaGlobalProducer::produce(), and ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaStreamProducer::produce().

                                                                                                                 {
    // 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(collection.view<portabletest::TestSoA>().metadata().size(), items);
    uint32_t groups2 = divide_up_by(collection.view<portabletest::TestSoA2>().metadata().size(), items);
    uint32_t groups3 = divide_up_by(collection.view<portabletest::TestSoA3>().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);
    auto workDiv2 = make_workdiv<Acc1D>(groups2, items);
    auto workDiv3 = make_workdiv<Acc1D>(groups3, items);

    alpaka::exec<Acc1D>(queue, workDiv, TestAlgoKernel{}, collection.view<portabletest::TestSoA>(), xvalue);
    alpaka::exec<Acc1D>(queue, workDiv2, TestAlgoMultiKernel2{}, collection.view<portabletest::TestSoA2>(), xvalue);
    alpaka::exec<Acc1D>(queue, workDiv3, TestAlgoMultiKernel3{}, collection.view<portabletest::TestSoA3>(), xvalue);
  }

fillObject()

void ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::fillObject	(	Queue &	queue,
		portabletest::TestDeviceObject &	object,
		double	x,
		double	y,
		double	z,
		int32_t	id
	)		const

Definition at line 135 of file TestAlgo.dev.cc.

References l1ctLayer2EG_cff::id, createBeamHaloJobs::queue, and x.

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

                                                                                                          {
    // run on a single thread
    auto workDiv = make_workdiv<Acc1D>(1, 1);

    alpaka::exec<Acc1D>(queue, workDiv, TestAlgoStructKernel{}, object.data(), x, y, z, id);
  }

update()

portabletest::TestDeviceCollection ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::update	(	Queue &	queue,
		portabletest::TestDeviceCollection const &	input,
		AlpakaESTestDataEDevice const &	esData
	)		const

Definition at line 265 of file TestAlgo.dev.cc.

References universalConfigTemplate::collection, cms::alpakatools::divide_up_by(), input, mps_monitormerge::items, createBeamHaloJobs::queue, and cms::alpakatest::AlpakaESTestDataE< TDev >::view().

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), progressbar.ProgressBar::finish(), MatrixUtil.Steps::overwrite(), and ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaGlobalProducerE::produce().

                                                                                                   {
    portabletest::TestDeviceCollection collection{input->metadata().size(), queue};

    // 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(collection->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, TestAlgoKernelUpdate{}, input.view(), esData.view(), collection.view());

    return collection;
  }

updateMulti2()

portabletest::TestDeviceMultiCollection2 ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::updateMulti2	(	Queue &	queue,
		portabletest::TestDeviceMultiCollection2 const &	input,
		AlpakaESTestDataEDevice const &	esData
	)		const

Definition at line 286 of file TestAlgo.dev.cc.

References universalConfigTemplate::collection, cms::alpakatools::divide_up_by(), input, mps_monitormerge::items, createBeamHaloJobs::queue, and cms::alpakatest::AlpakaESTestDataE< TDev >::view().

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

                                                                                                               {
    portabletest::TestDeviceMultiCollection2 collection{input.sizes(), queue};

    // 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
    auto sizes = collection.sizes();
    uint32_t groups = divide_up_by(*std::max_element(sizes.begin(), sizes.end()), 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,
                        TestAlgoKernelUpdateMulti2{},
                        input.view<portabletest::TestSoA>(),
                        input.view<portabletest::TestSoA2>(),
                        esData.view(),
                        collection.view<portabletest::TestSoA>(),
                        collection.view<portabletest::TestSoA2>());

    return collection;
  }

updateMulti3()

portabletest::TestDeviceMultiCollection3 ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::updateMulti3	(	Queue &	queue,
		portabletest::TestDeviceMultiCollection3 const &	input,
		AlpakaESTestDataEDevice const &	esData
	)		const

Definition at line 315 of file TestAlgo.dev.cc.

References universalConfigTemplate::collection, cms::alpakatools::divide_up_by(), input, mps_monitormerge::items, createBeamHaloJobs::queue, and cms::alpakatest::AlpakaESTestDataE< TDev >::view().

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

                                                                                                               {
    portabletest::TestDeviceMultiCollection3 collection{input.sizes(), queue};

    // 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
    auto sizes = collection.sizes();
    uint32_t groups = divide_up_by(*std::max_element(sizes.begin(), sizes.end()), 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,
                        TestAlgoKernelUpdateMulti3{},
                        input.view<portabletest::TestSoA>(),
                        input.view<portabletest::TestSoA2>(),
                        input.view<portabletest::TestSoA3>(),
                        esData.view(),
                        collection.view<portabletest::TestSoA>(),
                        collection.view<portabletest::TestSoA2>(),
                        collection.view<portabletest::TestSoA3>());

    return collection;
  }