EmaMaker
/
voxel-engine
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use concurrent_hash_map and parallel_for for chunk update 

memory VIRT is higher, RES is the same. memory usage stabilizes after a while
fix-multithread
EmaMaker 2023-10-01 19:45:51 +02:00
parent 49edf2de85
commit a05d019c69
3 changed files with 109 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/chunk.hpp
View File

@ -47,9 +47,11 @@ namespace Chunk
void deleteBuffers();
glm::vec3 getPosition() { return this->position; }
void setState(uint16_t nstate, bool value);
uint16_t getTotalState() { return this->state; }
bool getState(uint16_t n) { return (this->state & n) == n; }
void setState(uint16_t nstate, bool value);
bool isFree(){ return !(getState(CHUNK_STATE_IN_GENERATION_QUEUE) ||
getState(CHUNK_STATE_IN_MESHING_QUEUE)); }
void setBlock(Block b, int x, int y, int z);
void setBlocks(int start, int end, Block b);

7
include/chunkmanager.hpp
View File

@ -21,8 +21,10 @@
namespace chunkmanager
{
//typedef oneapi::tbb::concurrent_hash_map<uint32_t, Chunk::Chunk*> ChunkTable;
typedef std::unordered_map<int32_t, Chunk::Chunk*> ChunkTable;
typedef oneapi::tbb::concurrent_hash_map<uint32_t, Chunk::Chunk*> ChunkTable;
typedef oneapi::tbb::concurrent_queue<int> IntQueue;
//typedef std::unordered_map<int32_t, Chunk::Chunk*> ChunkTable;
typedef std::pair<Chunk::Chunk*, uint8_t> ChunkPQEntry;
// The comparing function to use
struct compare_f {
@ -38,7 +40,6 @@ namespace chunkmanager
void stop();
void destroy();
oneapi::tbb::concurrent_queue<Chunk::Chunk*>& getDeleteVector();
std::array<std::array<int16_t, 3>, chunks_volume>& getChunksIndices();
Block getBlockAtPos(int x, int y, int z);
void update();

83
src/chunkmanager.cpp
View File

@ -27,6 +27,8 @@ namespace chunkmanager
// Concurrent hash table of chunks
ChunkTable chunks;
// Concurrent queue for chunks to be deleted
IntQueue chunks_todelete;
// Chunk indices. Centered at (0,0,0), going in concentric sphere outwards
std::array<std::array<int16_t, 3>, chunks_volume> chunks_indices;
@ -40,13 +42,7 @@ namespace chunkmanager
int block_to_place{2};
// MEMORYTEST
bool populated{false};
bool populated2{false};
float start_time{0};
// Init chunkmanager. Chunk indices and start threads
int chunks_volume_real;
void init(){
int index{0};
constexpr int rr{RENDER_DISTANCE * RENDER_DISTANCE};
@ -73,9 +69,6 @@ namespace chunkmanager
mesh_thread = std::thread(mesh);
debug::window::set_parameter("block_type_return", &block_to_place);
// MEMORYTEST
start_time = glfwGetTime();
}
// Method for world generation thread(s)
@ -96,39 +89,34 @@ namespace chunkmanager
ChunkPQEntry entry;
if(chunks_to_mesh_queue.try_pop(entry)){
Chunk::Chunk* chunk = entry.first;
if(chunk->getState(Chunk::CHUNK_STATE_GENERATED)){
chunkmesher::mesh(chunk);
entry.first->setState(Chunk::CHUNK_STATE_IN_MESHING_QUEUE, false);
}
chunk->setState(Chunk::CHUNK_STATE_IN_MESHING_QUEUE, false);
}
}
chunks_to_mesh_queue.clear();
}
int nUnloaded{0};
std::queue<int32_t> chunks_todelete;
void update(){
while(should_run) {
std::atomic_int nUnloaded{0}, nMarkUnload{0}, nExplored{0}, nMeshed{0}, nGenerated{0};
std::atomic_int chunkX=static_cast<int>(theCamera.getAtomicPosX() / CHUNK_SIZE);
std::atomic_int chunkY=static_cast<int>(theCamera.getAtomicPosY() / CHUNK_SIZE);
std::atomic_int chunkZ=static_cast<int>(theCamera.getAtomicPosZ() / CHUNK_SIZE);
int nExplored{0}, nMeshed{0}, nGenerated{0};
int chunkX=static_cast<int>(theCamera.getAtomicPosX() / CHUNK_SIZE);
int chunkY=static_cast<int>(theCamera.getAtomicPosY() / CHUNK_SIZE);
int chunkZ=static_cast<int>(theCamera.getAtomicPosZ() / CHUNK_SIZE);
debug::window::set_parameter("update_chunks_tobedeleted", (int) chunks_todelete.size());
while(!chunks_todelete.empty()){
int a = chunks_todelete.front();
auto i = chunks.find(a);
// Eventually delete old chunks
int i;
ChunkTable::accessor a;
while(chunks_todelete.try_pop(i)){
const int index = i;
if(chunks.find(a, index)){
Chunk::Chunk* c = a->second;
if(chunks.erase(a)){
delete i->second;
nUnloaded++;
delete c;
} else std::cout << "failed to delete " << index << std::endl;
} else std::cout << "no such element found to delete\n";
}
else
std::cout << "no such element found to delete\n";
chunks_todelete.pop();
}
// Eventually create new chunks near the player
for(int i = 0; i < chunks_volume; i++) {
const int16_t x = chunks_indices[i][0] + chunkX;
@ -138,12 +126,15 @@ namespace chunkmanager
if(x < 0 || y < 0 || z < 0 || x > 1023 || y > 1023 || z > 1023) continue;
nExplored++;
const int32_t index = calculateIndex(x, y, z);
if(chunks.find(index) == chunks.end()) chunks.emplace(std::make_pair(index, new Chunk::Chunk(glm::vec3(x,y,z))));
ChunkTable::accessor a;
if(!chunks.find(a, index)) chunks.emplace(a, std::make_pair(index, new
Chunk::Chunk(glm::vec3(x,y,z))));
}
for(auto a = chunks.begin(); a != chunks.end(); a++){
// Now update all the chunks
oneapi::tbb::parallel_for(chunks.range(), [&](ChunkTable::range_type &r){
for(ChunkTable::iterator a = r.begin(); a != r.end(); a++){
Chunk::Chunk* c = a->second;
int x = c->getPosition().x;
@ -153,6 +144,8 @@ namespace chunkmanager
int disty = y - chunkY;
int distz = z - chunkZ;
int gen{0}, mesh{0}, unload{0};
if(
distx >= -RENDER_DISTANCE && distx <= RENDER_DISTANCE &&
disty >= -RENDER_DISTANCE && disty <= RENDER_DISTANCE &&
@ -172,7 +165,7 @@ namespace chunkmanager
c->setState(Chunk::CHUNK_STATE_IN_GENERATION_QUEUE, true);
}
}else{
nGenerated++;
gen++;
// If generated but not yet meshed
// TODO: not getting meshed
if(!c->getState(Chunk::CHUNK_STATE_MESHED)){
@ -182,7 +175,7 @@ namespace chunkmanager
c->setState(Chunk::CHUNK_STATE_IN_MESHING_QUEUE, true);
}
}else{
nMeshed++;
mesh++;
// If generated & meshed, render
/*if(!c->getState(Chunk::CHUNK_STATE_IN_RENDERING_QUEUE)){
renderer::getChunksToRender().push(c);
@ -195,8 +188,9 @@ namespace chunkmanager
// If not within distance
if(c->getState(Chunk::CHUNK_STATE_OUTOFVISION)){
// If enough time has passed, set to be deleted
if(glfwGetTime() - c->unload_timer >= UNLOAD_TIMEOUT){
if(c->isFree() && glfwGetTime() - c->unload_timer >= UNLOAD_TIMEOUT){
chunks_todelete.push(calculateIndex(x,y,z));
unload++;
}
}else{
// Mark as out of view, and start waiting time
@ -205,7 +199,25 @@ namespace chunkmanager
c->unload_timer = glfwGetTime();
}
}
nGenerated += gen;
nMeshed += mesh;
nMarkUnload += unload;
}
});
std::cout << "time: " << glfwGetTime() << "\ntotal: " << chunks.size() << "\ngenerated: " << nGenerated << "\nmeshed: "
<< nMeshed << "\nunloaded from prev loop: " << nUnloaded << "\nnew marked for unload: " << nMarkUnload << std::endl;
/*debug::window::set_parameter("px", theCamera.getAtomicPosX());
debug::window::set_parameter("py", theCamera.getAtomicPosY());
debug::window::set_parameter("pz", theCamera.getAtomicPosZ());
debug::window::set_parameter("cx", chunkX);
debug::window::set_parameter("cy", chunkY);
debug::window::set_parameter("cz", chunkZ);
debug::window::set_parameter("lx", theCamera.getFront().x);
debug::window::set_parameter("ly", theCamera.getFront().y);
debug::window::set_parameter("lz", theCamera.getFront().z);
debug::window::set_parameter("update_chunks_total", (int) chunks.size());
debug::window::set_parameter("update_chunks_buckets", (int) chunks.bucket_count());
@ -213,6 +225,7 @@ namespace chunkmanager
debug::window::set_parameter("update_chunks_generated", nGenerated);
debug::window::set_parameter("update_chunks_meshed", nMeshed);
debug::window::set_parameter("update_chunks_explored", nExplored);
debug::window::set_parameter("update_chunks_tobedeleted", 0);*/
}
}