A worker thread with OpenGL support, am I doing it right?

[jelko]

Ik work on an application where it's possible to load very large CAD files, loading can take quite some time, so to keep the UI responsive loading is done in a workerthread.
The workerthread requires an active OpenGL context as well, so it can upload vertexbuffers to the GPU. I came up with the following solution.

- in main thread first make current context not current
- store pointer to surface
- create Worker Object and pass pointers to surface and context
- change thread affinity of context (moveToThread)
- start workerthread
- make context current in workerthread
- do work
- when work is finished call doneCurrent (make not current)
- restore thread affinity
- make context active again in main thread

It requires some hassle but it works, I am wondering how other applications deal with this problem?

/// <summary>Starts a workerthread and handles its progress events</summary>
int ProgressHandler::handleWork(boost::function<int(void)>& functor, bool requiresRenderContext/* = false*/)
{
	// careful only call this method from the main thread
	//ASSERT(GetCurrentThreadId() == theApp.GetThreadId());
 
	QOpenGLContext* context = nullptr;
	QSurface* surface = nullptr;
 
	// make current OpenGL context not current if required, this is needed to be able to make it current in the workerthread
	if (requiresRenderContext)
	{
		context = QOpenGLContext::currentContext();
		surface = context->surface();
		context->doneCurrent();
	}
 
	// create a Worker object
	int result = 0;
	deskproto::Worker work(functor, result, context, surface);
	context->moveToThread(&work);
 
	connect(&work, &QThread::finished, this, &ProgressHandler::onWorkerFinished);
 
	// start workerthread
	work.start();
 
	// enter modal loop
	m_progressDialog.exec();
 
	// wait until thread finishes
	work.wait();
 
	// make RenderContext current again for main thread
	if (requiresRenderContext)
	{
		bool result = context->makeCurrent(surface);
		assert(result);
	}
 
	// re-throw any uncaught exception in main thread
	work.rethrow();
 
	return result;
}

/// <summary>Starts a workerthread and handles its progress events</summary>
int ProgressHandler::handleWork(boost::function<int(void)>& functor, bool requiresRenderContext/* = false*/)
{
	// careful only call this method from the main thread
	//ASSERT(GetCurrentThreadId() == theApp.GetThreadId());
	
	QOpenGLContext* context = nullptr;
	QSurface* surface = nullptr;

	// make current OpenGL context not current if required, this is needed to be able to make it current in the workerthread
	if (requiresRenderContext)
	{
		context = QOpenGLContext::currentContext();
		surface = context->surface();
		context->doneCurrent();
	}

	// create a Worker object
	int result = 0;
	deskproto::Worker work(functor, result, context, surface);
	context->moveToThread(&work);
	
	connect(&work, &QThread::finished, this, &ProgressHandler::onWorkerFinished);

	// start workerthread
	work.start();

	// enter modal loop
	m_progressDialog.exec();

	// wait until thread finishes
	work.wait();

	// make RenderContext current again for main thread
	if (requiresRenderContext)
	{
		bool result = context->makeCurrent(surface);
		assert(result);
	}

	// re-throw any uncaught exception in main thread
	work.rethrow();

	return result;
}

To copy to clipboard, switch view to plain text mode 

/// <summary>
	/// SwapContext allows to make an OpenGL context active for a different thread without changing the function
	/// e.g. used for loading 3D geometry, plotdata and bitmapdata in a workerthread (functions which require an active OpenGL context)
	/// </summary>
	void Worker::run()
	{
	#ifdef _DEBUG
		util::SetThreadName("Worker");
	#endif
 
		// Make context active for current thread, only works if previous context is made not current
		if (m_context)
		{
			m_context->makeCurrent(m_surface);
		}
 
		try
		{
			// Call the functor object
			m_result = m_functor();
		}
		catch(...)
		{
			// catch any uncaught exceptions and re-trow them on main thread			
			Worker::m_exception	= std::current_exception();
		}
 
		// Make context not current(restore)
		if (m_context)
		{
			m_context->doneCurrent();
			m_context->moveToThread(QApplication::instance()->thread());
		}
	}

/// <summary>
	/// SwapContext allows to make an OpenGL context active for a different thread without changing the function
	/// e.g. used for loading 3D geometry, plotdata and bitmapdata in a workerthread (functions which require an active OpenGL context)
	/// </summary>
	void Worker::run()
	{
	#ifdef _DEBUG
		util::SetThreadName("Worker");
	#endif

		// Make context active for current thread, only works if previous context is made not current
		if (m_context)
		{
			m_context->makeCurrent(m_surface);
		}

		try
		{
			// Call the functor object
			m_result = m_functor();
		}
		catch(...)
		{
			// catch any uncaught exceptions and re-trow them on main thread			
			Worker::m_exception	= std::current_exception();
		}

		// Make context not current(restore)
		if (m_context)
		{
			m_context->doneCurrent();
			m_context->moveToThread(QApplication::instance()->thread());
		}
	}

To copy to clipboard, switch view to plain text mode 

[wysota]

Why not load all the data in a worker thread and then push it to the GPU in the main thread?

[jelko]

That is to keep the GUI thread responsive, uploading the vertex buffers to the GPU might take 5 - 6 seconds as wel (depending on your machine).

[wysota]

Then I don't see how you can improve what you already have