init root files

Author: maureeungaro

gstreamer/examples/gstreamer_example.cc

@@ -117,15 +117,15 @@ auto build_event(int
 // Multithreaded driver
 // Each thread repeatedly grabs the next event number from an atomic counter
 // -----------------------------------------------------------------------------
-void run_simulation(int                                                                           nevents,
-                    int                                                                           nthreads,
-                    const std::shared_ptr<GLogger>&                                               logs,
-                    const std::shared_ptr<GLogger>&                                               loge,
-                    const std::shared_ptr<GLogger>&                                               logt,
-                    const std::unordered_map<std::string, std::shared_ptr<GDynamicDigitization>>& dynamicRoutinesMap,
-                    GOptions*                                                                     gopt,
-                    std::vector<std::unique_ptr<GEventDataCollection>>&                           runData,
-                    std::mutex&                                                                   runDataMtx) {
+void run_simulation(int                                                                            nevents,
+                    int                                                                            nthreads,
+                    const std::shared_ptr<GLogger>&                                                logs,
+                    const std::shared_ptr<GLogger>&                                                loge,
+                    const std::shared_ptr<GLogger>&                                                logt,
+                    const std::unordered_map<std::string, std::shared_ptr<GDynamicDigitization>>&  dynamicRoutinesMap,
+                    const std::vector<std::unordered_map<std::string, std::shared_ptr<GStreamer>>> streamers,
+                    std::vector<std::unique_ptr<GEventDataCollection>>&                            runData,
+                    std::mutex&                                                                    runDataMtx) {
 	// thread-safe integer counter starts at 1.
 	// fetch_add returns the old value *and* bumps.
 	// Zero contention: each thread fetches the next free event number.
@@ -155,12 +155,11 @@ void run_simulation(int
 			logs->info(0, "worker ", tid, " started");
 
 			int localCount = 0; // events built by *this* worker
+			// get streamer for this thread
+			const auto& streamersMap = streamers[tid]; // get the map of gstreamers for this thread
 
-			auto gstreamer_defs = gstreamer::getGStreamerDefinition(gopt); // get the vector of GStreamerDefinition from options
-			const auto& streamers = gstreamer::gstreamersMap(gstreamer_defs, tid, gopt, logs ); // all gstreamers for this thread
 
 			while (true) {
-
 				// repeatedly asks the shared atomic counter for “the next unclaimed event
 				// number,” processes that event, stores the result, and goes back for more.
 				// memory_order_relaxed: we only need *atomicity*, no ordering
@@ -200,17 +199,11 @@ void run_simulation(int
 }
 
 
-#include "TROOT.h"
-#include "TSystem.h"
 
 // notice runData is not really used here, but we keep the code as reference on how to accumulate
 // events in a thread-safe way into a shared vector.
 int main(int argc, char* argv[]) {
 
-	// Trigger interpreter and global dictionary setup
-	TClass::GetClass("TObject");  // this is a safe no-op that triggers interpreter init
-	gSystem->Load("libCore");     // optional: explicitly load libraries
-
 	// runData holds the finished events.  We store them as *unique_ptr* because
 	// each event is owned by the container and *only* by the container (single
 	// ownership → choose unique_ptr, not shared_ptr).
@@ -239,9 +232,12 @@ int main(int argc, char* argv[]) {
 	constexpr int nevents  = 200;
 	constexpr int nthreads = 8;
 
+	auto        gstreamer_defs = gstreamer::getGStreamerDefinition(gopts);                              // get the vector of GStreamerDefinition from options
+	const auto& streamers= gstreamer::gstreamersMapVector(gstreamer_defs, nthreads, gopts, logs); // all gstreamers for this thread
+
 	run_simulation(nevents, nthreads, logs, loge, loge,
 	               dynRoutinesConstMap,
-	               gopts,
+	               streamers,
 	               runData,
 	               runDataMtx);
 

gstreamer/factories/ROOT/gstreamerROOTConnection.cc

@@ -2,29 +2,51 @@
 #include "gstreamerROOTFactory.h"
 #include "gstreamerConventions.h"
 
+// root
+#include "TROOT.h"
+#include "TSystem.h"
+
+// c__
+#include <mutex> // for once_flag
+
+// Static member definition
+std::once_flag GstreamerRootFactory::rootInitFlag;
+
 bool GstreamerRootFactory::openConnectionImpl() {
 
+	// Trigger interpreter and global dictionary setup
+	// this needs to be called in the main thread before any ROOT objects are created
+	std::call_once(rootInitFlag, []() {
+		TClass::GetClass("TObject"); // triggers interpreter
+		gSystem->Load("libCore");    // optional
+		// log->info(0, "GstreamerRootFactory: ROOT interpreter initialized");
+	});
+
 	rootfile = std::make_unique<TFile>(filename().c_str(), "RECREATE");
 	rootfile->cd();
-	TDirectory::TContext ctx(rootfile.get());  // thread-local context
+	TDirectory::TContext ctx(rootfile.get()); // thread-local context
 
 	gRootTrees = new std::map<std::string, GRootTree*>;
 
-	if (!rootfile->IsOpen()) { log->error(ERR_CANTOPENOUTPUT, "GstreamerRootFactory: could not open file " + filename()); }
-	else { log->info(0, "GstreamerRootFactory: opened file " + filename()); }
+	if (!rootfile->IsOpen()) {
+		log->error(ERR_CANTOPENOUTPUT, "GstreamerRootFactory: could not open file " + filename());
+	}
+	else {
+		log->info(0, "GstreamerRootFactory: opened file " + filename());
+	}
 
 	return true;
 }
 
 bool GstreamerRootFactory::closeConnectionImpl() {
-	TDirectory::TContext ctx(rootfile.get());  // thread-local context
+	TDirectory::TContext ctx(rootfile.get()); // thread-local context
 
 	if (rootfile->IsOpen()) {
 		rootfile->Write();
 		rootfile->Close();
 	}
 
-	if ( rootfile->IsOpen() ) { log->error(ERR_CANTOPENOUTPUT, "GstreamerRootFactory: could not close file " + filename()); }
+	if (rootfile->IsOpen()) { log->error(ERR_CANTOPENOUTPUT, "GstreamerRootFactory: could not close file " + filename()); }
 
 	delete gRootTrees;
 

gstreamer/factories/ROOT/gstreamerROOTFactory.h

@@ -49,4 +49,6 @@ class GstreamerRootFactory : public GStreamer {
 	std::string filename() const override {
 		return gstreamer_definitions.rootname + ".root";
 	}
+
+	static std::once_flag rootInitFlag;
 };

gstreamer/gstreamer.h

@@ -155,6 +155,8 @@ class GStreamer {
 
 };
 
+
+
 namespace gstreamer {
 
 inline std::unordered_map<std::string, std::shared_ptr<GStreamer>> gstreamersMap(const std::vector<GStreamerDefinition>& goutput_defs,
@@ -186,5 +188,18 @@ inline std::unordered_map<std::string, std::shared_ptr<GStreamer>> gstreamersMap
 	return gstreamerConstMap;
 }
 
+// returns a vector of identical gstreamersMap the size of the number of threads
+inline std::vector<std::unordered_map<std::string, std::shared_ptr<GStreamer>>> gstreamersMapVector(const std::vector<GStreamerDefinition>& goutput_defs,
+																										   int                                     nthreads,
+																										   GOptions*                               gopts,
+																										   std::shared_ptr<GLogger>                log) {
+	std::vector<std::unordered_map<std::string, std::shared_ptr<GStreamer>>> gstreamersMaps;
+
+	for (int tid = 0; tid < nthreads; ++tid) {
+		gstreamersMaps.emplace_back(gstreamersMap(goutput_defs, tid, gopts, log));
+	}
+
+	return gstreamersMaps;
+}
 
 } // namespace gstreamer