Add a test for writing and reading a PortableTestObject

Author: fwyzard

HeterogeneousCore/AlpakaTest/plugins/TestAlpakaObjectAnalyzer.cc

@@ -0,0 +1,78 @@
+#include <cassert>
+
+#include "DataFormats/PortableTestObjects/interface/TestHostObject.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/Framework/interface/EventSetup.h"
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/global/EDAnalyzer.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+#include "FWCore/Utilities/interface/EDGetToken.h"
+#include "FWCore/Utilities/interface/InputTag.h"
+
+class TestAlpakaObjectAnalyzer : public edm::global::EDAnalyzer<> {
+public:
+  TestAlpakaObjectAnalyzer(edm::ParameterSet const& config)
+      : source_{config.getParameter<edm::InputTag>("source")}, token_{consumes(source_)} {
+    if (std::string const& eb = config.getParameter<std::string>("expectBackend"); not eb.empty()) {
+      expectBackend_ = cms::alpakatools::toBackend(eb);
+      backendToken_ = consumes(edm::InputTag(source_.label(), "backend", source_.process()));
+    }
+  }
+
+  void analyze(edm::StreamID sid, edm::Event const& event, edm::EventSetup const&) const override {
+    portabletest::TestHostObject const& product = event.get(token_);
+
+    auto const& value = product.value();
+    {
+      edm::LogInfo msg("TestAlpakaObjectAnalyzer");
+      msg << source_.encode() << ".data() at " << product.data() << '\n';
+      msg << source_.encode() << ".buffer().data() at " << product.buffer().data() << '\n';
+      msg << source_.encode() << ".value() = {\n";
+      msg << "  .x:  " << value.x << '\n';
+      msg << "  .y:  " << value.y << '\n';
+      msg << "  .z:  " << value.z << '\n';
+      msg << "  .id: " << value.id << '\n';
+      msg << "}\n";
+    }
+
+    // check that the product data is held in the product buffer
+    assert(product.buffer().data() == product.data());
+
+    // check that the product content is as expected
+    assert(value.x == 5.);
+    assert(value.y == 12.);
+    assert(value.z == 13.);
+    assert(value.id == 42);
+
+    // check that the backend is as expected
+    if (expectBackend_) {
+      auto backend = static_cast<cms::alpakatools::Backend>(event.get(backendToken_));
+      if (expectBackend_ != backend) {
+        throw cms::Exception("Assert") << "Expected input backend " << cms::alpakatools::toString(*expectBackend_)
+                                       << ", got " << cms::alpakatools::toString(backend);
+      }
+    }
+  }
+
+  static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
+    edm::ParameterSetDescription desc;
+    desc.add<edm::InputTag>("source");
+    desc.add<std::string>("expectBackend", "")
+        ->setComment(
+            "Expected backend of the input collection. Empty value means to not perform the check. Default: empty "
+            "string");
+    descriptions.addWithDefaultLabel(desc);
+  }
+
+private:
+  const edm::InputTag source_;
+  const edm::EDGetTokenT<portabletest::TestHostObject> token_;
+  edm::EDGetTokenT<unsigned short> backendToken_;
+  std::optional<cms::alpakatools::Backend> expectBackend_;
+};
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+DEFINE_FWK_MODULE(TestAlpakaObjectAnalyzer);

HeterogeneousCore/AlpakaTest/plugins/alpaka/TestAlgo.dev.cc

@@ -55,4 +55,31 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
     alpaka::exec<Acc1D>(queue, workDiv, TestAlgoKernel{}, collection.view(), collection->metadata().size(), xvalue);
   }
 
+  class TestAlgoStructKernel {
+  public:
+    template <typename TAcc, typename = std::enable_if_t<alpaka::isAccelerator<TAcc>>>
+    ALPAKA_FN_ACC void operator()(TAcc const& acc,
+                                  portabletest::TestDeviceObject::Product* data,
+                                  double x,
+                                  double y,
+                                  double z,
+                                  int32_t id) const {
+      // run on a single thread
+      if (once_per_grid(acc)) {
+        data->x = x;
+        data->y = y;
+        data->z = z;
+        data->id = id;
+      }
+    }
+  };
+
+  void TestAlgo::fillObject(
+      Queue& queue, portabletest::TestDeviceObject& object, double x, double y, double z, int32_t id) const {
+    // run on a single thread
+    auto workDiv = make_workdiv<Acc1D>(1, 1);
+
+    alpaka::exec<Acc1D>(queue, workDiv, TestAlgoStructKernel{}, object.data(), x, y, z, id);
+  }
+
 }  // namespace ALPAKA_ACCELERATOR_NAMESPACE

HeterogeneousCore/AlpakaTest/plugins/alpaka/TestAlgo.h

@@ -2,13 +2,16 @@
 #define HeterogeneousCore_AlpakaTest_plugins_alpaka_TestAlgo_h
 
 #include "DataFormats/PortableTestObjects/interface/alpaka/TestDeviceCollection.h"
+#include "DataFormats/PortableTestObjects/interface/alpaka/TestDeviceObject.h"
 #include "HeterogeneousCore/AlpakaInterface/interface/config.h"
 
 namespace ALPAKA_ACCELERATOR_NAMESPACE {
 
   class TestAlgo {
   public:
     void fill(Queue& queue, portabletest::TestDeviceCollection& collection, double xvalue = 0.) const;
+    void fillObject(
+        Queue& queue, portabletest::TestDeviceObject& object, double x, double y, double z, int32_t id) const;
   };
 
 }  // namespace ALPAKA_ACCELERATOR_NAMESPACE

HeterogeneousCore/AlpakaTest/plugins/alpaka/TestAlpakaProducer.cc

@@ -1,4 +1,5 @@
 #include "DataFormats/PortableTestObjects/interface/alpaka/TestDeviceCollection.h"
+#include "DataFormats/PortableTestObjects/interface/alpaka/TestDeviceObject.h"
 #include "FWCore/Framework/interface/Frameworkfwd.h"
 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
@@ -18,15 +19,19 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
   class TestAlpakaProducer : public global::EDProducer<> {
   public:
     TestAlpakaProducer(edm::ParameterSet const& config)
-        : deviceToken_{produces()}, size_{config.getParameter<int32_t>("size")} {}
+        : objectToken_{produces()}, collectionToken_{produces()}, size_{config.getParameter<int32_t>("size")} {}
 
     void produce(edm::StreamID sid, device::Event& event, device::EventSetup const&) const override {
       // run the algorithm, potentially asynchronously
-      portabletest::TestDeviceCollection deviceProduct{size_, event.queue()};
-      algo_.fill(event.queue(), deviceProduct);
+      portabletest::TestDeviceCollection deviceCollection{size_, event.queue()};
+      algo_.fill(event.queue(), deviceCollection);
 
-      // put the asynchronous product into the event without waiting
-      event.emplace(deviceToken_, std::move(deviceProduct));
+      portabletest::TestDeviceObject deviceObject{event.queue()};
+      algo_.fillObject(event.queue(), deviceObject, 5., 12., 13., 42);
+
+      // put the asynchronous products into the event without waiting
+      event.emplace(objectToken_, std::move(deviceObject));
+      event.emplace(collectionToken_, std::move(deviceCollection));
     }
 
     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
@@ -36,7 +41,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
     }
 
   private:
-    const device::EDPutToken<portabletest::TestDeviceCollection> deviceToken_;
+    const device::EDPutToken<portabletest::TestDeviceObject> objectToken_;
+    const device::EDPutToken<portabletest::TestDeviceCollection> collectionToken_;
     const int32_t size_;
 
     // implementation of the algorithm

HeterogeneousCore/AlpakaTest/test/reader.py

@@ -7,22 +7,32 @@
     fileNames = cms.untracked.vstring('file:test.root')
 )
 
-# enable logging for the TestAlpakaAnalyzer
+# enable logging for the analysers
 process.MessageLogger.TestAlpakaAnalyzer = cms.untracked.PSet()
+process.MessageLogger.TestAlpakaObjectAnalyzer = cms.untracked.PSet()
 
-# analyse the first product
+# analyse the first set of products
 process.testAnalyzer = cms.EDAnalyzer('TestAlpakaAnalyzer',
     source = cms.InputTag('testProducer')
 )
 
+process.testObjectAnalyzer = cms.EDAnalyzer('TestAlpakaObjectAnalyzer',
+    source = cms.InputTag('testProducer')
+)
+
 # analyse the second product
 process.testAnalyzerSerial = cms.EDAnalyzer('TestAlpakaAnalyzer',
     source = cms.InputTag('testProducerSerial'),
     expectBackend = cms.string('SerialSync')
 )
 
-process.cuda_path = cms.Path(process.testAnalyzer)
+process.testObjectAnalyzerSerial = cms.EDAnalyzer('TestAlpakaObjectAnalyzer',
+    source = cms.InputTag('testProducerSerial'),
+    expectBackend = cms.string('SerialSync')
+)
+
+process.device_path = cms.Path(process.testAnalyzer + process.testObjectAnalyzer)
 
-process.serial_path = cms.Path(process.testAnalyzerSerial)
+process.serial_path = cms.Path(process.testAnalyzerSerial + process.testObjectAnalyzerSerial)
 
 process.maxEvents.input = 10

HeterogeneousCore/AlpakaTest/test/writer.py

@@ -7,8 +7,9 @@
 process.load('Configuration.StandardSequences.Accelerators_cff')
 process.load('HeterogeneousCore.AlpakaCore.ProcessAcceleratorAlpaka_cfi')
 
-# enable logging for the AlpakaService and TestAlpakaAnalyzer
+# enable logging for the analysers
 process.MessageLogger.TestAlpakaAnalyzer = cms.untracked.PSet()
+process.MessageLogger.TestAlpakaObjectAnalyzer = cms.untracked.PSet()
 
 # either run the producer on a gpu (if available) and copy the product to the cpu, or run the producer directly on the cpu
 process.testProducer = cms.EDProducer('TestAlpakaProducer@alpaka',
@@ -20,11 +21,15 @@
     #)
 )
 
-# analyse the product
+# analyse the first set of products
 process.testAnalyzer = cms.EDAnalyzer('TestAlpakaAnalyzer',
     source = cms.InputTag('testProducer')
 )
 
+process.testObjectAnalyzer = cms.EDAnalyzer('TestAlpakaObjectAnalyzer',
+    source = cms.InputTag('testProducer')
+)
+
 # run a second producer explicitly on the cpu
 process.testProducerSerial = cms.EDProducer('alpaka_serial_sync::TestAlpakaProducer',
     size = cms.int32(99)
@@ -37,28 +42,32 @@
 #    )
 #)
 
-# analyse the second product
+# analyse the second set of products
 process.testAnalyzerSerial = cms.EDAnalyzer('TestAlpakaAnalyzer',
-    source = cms.InputTag('testProducerSerial')
+    source = cms.InputTag('testProducerSerial'),
+    expectBackend = cms.string('SerialSync')
+)
+
+process.testObjectAnalyzerSerial = cms.EDAnalyzer('TestAlpakaObjectAnalyzer',
+    source = cms.InputTag('testProducerSerial'),
+    expectBackend = cms.string('SerialSync')
 )
 
-# write the two products to a 'test.root' file
+# write all products to a 'test.root' file
 process.output = cms.OutputModule('PoolOutputModule',
     fileName = cms.untracked.string('test.root'),
-    outputCommands = cms.untracked.vstring(
-        'drop *',
-        'keep *_testProducer_*_*',
-        'keep *_testProducerSerial_*_*',
-  )
+    outputCommands = cms.untracked.vstring('keep *')
 )
 
 process.process_path = cms.Path(
     process.testProducer +
-    process.testAnalyzer)
+    process.testAnalyzer +
+    process.testObjectAnalyzer)
 
 process.serial_path = cms.Path(
     process.testProducerSerial +
-    process.testAnalyzerSerial)
+    process.testAnalyzerSerial +
+    process.testObjectAnalyzerSerial)
 
 process.output_path = cms.EndPath(process.output)