The general concept can be illustrated in this amazing diagram I drew in MS Paint.<\/p>\n
There’s two layers of parallelism in my current system, with the ability to add more later as time and performance dictate. \u00a0The first layer is to put the actual rendering on a separate thread that constantly loops, consuming the last command list buffer sent to it. \u00a0That was the basis of Reggie’s talk and has been a common technique for a while. \u00a0The second layer is to utilize deferred contexts to build the command lists for each pass process in parallel, and is the basic implementation discussed in\u00a0Bryan Dudash’s GDC presentation. \u00a0Of course, currently I’m only utilizing those two layers to draw a triangle into a render target and then composite that render target into the final presentation buffer, which is super impressive and all, but it provides a successful proof of concept that I can move forward from.<\/p>\n GoodGraphics26.png, a triangle is reborn!<\/p><\/div>\n It turns out that DX11 does a pretty great job of keeping itself thread-safe as long as you don’t try to utilize a single context over two threads, so the major task in getting this working was in keeping my own data thread-safe. \u00a0This necessitated three things: a simple public interface into the renderer, a transfer system for the command list buffers, and a transfer system for entities and assets. \u00a0The public interface was simple once I refactored and reorganized my classes, and now allows the renderer to run as a standalone library, fulfilling one of my major initial desires with this refactor.<\/p>\n The command list buffer is a read\/write\/pivot transfer system where the gameloop side copies to the write buffer, the renderloop side copies from the read buffer, and any copy causes a swap between the target buffer and the pivot. \u00a0This does introduce a lock into the system, but I used a Benaphore<\/a> to keep it as lightweight as possible. Here’s the code:<\/p>\n The entity\/asset system was by far the most complicated to implement, but it came down to a single container class that enqueued data changes (add, update, or remove) until a synchronization was called. \u00a0Here is the code:<\/p>\n And that’s how I solved my big thread-safety issue. The FAQ at the top of the file is worth reading, and while I’m preplanning for t_id to be some kind of GUID functor, I’m just using unsigned int for that type in all cases right now. I welcome any questions, comments, or criticisms of my methodology, but try not to be too hard on me as this is the first time I’ve actually posted code I’ve written.<\/p>\n But that’s all for now. Like I said, I’ve actually managed to take the system much further in the last week, but I’m just swamped right now. \u00a0Hopefully I’ll have time to make the next post before that information is also out of date, but no promises.<\/p>\n","protected":false},"excerpt":{"rendered":" It’s a new school year, and my senior year, so of course I decided that the most reasonable course of action was to put together a new team to build a new game in a new custom engine. \u00a0And I’d heavily rebuild my rendering system, too! \u00a0I’m smart like that. \u2026 Continue reading ![\"MTRenderingDiagram\"](\"http:\/\/www.teamfizzgames.com\/Matt\/wp-content\/uploads\/2013\/09\/MTRenderingDiagram-1024x576.png\")
<\/a><\/p>\n![\"\"](\"http:\/\/www.anguishgames.com\/download\/images\/GoodGraphics26.png\")
<\/a>\/*\r\nProject: Graphics\r\nPurpose: Declaration of the command list buffer container\r\nCoder\/s: Matt Sutherlin (matt.sutherlin@digipen.edu)\r\nCopyright: \u201cAll content \u00a9 2013 DigiPen (USA) Corporation, all rights reserved.\u201d\r\n*\/\r\n\r\n#pragma once\r\n\r\n#include "..\/Definitions\/ProcessEnums.hpp"\r\n#include "..\/Definitions\/DirectXIncludes.hpp"\r\n#include "..\/Renderer\/Benaphore.hpp"\r\n\r\nstruct CommandListLayer\r\n{\r\n CommandListLayer() {\r\n m_bIsDirty = false;\r\n\r\n for (unsigned lI = 0; lI < Passes::NumberOf; ++lI)\r\n {\r\n m_commandLists[lI] = nullptr;\r\n }\r\n }\r\n ~CommandListLayer() {\r\n for (unsigned lI = 0; lI < Passes::NumberOf; ++lI)\r\n {\r\n SAFE_RELEASE(m_commandLists[lI]);\r\n }\r\n }\r\n\r\n bool m_bIsDirty;\r\n ID3D11CommandList* m_commandLists[Passes::NumberOf];\r\n};\r\n\r\nclass CommandListBuffer\r\n{\r\npublic:\r\n CommandListBuffer() {\r\n for (unsigned lI = 0; lI < CommandListLayers::NumberOf; ++lI)\r\n {\r\n m_layers[lI] = new CommandListLayer();\r\n }\r\n }\r\n ~CommandListBuffer() {\r\n for (unsigned lI = 0; lI < CommandListLayers::NumberOf; ++lI)\r\n {\r\n delete m_layers[lI];\r\n }\r\n }\r\n ID3D11CommandList** GetLayerCommandLists(CommandListLayers::Layer pLayer) {\r\n if (pLayer == CommandListLayers::Read)\r\n {\r\n m_lock.Lock();\r\n\r\n if (m_layers[CommandListLayers::Pivot]->m_bIsDirty)\r\n {\r\n m_layers[CommandListLayers::Read]->m_bIsDirty = false;\r\n\r\n std::swap(m_layers[CommandListLayers::Read], m_layers[CommandListLayers::Pivot]);\r\n }\r\n\r\n m_lock.Unlock();\r\n }\r\n\r\n return m_layers[pLayer]->m_commandLists;\r\n }\r\n void SwapWriteLayer() {\r\n m_lock.Lock();\r\n\r\n m_layers[CommandListLayers::Write]->m_bIsDirty = true;\r\n\r\n std::swap(m_layers[CommandListLayers::Write], m_layers[CommandListLayers::Pivot]);\r\n\r\n m_lock.Unlock();\r\n }\r\nprivate:\r\n CommandListLayer* m_layers[CommandListLayers::NumberOf];\r\n Benaphore m_lock;\r\n};<\/pre>\n\/*\r\nProject: Graphics\r\nPurpose: Declaration of the transfer buffer container\r\nCoder\/s: Matt Sutherlin (matt.sutherlin@digipen.edu)\r\nCopyright: \u201cAll content \u00a9 2013 DigiPen (USA) Corporation, all rights reserved.\u201d\r\n*\/\r\n\r\n#pragma once\r\n\r\n#include <unordered_map>\r\n#include <queue>\r\n#include <type_traits>\r\n\r\n\/\/Q01: How does this work?\r\n\/\/A01: The game engine could potentially make requests for adding, removing, or\r\n\/\/ deleting resources at any time. While the ID3D11Device is thread-free, we \r\n\/\/ still need to be careful with resource management.\r\n\/\/\r\n\/\/ Adds can create their new resources immediately (and need to do so to return \r\n\/\/ a resource ID to the caller), but should not be added to traversal lists \r\n\/\/ while process threads are running. So we defer that until the next game loop.\r\n\/\/\r\n\/\/ Updates should only occur at the start of a new game loop, so they're deferred \r\n\/\/ until the game thread calls for a synch. We need to ensure the data we're \r\n\/\/ traversing doesn't get changed out from under us, so we synch this before \r\n\/\/ producer threads start for the frame.\r\n\/\/\r\n\/\/ Deletes have two levels of synchronization to deal with. Removing the resource \r\n\/\/ from traversal lists needs to happen at the next game loop and removing it \r\n\/\/ from memory needs to happen at the next render loop after that.\r\n\/\/\r\n\/\/Q02: What are the limitations?\r\n\/\/A02: t_entry objects need to have an UpdateData function, and that function needs to \r\n\/\/ take a t_data object.\r\n\/\/\r\n\/\/ t_id objects need to be able to be initialized by setting = 0, and need to \r\n\/\/ properly increment when post-incremented.\r\n\/\/\r\n\/\/ t_entry and t_data objects MUST be pointer types.\r\n\r\ntemplate <typename t_entry, typename t_data, typename t_id>\r\nclass TransferBuffer\r\n{\r\n typedef std::pair<t_id, t_entry> t_entryPair;\r\n typedef std::pair<t_id, t_data> t_dataPair;\r\n typedef typename std::unordered_map<t_id, t_entry>::iterator t_iterator;\r\nprivate:\r\n std::unordered_map<t_id, t_entry> m_entries;\r\n std::queue<t_entryPair> m_pendingAdditions;\r\n std::queue<t_id> m_markedDeletions;\r\n std::queue<t_entry> m_pendingDeletions;\r\n std::queue<t_dataPair> m_pendingUpdates;\r\n t_id m_nextID;\r\npublic:\r\n TransferBuffer() {\r\n m_nextID = 0;\r\n }\r\n\r\n ~TransferBuffer() {\r\n\r\n }\r\n\r\n \/\/This should only ever be called by the game engine!\r\n t_id AddEntry(t_data pData) {\r\n t_id lReturnID = m_nextID++;\r\n\r\n t_entry lEntry = new std::remove_pointer<t_entry>::type(pData);\r\n m_pendingAdditions.push(t_entryPair(lReturnID, lEntry));\r\n\r\n return lReturnID;\r\n }\r\n\r\n \/\/This should only ever be called by the game engine!\r\n void RemoveEntry(t_id pID) {\r\n m_markedDeletions.push(pID);\r\n }\r\n\r\n \/\/This should only ever be called by the game engine!\r\n void UpdateEntry(t_id pID, t_data pData) {\r\n t_data lData = new std::remove_pointer<t_data>::type();\r\n memcpy(lData, pData, sizeof(std::remove_pointer<t_data>::type));\r\n\r\n m_pendingUpdates.push(t_dataPair(pID, lData));\r\n }\r\n\r\n \/\/This should only ever be called by parallel producer threads!\r\n t_iterator GetEntries() {\r\n return m_entries.begin();\r\n }\r\n\r\n t_iterator GetEnd() {\r\n return m_entries.end();\r\n }\r\n\r\n \/\/This should only ever be called by the synchronous game thread!\r\n \/\/Should get called once per game loop before threading deferred contexts\r\n void SynchAdd() {\r\n unsigned lSizeAdditions = m_pendingAdditions.size();\r\n\r\n for (unsigned lI = 0; lI < lSizeAdditions; ++lI)\r\n {\r\n t_entryPair lEntryPair = m_pendingAdditions.front();\r\n m_pendingAdditions.pop();\r\n m_entries.emplace(lEntryPair.first, lEntryPair.second);\r\n }\r\n }\r\n\r\n \/\/This should only ever be called by the synchronous game thread!\r\n \/\/Should get called directly after SynchAdd\r\n void SynchUpdate() {\r\n unsigned lSizeUpdates = m_pendingUpdates.size();\r\n\r\n for (unsigned lI = 0; lI < lSizeUpdates; ++lI)\r\n {\r\n t_dataPair lDataPair = m_pendingUpdates.front();\r\n m_pendingUpdates.pop();\r\n\r\n auto lIter = m_entries.find(lDataPair.first);\r\n\r\n if (lIter != m_entries.end())\r\n {\r\n lIter->second->UpdateData(lDataPair.second);\r\n delete lDataPair.second;\r\n }\r\n }\r\n }\r\n\r\n \/\/This should only ever be called by synchronous game thread!\r\n \/\/Should get called directly after SynchUpdate\r\n void SynchMarkedDelete() {\r\n unsigned lSizeDeletions = m_markedDeletions.size();\r\n\r\n for (unsigned lI = 0; lI < lSizeDeletions; ++lI)\r\n {\r\n t_id lID = m_markedDeletions.front();\r\n m_markedDeletions.pop();\r\n\r\n auto lIter = m_entries.find(lID);\r\n\r\n if (lIter != m_entries.end())\r\n {\r\n t_entry lEntry = lIter->second;\r\n m_pendingDeletions.push(lEntry);\r\n m_entries.erase(lIter);\r\n }\r\n }\r\n }\r\n\r\n \/\/This should only ever be called by the parallel consumer thread!\r\n \/\/Should only get called at the start of a render loop\r\n void SynchPendingDelete() {\r\n unsigned lSizeDeletions = m_pendingDeletions.size();\r\n\r\n for (unsigned lI = 0; lI < lSizeDeletions; ++lI)\r\n {\r\n t_entry lEntry = m_pendingDeletions.front();\r\n m_pendingDeletions.pop();\r\n delete lEntry;\r\n }\r\n }\r\n};<\/pre>\n