Skip to content

Commit

Permalink
Merge pull request #30763 from wddgit/streamProcessBlockNoGlobalCache
Browse files Browse the repository at this point in the history
Stream case with ProcessBlock and no GlobalCache
cmsbuild authored Jul 17, 2020

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature. The key has expired.
2 parents 3cb645f + 7fbb6c7 commit 4bd85a7
Showing 3 changed files with 109 additions and 20 deletions.
82 changes: 70 additions & 12 deletions FWCore/Framework/interface/stream/callAbilities.h
Original file line number Diff line number Diff line change
@@ -67,7 +67,7 @@ namespace edm {
//********************************
// CallInputProcessBlock
//********************************
template <typename T, bool>
template <typename T, bool, bool>
struct CallInputProcessBlockImpl {
static void accessInputProcessBlock(edm::ProcessBlock const& iProcessBlock, typename T::GlobalCache* iGC) {
// This is not fully implemented yet and will never be called
@@ -76,12 +76,26 @@ namespace edm {
};

template <typename T>
struct CallInputProcessBlockImpl<T, false> {
struct CallInputProcessBlockImpl<T, true, false> {
static void accessInputProcessBlock(edm::ProcessBlock const& processBlock, typename T::GlobalCache*) {
// This is not fully implemented yet and will never be called
T::accessInputProcessBlock(processBlock);
}
};

template <typename T>
struct CallInputProcessBlockImpl<T, false, true> {
static void accessInputProcessBlock(edm::ProcessBlock const&, typename T::GlobalCache*) {}
};

template <typename T>
struct CallInputProcessBlockImpl<T, false, false> {
static void accessInputProcessBlock(edm::ProcessBlock const&, typename T::GlobalCache*) {}
};

template <typename T>
using CallInputProcessBlock = CallInputProcessBlockImpl<T, T::HasAbility::kInputProcessBlockCache>;
using CallInputProcessBlock =
CallInputProcessBlockImpl<T, T::HasAbility::kInputProcessBlockCache, T::HasAbility::kGlobalCache>;

//********************************
// CallGlobalRun
@@ -246,7 +260,7 @@ namespace edm {
//********************************
// CallWatchProcessBlock
//********************************
template <typename T, bool>
template <typename T, bool, bool>
struct CallWatchProcessBlockImpl {
static void beginProcessBlock(edm::ProcessBlock const& iProcessBlock, typename T::GlobalCache* iGC) {
T::beginProcessBlock(iProcessBlock, iGC);
@@ -258,49 +272,93 @@ namespace edm {
};

template <typename T>
struct CallWatchProcessBlockImpl<T, false> {
struct CallWatchProcessBlockImpl<T, true, false> {
static void beginProcessBlock(edm::ProcessBlock const& processBlock, typename T::GlobalCache*) {
T::beginProcessBlock(processBlock);
}

static void endProcessBlock(edm::ProcessBlock const& processBlock, typename T::GlobalCache*) {
T::endProcessBlock(processBlock);
}
};

template <typename T>
struct CallWatchProcessBlockImpl<T, false, true> {
static void beginProcessBlock(edm::ProcessBlock const&, typename T::GlobalCache*) {}
static void endProcessBlock(edm::ProcessBlock const&, typename T::GlobalCache*) {}
};

template <typename T>
struct CallWatchProcessBlockImpl<T, false, false> {
static void beginProcessBlock(edm::ProcessBlock const&, typename T::GlobalCache*) {}
static void endProcessBlock(edm::ProcessBlock const&, typename T::GlobalCache*) {}
};

template <typename T>
using CallWatchProcessBlock = CallWatchProcessBlockImpl<T, T::HasAbility::kWatchProcessBlock>;
using CallWatchProcessBlock =
CallWatchProcessBlockImpl<T, T::HasAbility::kWatchProcessBlock, T::HasAbility::kGlobalCache>;

//********************************
// CallBeginProcessBlockProduce
//********************************
template <typename T, bool>
template <typename T, bool, bool>
struct CallBeginProcessBlockProduceImpl {
static void produce(edm::ProcessBlock& processBlock, typename T::GlobalCache* globalCache) {
T::beginProcessBlockProduce(processBlock, globalCache);
}
};

template <typename T>
struct CallBeginProcessBlockProduceImpl<T, false> {
struct CallBeginProcessBlockProduceImpl<T, true, false> {
static void produce(edm::ProcessBlock& processBlock, typename T::GlobalCache*) {
T::beginProcessBlockProduce(processBlock);
}
};

template <typename T>
struct CallBeginProcessBlockProduceImpl<T, false, true> {
static void produce(edm::ProcessBlock&, typename T::GlobalCache*) {}
};

template <typename T>
struct CallBeginProcessBlockProduceImpl<T, false, false> {
static void produce(edm::ProcessBlock&, typename T::GlobalCache*) {}
};

template <typename T>
using CallBeginProcessBlockProduce = CallBeginProcessBlockProduceImpl<T, T::HasAbility::kBeginProcessBlockProducer>;
using CallBeginProcessBlockProduce =
CallBeginProcessBlockProduceImpl<T, T::HasAbility::kBeginProcessBlockProducer, T::HasAbility::kGlobalCache>;

//********************************
// CallEndProcessBlockProduce
//********************************
template <typename T, bool>
template <typename T, bool, bool>
struct CallEndProcessBlockProduceImpl {
static void produce(edm::ProcessBlock& processBlock, typename T::GlobalCache* globalCache) {
T::endProcessBlockProduce(processBlock, globalCache);
}
};

template <typename T>
struct CallEndProcessBlockProduceImpl<T, false> {
struct CallEndProcessBlockProduceImpl<T, true, false> {
static void produce(edm::ProcessBlock& processBlock, typename T::GlobalCache*) {
T::endProcessBlockProduce(processBlock);
}
};

template <typename T>
struct CallEndProcessBlockProduceImpl<T, false, true> {
static void produce(edm::ProcessBlock&, typename T::GlobalCache*) {}
};

template <typename T>
struct CallEndProcessBlockProduceImpl<T, false, false> {
static void produce(edm::ProcessBlock&, typename T::GlobalCache*) {}
};

template <typename T>
using CallEndProcessBlockProduce = CallEndProcessBlockProduceImpl<T, T::HasAbility::kEndProcessBlockProducer>;
using CallEndProcessBlockProduce =
CallEndProcessBlockProduceImpl<T, T::HasAbility::kEndProcessBlockProducer, T::HasAbility::kGlobalCache>;

//********************************
// CallBeginRunProduce
40 changes: 32 additions & 8 deletions FWCore/Framework/test/stubs/TestStreamProducers.cc
Original file line number Diff line number Diff line change
@@ -462,8 +462,6 @@ namespace edmtest {
: public edm::stream::EDProducer<edm::WatchProcessBlock, edm::GlobalCache<TestGlobalCache>> {
public:
explicit ProcessBlockIntProducer(edm::ParameterSet const& pset, TestGlobalCache const* testGlobalCache) {
produces<unsigned int>();

{
auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
if (not tag.label().empty()) {
@@ -500,10 +498,6 @@ namespace edmtest {
}
}

static std::shared_ptr<UnsafeCache> accessInputProcessBlock(edm::ProcessBlock const&, TestGlobalCache*) {
return std::make_shared<UnsafeCache>();
}

void produce(edm::Event&, edm::EventSetup const&) override {
TestGlobalCache const* testGlobalCache = globalCache();
if (testGlobalCache->m_count < 1u) {
@@ -560,7 +554,6 @@ namespace edmtest {
public:
explicit TestBeginProcessBlockProducer(edm::ParameterSet const& pset, TestGlobalCache const* testGlobalCache) {
testGlobalCache->token_ = produces<unsigned int, edm::Transition::BeginProcessBlock>("begin");
produces<unsigned int>();

auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
if (not tag.label().empty()) {
@@ -624,7 +617,6 @@ namespace edmtest {
public:
explicit TestEndProcessBlockProducer(edm::ParameterSet const& pset, TestGlobalCache const* testGlobalCache) {
testGlobalCache->token_ = produces<unsigned int, edm::Transition::EndProcessBlock>("end");
produces<unsigned int>();

auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
if (not tag.label().empty()) {
@@ -677,6 +669,35 @@ namespace edmtest {
}
};

class ProcessBlockIntProducerNoGlobalCache : public edm::stream::EDProducer<edm::WatchProcessBlock> {
public:
explicit ProcessBlockIntProducerNoGlobalCache(edm::ParameterSet const&) {}

static void beginProcessBlock(edm::ProcessBlock const&) {}

void produce(edm::Event&, edm::EventSetup const&) override {}

static void endProcessBlock(edm::ProcessBlock const&) {}
};

class TestBeginProcessBlockProducerNoGlobalCache : public edm::stream::EDProducer<edm::BeginProcessBlockProducer> {
public:
explicit TestBeginProcessBlockProducerNoGlobalCache(edm::ParameterSet const&) {}

static void beginProcessBlockProduce(edm::ProcessBlock&) {}

void produce(edm::Event&, edm::EventSetup const&) override {}
};

class TestEndProcessBlockProducerNoGlobalCache : public edm::stream::EDProducer<edm::EndProcessBlockProducer> {
public:
explicit TestEndProcessBlockProducerNoGlobalCache(edm::ParameterSet const&) {}

void produce(edm::Event&, edm::EventSetup const&) override {}

static void endProcessBlockProduce(edm::ProcessBlock&) {}
};

class TestBeginRunProducer : public edm::stream::EDProducer<edm::RunCache<bool>, edm::BeginRunProducer> {
public:
static std::atomic<unsigned int> m_count;
@@ -989,6 +1010,9 @@ DEFINE_FWK_MODULE(edmtest::stream::LumiSummaryIntProducer);
DEFINE_FWK_MODULE(edmtest::stream::ProcessBlockIntProducer);
DEFINE_FWK_MODULE(edmtest::stream::TestBeginProcessBlockProducer);
DEFINE_FWK_MODULE(edmtest::stream::TestEndProcessBlockProducer);
DEFINE_FWK_MODULE(edmtest::stream::ProcessBlockIntProducerNoGlobalCache);
DEFINE_FWK_MODULE(edmtest::stream::TestBeginProcessBlockProducerNoGlobalCache);
DEFINE_FWK_MODULE(edmtest::stream::TestEndProcessBlockProducerNoGlobalCache);
DEFINE_FWK_MODULE(edmtest::stream::TestBeginRunProducer);
DEFINE_FWK_MODULE(edmtest::stream::TestEndRunProducer);
DEFINE_FWK_MODULE(edmtest::stream::TestBeginLumiBlockProducer);
7 changes: 7 additions & 0 deletions FWCore/Framework/test/test_stream_modules_cfg.py
Original file line number Diff line number Diff line change
@@ -79,6 +79,10 @@
consumesEndProcessBlock = cms.InputTag("TestEndProcessBlockProd", "end")
)

process.ProcessBlockIntProdNoGlobalCache = cms.EDProducer("edmtest::stream::ProcessBlockIntProducerNoGlobalCache")
process.TestBeginProcessBlockProdNoGlobalCache = cms.EDProducer("edmtest::stream::TestBeginProcessBlockProducerNoGlobalCache")
process.TestEndProcessBlockProdNoGlobalCache = cms.EDProducer("edmtest::stream::TestEndProcessBlockProducerNoGlobalCache")

process.TestBeginRunProd = cms.EDProducer("edmtest::stream::TestBeginRunProducer",
transitions = cms.int32(int(nEvt/nEvtRun))
,cachevalue = cms.int32(nEvt)
@@ -227,6 +231,9 @@
process.TestBeginProcessBlockProd +
process.TestEndProcessBlockProdRead +
process.TestEndProcessBlockProd +
process.ProcessBlockIntProdNoGlobalCache +
process.TestBeginProcessBlockProdNoGlobalCache +
process.TestEndProcessBlockProdNoGlobalCache +
process.TestBeginRunProd +
process.TestEndRunProd +
process.TestBeginLumiBlockProd +

0 comments on commit 4bd85a7

Please sign in to comment.