Public Member Functions
ExternalGeneratorLumiInfo	beginLumiProduce (unsigned long long iTransitionID, edm::RandomNumberGeneratorState const &iState)

template<typename SERIAL >
auto	doTransition (SERIAL &iDeserializer, edm::Transition iTrans, unsigned long long iTransitionID) -> decltype(iDeserializer.deserialize())

std::optional< GenLumiInfoProduct >	endLumiProduce (unsigned long long iTransitionID)

std::optional< GenRunInfoProduct >	endRunProduce (unsigned long long iTransitionID)

ExternalGeneratorEventInfo	produce (edm::StreamID iStream, unsigned long long iTransitionID)

	StreamCache (const std::string &iConfig, int id, bool verbose, unsigned int waitTime)

	~StreamCache ()

Private Types
template<typename T >
using	Deserializer = ROOTDeserializer< T, ReadBuffer >

Private Member Functions
std::string	unique_name (std::string iBase)

Private Attributes
Deserializer< ExternalGeneratorLumiInfo >	bl_deserializer_

ControllerChannel	channel_

Deserializer< ExternalGeneratorEventInfo >	deserializer_

Deserializer< GenLumiInfoProduct >	el_deserializer_

Deserializer< GenRunInfoProduct >	er_deserializer_

bool	externalFailed_ = false

int	id_

FILE *	pipe_

ROOTSerializer< edm::RandomNumberGeneratorState, WriteBuffer >	randSerializer_

ReadBuffer	readBuffer_

WriteBuffer	writeBuffer_

Detailed Description

Definition at line 34 of file ExternalGeneratorFilter.cc.

Member Typedef Documentation

template<typename T >

using externalgen::StreamCache::Deserializer = ROOTDeserializer<T, ReadBuffer>

private

Definition at line 145 of file ExternalGeneratorFilter.cc.

Constructor & Destructor Documentation

externalgen::StreamCache::StreamCache	(	const std::string &	iConfig,
		int	id,
		bool	verbose,
		unsigned int	waitTime
	)

inline

Definition at line 35 of file ExternalGeneratorFilter.cc.

References KineDebug3::count(), callgraph::path, sistrip::pipe_, mps_fire::result, alignCSCRings::s, mps_setup::stdout, and AlCaHLTBitMon_QueryRunRegistry::string.

         : id_{id},
           channel_("extGen", id_, waitTime),
           readBuffer_{channel_.sharedMemoryName(), channel_.fromWorkerBufferInfo()},
           writeBuffer_{std::string("Rand") + channel_.sharedMemoryName(), channel_.toWorkerBufferInfo()},
           deserializer_{readBuffer_},
           er_deserializer_{readBuffer_},
           bl_deserializer_{readBuffer_},
           el_deserializer_(readBuffer_),
           randSerializer_(writeBuffer_) {
       //make sure output is flushed before popen does any writing
       fflush(stdout);
       fflush(stderr);
 
       channel_.setupWorker([&]() {
         using namespace std::string_literals;
         using namespace boost::filesystem;
         edm::LogSystem("ExternalProcess") << id_ << " starting external process \n";
         std::string verboseCommand;
         if (verbose) {
           verboseCommand = "--verbose ";
         }
         auto curDir = current_path();
         auto newDir = path("thread"s + std::to_string(id_));
         create_directory(newDir);
         current_path(newDir);
         pipe_ =
             popen(("cmsExternalGenerator "s + verboseCommand + channel_.sharedMemoryName() + " " + channel_.uniqueID())
                       .c_str(),
                   "w");
         current_path(curDir);
 
         if (nullptr == pipe_) {
           abort();
         }
 
         {
           auto nlines = std::to_string(std::count(iConfig.begin(), iConfig.end(), '\n'));
           auto result = fwrite(nlines.data(), sizeof(char), nlines.size(), pipe_);
           assert(result = nlines.size());
           result = fwrite(iConfig.data(), sizeof(char), iConfig.size(), pipe_);
           assert(result == iConfig.size());
           fflush(pipe_);
         }
       });
     }

externalgen::StreamCache::~StreamCache ( )

inline

Definition at line 123 of file ExternalGeneratorFilter.cc.

References sistrip::pipe_.

                    {
       channel_.stopWorker();
       pclose(pipe_);
     }

Member Function Documentation

ExternalGeneratorLumiInfo externalgen::StreamCache::beginLumiProduce	(	unsigned long long	iTransitionID,
		edm::RandomNumberGeneratorState const &	iState
	)

inline

Definition at line 109 of file ExternalGeneratorFilter.cc.

References edm::BeginLuminosityBlock.

                                                                                             {
       //NOTE: root serialize requires a `void*` not a `void const*` even though it doesn't modify the object
       randSerializer_.serialize(const_cast<edm::RandomNumberGeneratorState&>(iState));
       return doTransition(bl_deserializer_, edm::Transition::BeginLuminosityBlock, iTransitionID);
     }

template<typename SERIAL >

auto externalgen::StreamCache::doTransition	(	SERIAL &	iDeserializer,
		edm::Transition	iTrans,
		unsigned long long	iTransitionID
	)		-> decltype(iDeserializer.deserialize())

inline

Definition at line 83 of file ExternalGeneratorFilter.cc.

References Exception, and relativeConstraints::value.

                                                  {
       decltype(iDeserializer.deserialize()) value;
       if (not channel_.doTransition(
               [&value, &iDeserializer]() { value = iDeserializer.deserialize(); }, iTrans, iTransitionID)) {
         externalFailed_ = true;
         throw cms::Exception("ExternalFailed") << "failed waiting for external process";
       }
       return value;
     }

std::optional<GenLumiInfoProduct> externalgen::StreamCache::endLumiProduce ( unsigned long long iTransitionID )

inline

Definition at line 116 of file ExternalGeneratorFilter.cc.

References edm::EndLuminosityBlock.

                                                                                      {
       if (not externalFailed_) {
         return doTransition(el_deserializer_, edm::Transition::EndLuminosityBlock, iTransitionID);
       }
       return {};
     }

std::optional<GenRunInfoProduct> externalgen::StreamCache::endRunProduce ( unsigned long long iTransitionID )

inline

Definition at line 102 of file ExternalGeneratorFilter.cc.

References edm::EndRun.

                                                                                    {
       if (not externalFailed_) {
         return doTransition(er_deserializer_, edm::Transition::EndRun, iTransitionID);
       }
       return {};
     }

ExternalGeneratorEventInfo externalgen::StreamCache::produce	(	edm::StreamID	iStream,
		unsigned long long	iTransitionID
	)

inline

Definition at line 93 of file ExternalGeneratorFilter.cc.

References edm::Event, relval_steps::gen(), and edm::RandomNumberGenerator::getEngine().

                                                                                               {
       edm::Service<edm::RandomNumberGenerator> gen;
       auto& engine = gen->getEngine(iStream);
       edm::RandomNumberGeneratorState state{engine.put(), engine.getSeed()};
       randSerializer_.serialize(state);
 
       return doTransition(deserializer_, edm::Transition::Event, iTransitionID);
     }

std::string externalgen::StreamCache::unique_name ( std::string iBase )

inlineprivate

Definition at line 129 of file ExternalGeneratorFilter.cc.

References sysUtil::pid.

                                            {
       auto pid = getpid();
       iBase += std::to_string(pid);
       iBase += "_";
       iBase += std::to_string(id_);
 
       return iBase;
     }