AxioDL/boo
2
0
Fork 0
mirror of https://github.com/AxioDL/boo.git synced 2025-12-08 21:17:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

use hash table for pool buffers

Browse Source
This commit is contained in:
Jack Andersen
2016-12-10 20:18:41 -10:00
parent 25fadc7348
commit c057068e64
8 changed files with 118 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
lib/graphicsdev/D3D11.cpp
View File

@@ -59,22 +59,37 @@ struct D3D11Data : IGraphicsData
}
};
class D3D11GraphicsBufferD;
struct D3D11Pool : IGraphicsBufferPool
{
size_t m_deleteCountdown = 4;
std::vector<std::unique_ptr<class D3D11GraphicsBufferD>> m_DBufs;
bool decref()
struct Buffer
{
if (!m_deleteCountdown)
Log.report(logvisor::Fatal, "Can't decrement 0-data");
--m_deleteCountdown;
if (!m_deleteCountdown)
size_t m_deleteCountdown = 4;
std::unique_ptr<D3D11GraphicsBufferD> m_buf;
Buffer(D3D11GraphicsBufferD* buf) : m_buf(buf) {}
bool decref()
{
delete this;
return true;
if (!m_deleteCountdown)
Log.report(logvisor::Fatal, "Can't decrement 0-data");
--m_deleteCountdown;
if (!m_deleteCountdown)
{
delete this;
return true;
}
return false;
}
return false;
};
std::unordered_map<D3D11GraphicsBufferD*, Buffer*> m_DBufs;
void destroyPool(std::unordered_set<D3D11Pool::Buffer*>& delsOut)
{
for (auto& b : m_DBufs)
delsOut.emplace(b.second);
m_DBufs.clear();
}
};
@@ -1060,9 +1075,11 @@ void D3D11GraphicsBufferD::update(ID3D11DeviceContext* ctx, int b)
{
ID3D11Buffer* res = m_bufs[b].Get();
D3D11_MAPPED_SUBRESOURCE d;
ctx->Map(res, 0, D3D11_MAP_WRITE_DISCARD, 0, &d);
memcpy(d.pData, m_cpuBuf.get(), m_cpuSz);
ctx->Unmap(res, 0);
if (SUCCEEDED(ctx->Map(res, 0, D3D11_MAP_WRITE_DISCARD, 0, &d)))
{
memcpy(d.pData, m_cpuBuf.get(), m_cpuSz);
ctx->Unmap(res, 0);
}
m_validSlots |= slot;
}
}
@@ -1129,7 +1146,7 @@ class D3D11DataFactory : public ID3DDataFactory
std::unordered_set<D3D11Pool*> m_committedPools;
std::mutex m_committedMutex;
std::unordered_set<D3D11Data*> m_deletedData;
std::unordered_set<D3D11Pool*> m_deletedPools;
std::unordered_set<D3D11Pool::Buffer*> m_deletedPoolBufs;
uint32_t m_sampleCount;
void destroyData(IGraphicsData* d)
@@ -1146,7 +1163,7 @@ class D3D11DataFactory : public ID3DDataFactory
for (IGraphicsData* data : m_committedData)
m_deletedData.insert(static_cast<D3D11Data*>(data));
for (IGraphicsBufferPool* pool : m_committedPools)
m_deletedPools.insert(static_cast<D3D11Pool*>(pool));
static_cast<D3D11Pool*>(pool)->destroyPool(m_deletedPoolBufs);
m_committedData.clear();
m_committedPools.clear();
}
@@ -1156,7 +1173,7 @@ class D3D11DataFactory : public ID3DDataFactory
std::unique_lock<std::mutex> lk(m_committedMutex);
D3D11Pool* pool = static_cast<D3D11Pool*>(p);
m_committedPools.erase(pool);
m_deletedPools.insert(pool);
pool->destroyPool(m_deletedPoolBufs);
}
void procDeletes()
@@ -1171,12 +1188,12 @@ class D3D11DataFactory : public ID3DDataFactory
}
++it;
}
for (auto it = m_deletedPools.begin(); it != m_deletedPools.end();)
for (auto it = m_deletedPoolBufs.begin(); it != m_deletedPoolBufs.end();)
{
D3D11Pool* cpool = static_cast<D3D11Pool*>(*it);
D3D11Pool::Buffer* cpool = *it;
if (cpool->decref())
{
it = m_deletedPools.erase(it);
it = m_deletedPoolBufs.erase(it);
continue;
}
++it;
@@ -1189,10 +1206,21 @@ class D3D11DataFactory : public ID3DDataFactory
D3D11CommandQueue* q = static_cast<D3D11CommandQueue*>(m_parent->getCommandQueue());
D3D11Pool* pool = static_cast<D3D11Pool*>(p);
D3D11GraphicsBufferD* retval = new D3D11GraphicsBufferD(q, use, m_ctx, stride, count);
pool->m_DBufs.emplace_back(retval);
pool->m_DBufs.emplace(std::make_pair(retval, new D3D11Pool::Buffer(retval)));
return retval;
}
void deletePoolBuffer(IGraphicsBufferPool* p, IGraphicsBufferD* buf)
{
D3D11Pool* pool = static_cast<D3D11Pool*>(p);
auto search = pool->m_DBufs.find(static_cast<D3D11GraphicsBufferD*>(buf));
if (search != pool->m_DBufs.end())
{
m_deletedPoolBufs.emplace(search->second);
pool->m_DBufs.erase(search);
}
}
public:
D3D11DataFactory(IGraphicsContext* parent, D3D11Context* ctx, uint32_t sampleCount)
: m_parent(parent), m_ctx(ctx), m_sampleCount(sampleCount)
@@ -1404,8 +1432,8 @@ void D3D11CommandQueue::ProcessDynamicLoads(ID3D11DeviceContext* ctx)
}
for (D3D11Pool* p : gfxF->m_committedPools)
{
for (std::unique_ptr<D3D11GraphicsBufferD>& b : p->m_DBufs)
b->update(ctx, m_drawBuf);
for (auto& b : p->m_DBufs)
b.second->m_buf->update(ctx, m_drawBuf);
}
}

14
lib/graphicsdev/D3D12.cpp
View File

@@ -64,7 +64,7 @@ struct D3D12Pool : IGraphicsBufferPool
Buffer(ComPtr<ID3D12Heap>&& heap, class D3D12GraphicsBufferD* buf)
: m_bufHeap(std::move(heap)), m_buf(buf) {}
};
std::vector<Buffer> m_DBufs;
std::unordered_map<class D3D12GraphicsBufferD*, Buffer> m_DBufs;
};
static const D3D12_RESOURCE_STATES USE_TABLE[] =
@@ -1586,10 +1586,16 @@ class D3D12DataFactory : public ID3DDataFactory
/* Place resources */
PlaceBufferForGPU(retval, m_ctx, bufHeap.Get(), 0);
pool->m_DBufs.emplace_back(std::move(bufHeap), retval);
pool->m_DBufs.emplace(std::make_pair(retval, D3D12Pool::Buffer{std::move(bufHeap), retval}));
return retval;
}
void deletePoolBuffer(IGraphicsBufferPool* p, IGraphicsBufferD* buf)
{
D3D12Pool* pool = static_cast<D3D12Pool*>(p);
pool->m_DBufs.erase(static_cast<D3D12GraphicsBufferD*>(buf));
}
public:
D3D12DataFactory(IGraphicsContext* parent, D3D12Context* ctx, uint32_t sampleCount)
: m_parent(parent), m_ctx(ctx), m_sampleCount(sampleCount)
@@ -1893,8 +1899,8 @@ void D3D12CommandQueue::execute()
}
for (D3D12Pool* p : gfxF->m_committedPools)
{
for (D3D12Pool::Buffer& b : p->m_DBufs)
b.m_buf->update(m_fillBuf);
for (auto& b : p->m_DBufs)
b.second.m_buf->update(m_fillBuf);
}
datalk.unlock();

15
lib/graphicsdev/GL.cpp
View File

@@ -6,6 +6,7 @@
#include <mutex>
#include <condition_variable>
#include <array>
#include <unordered_map>
#include "logvisor/logvisor.hpp"
@@ -32,7 +33,7 @@ struct GLData : IGraphicsData
struct GLPool : IGraphicsBufferPool
{
std::vector<std::unique_ptr<class GLGraphicsBufferD>> m_DBufs;
std::unordered_map<class GLGraphicsBufferD*, std::unique_ptr<class GLGraphicsBufferD>> m_DBufs;
};
static const GLenum USE_TABLE[] =
@@ -738,10 +739,16 @@ IGraphicsBufferD* GLDataFactory::newPoolBuffer(IGraphicsBufferPool* p, BufferUse
{
GLPool* pool = static_cast<GLPool*>(p);
GLGraphicsBufferD* retval = new GLGraphicsBufferD(use, stride * count);
pool->m_DBufs.emplace_back(retval);
pool->m_DBufs.emplace(std::make_pair(retval, retval));
return retval;
}
void GLDataFactory::deletePoolBuffer(IGraphicsBufferPool *p, IGraphicsBufferD *buf)
{
GLPool* pool = static_cast<GLPool*>(p);
pool->m_DBufs.erase(static_cast<GLGraphicsBufferD*>(buf));
}
static const GLint SEMANTIC_COUNT_TABLE[] =
{
0,
@@ -1297,8 +1304,8 @@ struct GLCommandQueue : IGraphicsCommandQueue
}
for (GLPool* p : gfxF->m_committedPools)
{
for (std::unique_ptr<GLGraphicsBufferD>& b : p->m_DBufs)
b->update(m_completeBuf);
for (auto& b : p->m_DBufs)
b.second->update(m_completeBuf);
}
datalk.unlock();
glFlush();

20
lib/graphicsdev/Vulkan.cpp
View File

@@ -687,14 +687,14 @@ struct VulkanPool : IGraphicsBufferPool
Buffer(VkDeviceMemory mem, class VulkanGraphicsBufferD* buf)
: m_bufMem(mem), m_buffer(buf) {}
};
std::vector<Buffer> m_DBufs;
std::unordered_map<class VulkanGraphicsBufferD*, Buffer> m_DBufs;
bool m_dead = false;
VulkanPool(VulkanContext* ctx) : m_ctx(ctx) {}
~VulkanPool()
{
for (Buffer& buf : m_DBufs)
if (buf.m_bufMem)
vk::FreeMemory(m_ctx->m_dev, buf.m_bufMem, nullptr);
for (auto& buf : m_DBufs)
if (buf.second.m_bufMem)
vk::FreeMemory(m_ctx->m_dev, buf.second.m_bufMem, nullptr);
}
};
@@ -3221,10 +3221,16 @@ IGraphicsBufferD* VulkanDataFactory::newPoolBuffer(IGraphicsBufferPool* p, Buffe
retval->placeForGPU(m_ctx, bufMem);
}
pool->m_DBufs.emplace_back(bufMem, retval);
pool->m_DBufs.emplace(std::make_pair(retval, VulkanPool::Buffer{bufMem, retval}));
return retval;
}
void VulkanDataFactory::deletePoolBuffer(IGraphicsBufferPool* p, IGraphicsBufferD* buf)
{
VulkanPool* pool = static_cast<VulkanPool*>(p);
pool->m_DBufs.erase(static_cast<VulkanGraphicsBufferD*>(buf));
}
GraphicsBufferPoolToken VulkanDataFactory::newBufferPool()
{
std::unique_lock<std::mutex> lk(m_committedMutex);
@@ -3252,8 +3258,8 @@ void VulkanCommandQueue::execute()
}
for (VulkanPool* p : gfxF->m_committedPools)
{
for (VulkanPool::Buffer& b : p->m_DBufs)
b.m_buffer->update(m_fillBuf);
for (auto& b : p->m_DBufs)
b.second.m_buffer->update(m_fillBuf);
}
datalk.unlock();