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 32 of file ExternalGeneratorFilter.cc.

Member Typedef Documentation

◆ Deserializer

template<typename T >

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

private

Definition at line 144 of file ExternalGeneratorFilter.cc.

Constructor & Destructor Documentation

◆ StreamCache()

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

inline

Definition at line 33 of file ExternalGeneratorFilter.cc.

         : 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 std::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_);
         }
       });
     }

◆ ~StreamCache()

externalgen::StreamCache::~StreamCache ( )

inline

Definition at line 122 of file ExternalGeneratorFilter.cc.

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

References sistrip::pipe_.

Member Function Documentation

◆ beginLumiProduce()

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

inline

Definition at line 108 of file ExternalGeneratorFilter.cc.

                                                                                             {
       //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);
     }

References edm::BeginLuminosityBlock.

◆ doTransition()

template<typename SERIAL >

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

inline

Definition at line 81 of file ExternalGeneratorFilter.cc.

                                                  {
       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. Timed out after " << channel_.maxWaitInSeconds() << " seconds.";
       }
       return value;
     }

References Exception, and relativeConstraints::value.

◆ endLumiProduce()

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

inline

Definition at line 115 of file ExternalGeneratorFilter.cc.

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

References edm::EndLuminosityBlock.

◆ endRunProduce()

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

inline

Definition at line 101 of file ExternalGeneratorFilter.cc.

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

References edm::EndRun.

◆ produce()

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

inline

Definition at line 92 of file ExternalGeneratorFilter.cc.

                                                                                               {
       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);
     }

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

◆ unique_name()

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

inlineprivate

Definition at line 128 of file ExternalGeneratorFilter.cc.

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