Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-06-29 22:58:07 

0001 /*
0002  *  stream_filter_test.cppunit.cc
0003  *  EDMProto
0004  *
0005  *  Created by Chris Jones on 2/8/2013.
0006  */
0007 #include <iostream>
0008 #include <atomic>
0009 #include <vector>
0010 #include <map>
0011 #include <functional>
0012 #include "oneapi/tbb/global_control.h"
0013 #include "FWCore/Framework/interface/maker/Worker.h"
0014 #include "FWCore/Framework/interface/maker/WorkerT.h"
0015 #include "FWCore/Framework/interface/maker/ModuleHolder.h"
0016 #include "FWCore/Framework/interface/PreallocationConfiguration.h"
0017 #include "FWCore/Framework/interface/TransitionInfoTypes.h"
0018 #include "FWCore/Framework/interface/stream/EDFilter.h"
0019 #include "FWCore/Framework/interface/stream/EDProducerAdaptor.h"
0020 #include "FWCore/Framework/interface/OccurrenceTraits.h"
0021 #include "FWCore/Framework/interface/ProductResolversFactory.h"
0022 #include "DataFormats/Provenance/interface/ProductRegistry.h"
0023 #include "DataFormats/Provenance/interface/BranchIDListHelper.h"
0024 #include "DataFormats/Provenance/interface/ThinnedAssociationsHelper.h"
0025 #include "FWCore/Framework/interface/HistoryAppender.h"
0026 #include "FWCore/ServiceRegistry/interface/GlobalContext.h"
0027 #include "FWCore/ServiceRegistry/interface/ParentContext.h"
0028 #include "FWCore/ServiceRegistry/interface/StreamContext.h"
0029 #include "FWCore/Concurrency/interface/FinalWaitingTask.h"
0030 #include "FWCore/Utilities/interface/GlobalIdentifier.h"
0031 
0032 #include "FWCore/Utilities/interface/Exception.h"
0033 
0034 #include "cppunit/extensions/HelperMacros.h"
0035 
0036 namespace {
0037   struct ShadowStreamID {
0038     constexpr ShadowStreamID() : value(0) {}
0039     unsigned int value;
0040   };
0041 
0042   union IDUnion {
0043     IDUnion() : m_shadow() {}
0044     ShadowStreamID m_shadow;
0045     edm::StreamID m_id;
0046   };
0047 }  // namespace
0048 static edm::StreamID makeID() {
0049   IDUnion u;
0050   assert(u.m_id.value() == 0);
0051   return u.m_id;
0052 }
0053 static const edm::StreamID s_streamID0 = makeID();
0054 
0055 class testStreamFilter : public CppUnit::TestFixture {
0056   CPPUNIT_TEST_SUITE(testStreamFilter);
0057 
0058   CPPUNIT_TEST(basicTest);
0059   CPPUNIT_TEST(globalTest);
0060   CPPUNIT_TEST(runTest);
0061   CPPUNIT_TEST(runSummaryTest);
0062   CPPUNIT_TEST(lumiTest);
0063   CPPUNIT_TEST(lumiSummaryTest);
0064   CPPUNIT_TEST(beginRunProdTest);
0065   CPPUNIT_TEST(beginLumiProdTest);
0066   CPPUNIT_TEST(endRunProdTest);
0067   CPPUNIT_TEST(endLumiProdTest);
0068   CPPUNIT_TEST(endRunSummaryProdTest);
0069   CPPUNIT_TEST(endLumiSummaryProdTest);
0070 
0071   CPPUNIT_TEST_SUITE_END();
0072 
0073 public:
0074   testStreamFilter();
0075 
0076   void setUp() {}
0077   void tearDown() {}
0078 
0079   void basicTest();
0080   void globalTest();
0081   void runTest();
0082   void runSummaryTest();
0083   void lumiTest();
0084   void lumiSummaryTest();
0085   void beginRunProdTest();
0086   void beginLumiProdTest();
0087   void endRunProdTest();
0088   void endLumiProdTest();
0089   void endRunSummaryProdTest();
0090   void endLumiSummaryProdTest();
0091 
0092   enum class Trans {
0093     kBeginJob,                    //0
0094     kBeginStream,                 //1
0095     kGlobalBeginRun,              //2
0096     kStreamBeginRun,              //3
0097     kGlobalBeginLuminosityBlock,  //4
0098     kStreamBeginLuminosityBlock,  //5
0099     kEvent,                       //6
0100     kStreamEndLuminosityBlock,    //7
0101     kGlobalEndLuminosityBlock,    //8
0102     kStreamEndRun,                //9
0103     kGlobalEndRun,                //10
0104     kEndStream,                   //11
0105     kEndJob                       //12
0106   };
0107 
0108   typedef std::vector<Trans> Expectations;
0109 
0110 private:
0111   std::map<Trans, std::function<void(edm::Worker*, edm::maker::ModuleHolder*)>> m_transToFunc;
0112 
0113   edm::ProcessConfiguration m_procConfig;
0114   std::shared_ptr<edm::ProductRegistry> m_prodReg;
0115   std::shared_ptr<edm::BranchIDListHelper> m_idHelper;
0116   std::shared_ptr<edm::ThinnedAssociationsHelper> m_associationsHelper;
0117   std::unique_ptr<edm::EventPrincipal> m_ep;
0118   edm::HistoryAppender historyAppender_;
0119   std::shared_ptr<edm::LuminosityBlockPrincipal> m_lbp;
0120   std::shared_ptr<edm::RunPrincipal> m_rp;
0121   std::shared_ptr<edm::ActivityRegistry>
0122       m_actReg;  // We do not use propagate_const because the registry itself is mutable.
0123   edm::EventSetupImpl* m_es = nullptr;
0124   edm::ModuleDescription m_desc = {"Dummy", "dummy"};
0125 
0126   template <typename T, typename U>
0127   void testTransitions(std::shared_ptr<U> iMod, Expectations const& iExpect);
0128 
0129   template <typename Traits, typename Info>
0130   void doWork(edm::Worker* iBase, Info const& info, edm::ParentContext const& iContext) {
0131     oneapi::tbb::task_group group;
0132     edm::FinalWaitingTask task{group};
0133     edm::ServiceToken token;
0134     iBase->doWorkAsync<Traits>(edm::WaitingTaskHolder(group, &task), info, token, s_streamID0, iContext, nullptr);
0135     task.wait();
0136   }
0137 
0138   template <typename T>
0139   void runTest(Expectations const& iExpect);
0140 
0141   class BasicProd : public edm::stream::EDFilter<> {
0142   public:
0143     static unsigned int m_count;
0144 
0145     BasicProd(edm::ParameterSet const&) {}
0146 
0147     bool filter(edm::Event&, edm::EventSetup const&) override {
0148       ++m_count;
0149       return true;
0150     }
0151   };
0152 
0153   class GlobalProd : public edm::stream::EDFilter<edm::GlobalCache<int>> {
0154   public:
0155     static unsigned int m_count;
0156 
0157     static std::unique_ptr<int> initializeGlobalCache(edm::ParameterSet const&) { return std::make_unique<int>(1); }
0158     GlobalProd(edm::ParameterSet const&, const int* iGlobal) { CPPUNIT_ASSERT(*iGlobal == 1); }
0159 
0160     bool filter(edm::Event&, edm::EventSetup const&) override {
0161       ++m_count;
0162       return true;
0163     }
0164 
0165     static void globalEndJob(int* iGlobal) {
0166       CPPUNIT_ASSERT(1 == *iGlobal);
0167       ++m_count;
0168     }
0169   };
0170   class GlobalProdWithBeginJob : public edm::stream::EDFilter<edm::GlobalCache<int>> {
0171   public:
0172     static unsigned int m_count;
0173 
0174     static std::unique_ptr<int> initializeGlobalCache(edm::ParameterSet const&) { return std::make_unique<int>(1); }
0175     GlobalProdWithBeginJob(edm::ParameterSet const&, const int* iGlobal) { CPPUNIT_ASSERT(*iGlobal == 1); }
0176 
0177     static void globalBeginJob(int* iGlobal) {
0178       CPPUNIT_ASSERT(1 == *iGlobal);
0179       *iGlobal = 2;
0180       ++m_count;
0181     }
0182 
0183     void beginStream(edm::StreamID) override {
0184       int* iGlobal = const_cast<int*>(globalCache());
0185       CPPUNIT_ASSERT(2 == *iGlobal);
0186       *iGlobal = 3;
0187       ++m_count;
0188     }
0189 
0190     bool filter(edm::Event&, edm::EventSetup const&) override {
0191       ++m_count;
0192       return true;
0193     }
0194 
0195     static void globalEndJob(int* iGlobal) {
0196       CPPUNIT_ASSERT(3 == *iGlobal);
0197       ++m_count;
0198     }
0199   };
0200   class RunProd : public edm::stream::EDFilter<edm::RunCache<int>> {
0201   public:
0202     static unsigned int m_count;
0203     RunProd(edm::ParameterSet const&) {}
0204     bool filter(edm::Event&, edm::EventSetup const&) override {
0205       ++m_count;
0206       return true;
0207     }
0208 
0209     static std::shared_ptr<int> globalBeginRun(edm::Run const&, edm::EventSetup const&, GlobalCache const*) {
0210       ++m_count;
0211       return std::shared_ptr<int>{};
0212     }
0213 
0214     static void globalEndRun(edm::Run const&, edm::EventSetup const&, RunProd::RunContext const*) { ++m_count; }
0215   };
0216 
0217   class LumiProd : public edm::stream::EDFilter<edm::LuminosityBlockCache<int>> {
0218   public:
0219     static unsigned int m_count;
0220     LumiProd(edm::ParameterSet const&) {}
0221     bool filter(edm::Event&, edm::EventSetup const&) override {
0222       ++m_count;
0223       return true;
0224     }
0225 
0226     static std::shared_ptr<int> globalBeginLuminosityBlock(edm::LuminosityBlock const&,
0227                                                            edm::EventSetup const&,
0228                                                            RunContext const*) {
0229       ++m_count;
0230       return std::shared_ptr<int>{};
0231     }
0232 
0233     static void globalEndLuminosityBlock(edm::LuminosityBlock const&,
0234                                          edm::EventSetup const&,
0235                                          LuminosityBlockContext const*) {
0236       ++m_count;
0237     }
0238   };
0239 
0240   class RunSummaryProd : public edm::stream::EDFilter<edm::RunSummaryCache<int>> {
0241   public:
0242     static unsigned int m_count;
0243     RunSummaryProd(edm::ParameterSet const&) {}
0244     bool filter(edm::Event&, edm::EventSetup const&) override {
0245       ++m_count;
0246       return true;
0247     }
0248 
0249     static std::shared_ptr<int> globalBeginRunSummary(edm::Run const&, edm::EventSetup const&, GlobalCache const*) {
0250       ++m_count;
0251       return std::shared_ptr<int>{};
0252     }
0253 
0254     void endRunSummary(edm::Run const&, edm::EventSetup const&, int*) const override { ++m_count; }
0255 
0256     static void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, RunContext const*, int*) { ++m_count; }
0257   };
0258 
0259   class LumiSummaryProd : public edm::stream::EDFilter<edm::LuminosityBlockSummaryCache<int>> {
0260   public:
0261     static unsigned int m_count;
0262     LumiSummaryProd(edm::ParameterSet const&) {}
0263     bool filter(edm::Event&, edm::EventSetup const&) override {
0264       ++m_count;
0265       return true;
0266     }
0267 
0268     static std::shared_ptr<int> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const&,
0269                                                                   edm::EventSetup const&,
0270                                                                   LuminosityBlockContext const*) {
0271       ++m_count;
0272       return std::shared_ptr<int>{};
0273     }
0274 
0275     void endLuminosityBlockSummary(edm::LuminosityBlock const&, edm::EventSetup const&, int*) const override {
0276       ++m_count;
0277     }
0278 
0279     static void globalEndLuminosityBlockSummary(edm::LuminosityBlock const&,
0280                                                 edm::EventSetup const&,
0281                                                 LuminosityBlockContext const*,
0282                                                 int*) {
0283       ++m_count;
0284     }
0285   };
0286 
0287   class BeginRunProd : public edm::stream::EDFilter<edm::BeginRunProducer> {
0288   public:
0289     static unsigned int m_count;
0290     BeginRunProd(edm::ParameterSet const&) {}
0291 
0292     bool filter(edm::Event&, edm::EventSetup const&) override {
0293       ++m_count;
0294       return true;
0295     }
0296 
0297     static void globalBeginRunProduce(edm::Run&, edm::EventSetup const&, RunContext const*) { ++m_count; }
0298   };
0299 
0300   class BeginLumiProd : public edm::stream::EDFilter<edm::BeginLuminosityBlockProducer> {
0301   public:
0302     static unsigned int m_count;
0303     BeginLumiProd(edm::ParameterSet const&) {}
0304 
0305     bool filter(edm::Event&, edm::EventSetup const&) override {
0306       ++m_count;
0307       return true;
0308     }
0309 
0310     static void globalBeginLuminosityBlockProduce(edm::LuminosityBlock&,
0311                                                   edm::EventSetup const&,
0312                                                   LuminosityBlockContext const*) {
0313       ++m_count;
0314     }
0315   };
0316 
0317   class EndRunProd : public edm::stream::EDFilter<edm::EndRunProducer> {
0318   public:
0319     static unsigned int m_count;
0320     EndRunProd(edm::ParameterSet const&) {}
0321 
0322     bool filter(edm::Event&, edm::EventSetup const&) override {
0323       ++m_count;
0324       return true;
0325     }
0326 
0327     static void globalEndRunProduce(edm::Run&, edm::EventSetup const&, RunContext const*) { ++m_count; }
0328   };
0329 
0330   class EndLumiProd : public edm::stream::EDFilter<edm::EndLuminosityBlockProducer> {
0331   public:
0332     static unsigned int m_count;
0333     EndLumiProd(edm::ParameterSet const&) {}
0334 
0335     bool filter(edm::Event&, edm::EventSetup const&) override {
0336       ++m_count;
0337       return true;
0338     }
0339 
0340     static void globalEndLuminosityBlockProduce(edm::LuminosityBlock&,
0341                                                 edm::EventSetup const&,
0342                                                 LuminosityBlockContext const*) {
0343       ++m_count;
0344     }
0345   };
0346 
0347   class EndRunSummaryProd : public edm::stream::EDFilter<edm::EndRunProducer, edm::RunSummaryCache<int>> {
0348   public:
0349     static unsigned int m_count;
0350     static bool m_globalEndRunSummaryCalled;
0351     EndRunSummaryProd(edm::ParameterSet const&) {}
0352 
0353     bool filter(edm::Event&, edm::EventSetup const&) override {
0354       ++m_count;
0355       return true;
0356     }
0357 
0358     static std::shared_ptr<int> globalBeginRunSummary(edm::Run const&, edm::EventSetup const&, RunContext const*) {
0359       ++m_count;
0360       return std::shared_ptr<int>{};
0361     }
0362 
0363     void endRunSummary(edm::Run const&, edm::EventSetup const&, int*) const override { ++m_count; }
0364 
0365     static void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, RunContext const*, int*) {
0366       ++m_count;
0367       CPPUNIT_ASSERT(m_globalEndRunSummaryCalled == false);
0368       m_globalEndRunSummaryCalled = true;
0369     }
0370 
0371     static void globalEndRunProduce(edm::Run&, edm::EventSetup const&, RunContext const*, int const*) {
0372       ++m_count;
0373       CPPUNIT_ASSERT(m_globalEndRunSummaryCalled == true);
0374       m_globalEndRunSummaryCalled = false;
0375     }
0376   };
0377 
0378   class EndLumiSummaryProd
0379       : public edm::stream::EDFilter<edm::EndLuminosityBlockProducer, edm::LuminosityBlockSummaryCache<int>> {
0380   public:
0381     static unsigned int m_count;
0382     static bool m_globalEndLuminosityBlockSummaryCalled;
0383     EndLumiSummaryProd(edm::ParameterSet const&) {}
0384 
0385     bool filter(edm::Event&, edm::EventSetup const&) override {
0386       ++m_count;
0387       return true;
0388     }
0389 
0390     static std::shared_ptr<int> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const&,
0391                                                                   edm::EventSetup const&,
0392                                                                   LuminosityBlockContext const*) {
0393       ++m_count;
0394       return std::shared_ptr<int>{};
0395     }
0396 
0397     void endLuminosityBlockSummary(edm::LuminosityBlock const&, edm::EventSetup const&, int*) const override {
0398       ++m_count;
0399     }
0400 
0401     static void globalEndLuminosityBlockSummary(edm::LuminosityBlock const&,
0402                                                 edm::EventSetup const&,
0403                                                 LuminosityBlockContext const*,
0404                                                 int*) {
0405       ++m_count;
0406       CPPUNIT_ASSERT(m_globalEndLuminosityBlockSummaryCalled == false);
0407       m_globalEndLuminosityBlockSummaryCalled = true;
0408     }
0409 
0410     static void globalEndLuminosityBlockProduce(edm::LuminosityBlock&,
0411                                                 edm::EventSetup const&,
0412                                                 LuminosityBlockContext const*,
0413                                                 int const*) {
0414       ++m_count;
0415       CPPUNIT_ASSERT(m_globalEndLuminosityBlockSummaryCalled == true);
0416       m_globalEndLuminosityBlockSummaryCalled = false;
0417     }
0418   };
0419 };
0420 unsigned int testStreamFilter::BasicProd::m_count = 0;
0421 unsigned int testStreamFilter::GlobalProd::m_count = 0;
0422 unsigned int testStreamFilter::GlobalProdWithBeginJob::m_count = 0;
0423 unsigned int testStreamFilter::RunProd::m_count = 0;
0424 unsigned int testStreamFilter::LumiProd::m_count = 0;
0425 unsigned int testStreamFilter::RunSummaryProd::m_count = 0;
0426 unsigned int testStreamFilter::LumiSummaryProd::m_count = 0;
0427 unsigned int testStreamFilter::BeginRunProd::m_count = 0;
0428 unsigned int testStreamFilter::EndRunProd::m_count = 0;
0429 unsigned int testStreamFilter::BeginLumiProd::m_count = 0;
0430 unsigned int testStreamFilter::EndLumiProd::m_count = 0;
0431 unsigned int testStreamFilter::EndRunSummaryProd::m_count = 0;
0432 bool testStreamFilter::EndRunSummaryProd::m_globalEndRunSummaryCalled = false;
0433 unsigned int testStreamFilter::EndLumiSummaryProd::m_count = 0;
0434 bool testStreamFilter::EndLumiSummaryProd::m_globalEndLuminosityBlockSummaryCalled = false;
0435 ///registration of the test so that the runner can find it
0436 CPPUNIT_TEST_SUITE_REGISTRATION(testStreamFilter);
0437 
0438 testStreamFilter::testStreamFilter()
0439     : m_prodReg(new edm::ProductRegistry{}),
0440       m_idHelper(new edm::BranchIDListHelper{}),
0441       m_associationsHelper(new edm::ThinnedAssociationsHelper{}),
0442       m_ep() {
0443   //Setup the principals
0444   m_prodReg->setFrozen();
0445   m_idHelper->updateFromRegistry(*m_prodReg);
0446   edm::EventID eventID = edm::EventID::firstValidEvent();
0447 
0448   std::string uuid = edm::createGlobalIdentifier();
0449   edm::Timestamp now(1234567UL);
0450   m_rp.reset(
0451       new edm::RunPrincipal(m_prodReg, edm::productResolversFactory::makePrimary, m_procConfig, &historyAppender_, 0));
0452   m_rp->setAux(edm::RunAuxiliary(eventID.run(), now, now));
0453   auto lumiAux = std::make_shared<edm::LuminosityBlockAuxiliary>(m_rp->run(), 1, now, now);
0454   m_lbp.reset(new edm::LuminosityBlockPrincipal(
0455       m_prodReg, edm::productResolversFactory::makePrimary, m_procConfig, &historyAppender_, 0));
0456   m_lbp->setAux(*lumiAux);
0457   m_lbp->setRunPrincipal(m_rp);
0458   edm::EventAuxiliary eventAux(eventID, uuid, now, true);
0459 
0460   //Only an EventProcessor is allowed to create a StreamID but I need one
0461   ShadowStreamID shadowID;
0462   shadowID.value = 0;
0463   edm::StreamID* pID = reinterpret_cast<edm::StreamID*>(&shadowID);
0464   assert(pID->value() == 0);
0465 
0466   m_ep.reset(new edm::EventPrincipal(m_prodReg,
0467                                      edm::productResolversFactory::makePrimary,
0468                                      m_idHelper,
0469                                      m_associationsHelper,
0470                                      m_procConfig,
0471                                      nullptr,
0472                                      *pID));
0473   m_ep->fillEventPrincipal(eventAux, nullptr);
0474   m_ep->setLuminosityBlockPrincipal(m_lbp.get());
0475   m_actReg.reset(new edm::ActivityRegistry);
0476 
0477   //For each transition, bind a lambda which will call the proper method of the Worker
0478   m_transToFunc[Trans::kBeginJob] = [](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) { iHolder->beginJob(); };
0479   m_transToFunc[Trans::kBeginStream] = [](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0480     iHolder->beginStream(s_streamID0);
0481   };
0482 
0483   m_transToFunc[Trans::kGlobalBeginRun] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0484     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionGlobalBegin> Traits;
0485     edm::GlobalContext gc(edm::GlobalContext::Transition::kBeginRun, nullptr);
0486     edm::ParentContext parentContext(&gc);
0487     iBase->setActivityRegistry(m_actReg);
0488     edm::RunTransitionInfo info(*m_rp, *m_es);
0489     doWork<Traits>(iBase, info, parentContext);
0490   };
0491   m_transToFunc[Trans::kStreamBeginRun] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0492     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionStreamBegin> Traits;
0493     edm::StreamContext streamContext(s_streamID0, nullptr);
0494     edm::ParentContext parentContext(&streamContext);
0495     iBase->setActivityRegistry(m_actReg);
0496     edm::RunTransitionInfo info(*m_rp, *m_es);
0497     doWork<Traits>(iBase, info, parentContext);
0498   };
0499 
0500   m_transToFunc[Trans::kGlobalBeginLuminosityBlock] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0501     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionGlobalBegin> Traits;
0502     edm::GlobalContext gc(edm::GlobalContext::Transition::kBeginLuminosityBlock, nullptr);
0503     edm::ParentContext parentContext(&gc);
0504     iBase->setActivityRegistry(m_actReg);
0505     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0506     doWork<Traits>(iBase, info, parentContext);
0507   };
0508   m_transToFunc[Trans::kStreamBeginLuminosityBlock] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0509     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionStreamBegin> Traits;
0510     edm::StreamContext streamContext(s_streamID0, nullptr);
0511     edm::ParentContext parentContext(&streamContext);
0512     iBase->setActivityRegistry(m_actReg);
0513     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0514     doWork<Traits>(iBase, info, parentContext);
0515   };
0516 
0517   m_transToFunc[Trans::kEvent] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0518     typedef edm::OccurrenceTraits<edm::EventPrincipal, edm::BranchActionStreamBegin> Traits;
0519     edm::StreamContext streamContext(s_streamID0, nullptr);
0520     edm::ParentContext parentContext(&streamContext);
0521     iBase->setActivityRegistry(m_actReg);
0522     edm::EventTransitionInfo info(*m_ep, *m_es);
0523     doWork<Traits>(iBase, info, parentContext);
0524   };
0525 
0526   m_transToFunc[Trans::kStreamEndLuminosityBlock] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0527     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionStreamEnd> Traits;
0528     edm::StreamContext streamContext(s_streamID0, nullptr);
0529     edm::ParentContext parentContext(&streamContext);
0530     iBase->setActivityRegistry(m_actReg);
0531     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0532     doWork<Traits>(iBase, info, parentContext);
0533   };
0534   m_transToFunc[Trans::kGlobalEndLuminosityBlock] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0535     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionGlobalEnd> Traits;
0536     edm::GlobalContext gc(edm::GlobalContext::Transition::kEndLuminosityBlock, nullptr);
0537     edm::ParentContext parentContext(&gc);
0538     iBase->setActivityRegistry(m_actReg);
0539     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0540     doWork<Traits>(iBase, info, parentContext);
0541   };
0542 
0543   m_transToFunc[Trans::kStreamEndRun] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0544     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionStreamEnd> Traits;
0545     edm::StreamContext streamContext(s_streamID0, nullptr);
0546     edm::ParentContext parentContext(&streamContext);
0547     iBase->setActivityRegistry(m_actReg);
0548     edm::RunTransitionInfo info(*m_rp, *m_es);
0549     doWork<Traits>(iBase, info, parentContext);
0550   };
0551   m_transToFunc[Trans::kGlobalEndRun] = [this](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0552     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionGlobalEnd> Traits;
0553     edm::GlobalContext gc(edm::GlobalContext::Transition::kEndRun, nullptr);
0554     edm::ParentContext parentContext(&gc);
0555     iBase->setActivityRegistry(m_actReg);
0556     edm::RunTransitionInfo info(*m_rp, *m_es);
0557     doWork<Traits>(iBase, info, parentContext);
0558   };
0559 
0560   m_transToFunc[Trans::kEndStream] = [](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) {
0561     iHolder->endStream(s_streamID0);
0562   };
0563   m_transToFunc[Trans::kEndJob] = [](edm::Worker* iBase, edm::maker::ModuleHolder* iHolder) { iHolder->endJob(); };
0564 }
0565 
0566 namespace {
0567   template <typename T>
0568   std::shared_ptr<edm::stream::EDFilterAdaptorBase> createModule() {
0569     edm::ParameterSet pset;
0570     std::shared_ptr<edm::stream::EDFilterAdaptorBase> retValue =
0571         std::make_shared<edm::stream::EDFilterAdaptor<T>>(pset);
0572     edm::maker::ModuleHolderT<edm::stream::EDFilterAdaptorBase> h(retValue);
0573     h.finishModuleInitialization(retValue->moduleDescription(), edm::PreallocationConfiguration{}, nullptr);
0574     return retValue;
0575   }
0576   template <typename T>
0577   void testTransition(edm::Worker* iWorker,
0578                       edm::maker::ModuleHolder* iHolder,
0579                       testStreamFilter::Trans iTrans,
0580                       testStreamFilter::Expectations const& iExpect,
0581                       std::function<void(edm::Worker*, edm::maker::ModuleHolder* iHolder)> iFunc) {
0582     assert(0 == T::m_count);
0583     iFunc(iWorker, iHolder);
0584     auto count = std::count(iExpect.begin(), iExpect.end(), iTrans);
0585     if (count != T::m_count) {
0586       std::cout << "For trans " << static_cast<std::underlying_type<testStreamFilter::Trans>::type>(iTrans)
0587                 << " expected " << count << " and got " << T::m_count << std::endl;
0588     }
0589     CPPUNIT_ASSERT(T::m_count == count);
0590     T::m_count = 0;
0591     iWorker->reset();
0592   }
0593 }  // namespace
0594 
0595 template <typename T, typename U>
0596 void testStreamFilter::testTransitions(std::shared_ptr<U> iMod, Expectations const& iExpect) {
0597   oneapi::tbb::global_control control(oneapi::tbb::global_control::max_allowed_parallelism, 1);
0598 
0599   edm::maker::ModuleHolderT<edm::stream::EDFilterAdaptorBase> h(iMod);
0600   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wBeginJobEndJob{iMod, m_desc, nullptr};
0601   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wBeginStreamEndStream{iMod, m_desc, nullptr};
0602   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wGlobalLumi{iMod, m_desc, nullptr};
0603   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wStreamLumi{iMod, m_desc, nullptr};
0604   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wGlobalRun{iMod, m_desc, nullptr};
0605   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wStreamRun{iMod, m_desc, nullptr};
0606   for (auto& keyVal : m_transToFunc) {
0607     edm::Worker* worker = &wBeginJobEndJob;
0608     if (keyVal.first == Trans::kBeginStream || keyVal.first == Trans::kEndStream) {
0609       worker = &wBeginStreamEndStream;
0610     } else if (keyVal.first == Trans::kStreamBeginLuminosityBlock || keyVal.first == Trans::kStreamEndLuminosityBlock) {
0611       worker = &wStreamLumi;
0612     } else if (keyVal.first == Trans::kGlobalBeginLuminosityBlock || keyVal.first == Trans::kGlobalEndLuminosityBlock) {
0613       worker = &wGlobalLumi;
0614     } else if (keyVal.first == Trans::kStreamBeginRun || keyVal.first == Trans::kStreamEndRun) {
0615       worker = &wStreamRun;
0616     } else if (keyVal.first == Trans::kGlobalBeginRun || keyVal.first == Trans::kGlobalEndRun) {
0617       worker = &wGlobalRun;
0618     }
0619     testTransition<T>(worker, &h, keyVal.first, iExpect, keyVal.second);
0620   }
0621 }
0622 template <typename T>
0623 void testStreamFilter::runTest(Expectations const& iExpect) {
0624   auto mod = createModule<T>();
0625   CPPUNIT_ASSERT(0 == T::m_count);
0626   testTransitions<T>(mod, iExpect);
0627 }
0628 
0629 void testStreamFilter::basicTest() { runTest<BasicProd>({Trans::kEvent}); }
0630 
0631 void testStreamFilter::globalTest() {
0632   runTest<GlobalProd>({Trans::kEvent, Trans::kEndJob});
0633   runTest<GlobalProdWithBeginJob>({Trans::kBeginJob, Trans::kBeginStream, Trans::kEvent, Trans::kEndJob});
0634 }
0635 
0636 void testStreamFilter::runTest() { runTest<RunProd>({Trans::kGlobalBeginRun, Trans::kEvent, Trans::kGlobalEndRun}); }
0637 
0638 void testStreamFilter::runSummaryTest() {
0639   runTest<RunSummaryProd>({Trans::kGlobalBeginRun, Trans::kEvent, Trans::kStreamEndRun, Trans::kGlobalEndRun});
0640 }
0641 
0642 void testStreamFilter::lumiTest() {
0643   runTest<LumiProd>({Trans::kGlobalBeginLuminosityBlock, Trans::kEvent, Trans::kGlobalEndLuminosityBlock});
0644 }
0645 
0646 void testStreamFilter::lumiSummaryTest() {
0647   runTest<LumiSummaryProd>({Trans::kGlobalBeginLuminosityBlock,
0648                             Trans::kEvent,
0649                             Trans::kStreamEndLuminosityBlock,
0650                             Trans::kGlobalEndLuminosityBlock});
0651 }
0652 
0653 void testStreamFilter::beginRunProdTest() { runTest<BeginRunProd>({Trans::kGlobalBeginRun, Trans::kEvent}); }
0654 
0655 void testStreamFilter::beginLumiProdTest() {
0656   runTest<BeginLumiProd>({Trans::kGlobalBeginLuminosityBlock, Trans::kEvent});
0657 }
0658 
0659 void testStreamFilter::endRunProdTest() { runTest<EndRunProd>({Trans::kGlobalEndRun, Trans::kEvent}); }
0660 
0661 void testStreamFilter::endLumiProdTest() { runTest<EndLumiProd>({Trans::kGlobalEndLuminosityBlock, Trans::kEvent}); }
0662 
0663 void testStreamFilter::endRunSummaryProdTest() {
0664   runTest<EndRunSummaryProd>(
0665       {Trans::kGlobalEndRun, Trans::kEvent, Trans::kGlobalBeginRun, Trans::kStreamEndRun, Trans::kGlobalEndRun});
0666 }
0667 
0668 void testStreamFilter::endLumiSummaryProdTest() {
0669   runTest<EndLumiSummaryProd>({Trans::kGlobalEndLuminosityBlock,
0670                                Trans::kEvent,
0671                                Trans::kGlobalBeginLuminosityBlock,
0672                                Trans::kStreamEndLuminosityBlock,
0673                                Trans::kGlobalEndLuminosityBlock});
0674 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!