RT CPU: flush scene objects pending deletion when rendering is paused

Author: howetuft

include/slg/engines/rtpathcpu/rtpathcpu.h

@@ -58,7 +58,7 @@ class RTPathCPUSampler;
 class RTPathCPURenderEngine : public PathCPURenderEngine {
 public:
 	RTPathCPURenderEngine(RenderConfigRef cfg);
-	~RTPathCPURenderEngine();
+	virtual ~RTPathCPURenderEngine() = default;
 
 	virtual RenderEngineType GetType() const { return GetObjectType(); }
 	virtual std::string GetTag() const { return GetObjectTag(); }
@@ -80,15 +80,11 @@ class RTPathCPURenderEngine : public PathCPURenderEngine {
 	friend class RTPathCPURenderThread;
 	friend class RTPathCPUSampler;
 
-    struct completion_t {
-        void operator()() noexcept { }
-    };
-
 protected:
 	static luxrays::PropertiesUPtr GetDefaultProps();
 
 	virtual bool IsRTMode() const { return true; }
-	
+
 	CPURenderThreadUPtr NewRenderThread(const u_int index,
 			luxrays::IntersectionDevice *device) {
 		return std::make_unique<RTPathCPURenderThread>(this, index, device);
@@ -113,10 +109,12 @@ class RTPathCPURenderEngine : public PathCPURenderEngine {
 
 	std::mutex firstFrameMutex;
     std::condition_variable firstFrameCondition;
-	u_int firstFrameThreadDoneCount;
+	std::atomic<u_int> firstFrameThreadDoneCount;
 	bool firstFrameDone;
 
-	std::barrier<completion_t> *threadsSyncBarrier;
+	using CompletionFunction = std::function<void()>;
+	std::unique_ptr<std::barrier<CompletionFunction>> threadsSyncBarrier;  // General sync
+	std::unique_ptr<std::barrier<CompletionFunction>> threadsPauseBarrier;  // Dedicated to pause event
 	std::atomic<bool> threadsPauseMode;
 };
 

include/slg/scene/scene.h

@@ -262,7 +262,7 @@ class Scene {
 	void SetEnableParsePrint(bool status) { enableParsePrint = status; }
 
 	void moveToTrash(luxrays::NamedObjectUPtr&&);
-	void emptyTrash();
+	void EmptyTrash();
 
 	// Serialization
 	static SceneUPtr LoadSerialized(const std::string &fileName);

src/slg/engines/rtpathcpu/rtpathcpu.cpp

@@ -19,6 +19,8 @@
 #include "slg/slg.h"
 #include "slg/samplers/rtpathcpusampler.h"
 #include <memory>
+#include <barrier>
+#include <csignal>
 #include "slg/engines/rtpathcpu/rtpathcpu.h"
 
 using namespace std;
@@ -29,15 +31,26 @@ using namespace slg;
 // RTPathCPURenderEngine
 //------------------------------------------------------------------------------
 
+
 RTPathCPURenderEngine::RTPathCPURenderEngine(RenderConfigRef rcfg) :
 		PathCPURenderEngine(rcfg) {
-	threadsSyncBarrier = new std::barrier(renderThreads.size() + 1, completion_t());
-}
 
-RTPathCPURenderEngine::~RTPathCPURenderEngine() {
-	delete threadsSyncBarrier;
+	auto nullHandler = [&]() noexcept {
+	};
+
+	auto onPause = [&]() noexcept {
+		renderConfig.GetScene().EmptyTrash();
+	};
+
+	threadsSyncBarrier = std::make_unique<std::barrier<CompletionFunction>>(
+		renderThreads.size() + 1, nullHandler
+	);
+	threadsPauseBarrier = std::make_unique<std::barrier<CompletionFunction>>(
+		renderThreads.size() + 1, onPause
+	);
 }
 
+
 void RTPathCPURenderEngine::StartLockLess() {
 	auto& cfg = renderConfig.GetConfig();
 	zoomFactor = (u_int)Max(1, cfg.Get(GetDefaultProps()->Get("rtpathcpu.zoomphase.size")).Get<int>());
@@ -70,7 +83,7 @@ void RTPathCPURenderEngine::PauseThreads() {
 	threadsPauseMode = true;
 
 	// Wait for the threads
-	threadsSyncBarrier->arrive_and_wait();
+	threadsPauseBarrier->arrive_and_wait();
 }
 
 void RTPathCPURenderEngine::ResumeThreads() {

src/slg/engines/rtpathcpu/rtpathcputhread.cpp

@@ -36,8 +36,7 @@ RTPathCPURenderThread::RTPathCPURenderThread(RTPathCPURenderEngine *engine, cons
 	PathCPURenderThread(engine, index, device) {
 }
 
-RTPathCPURenderThread::~RTPathCPURenderThread() {
-}
+RTPathCPURenderThread::~RTPathCPURenderThread() = default;
 
 void RTPathCPURenderThread::StartRenderThread() {
 	// Avoid to allocate the film thread because I'm going to use the global one
@@ -83,7 +82,7 @@ void RTPathCPURenderThread::RTRenderFunc(std::stop_token stop_token) {
 		// Check if we are in pause or edit mode
 		if (engine->threadsPauseMode) {
 			// Synchronize all threads -> This waits for RTPathCPURenderEngine::PauseThreads()
-			engine->threadsSyncBarrier->arrive_and_wait();
+			engine->threadsPauseBarrier->arrive_and_wait();
 
 			while (!stop_token.stop_requested() && engine->threadsPauseMode)
 				std::this_thread::sleep_for(100ms);

src/slg/scene/scene.cpp

@@ -462,7 +462,7 @@ void Scene::moveToTrash(NamedObjectUPtr&& oldObj) {
 }
 
 
-void Scene::emptyTrash() {
+void Scene::EmptyTrash() {
 	std::lock_guard lk(trashMtx);
 	trashBin.clear();
 }