GPU uses improved queue for commands

Author: PoroCoco

CMakeLists.txt

@@ -11,7 +11,7 @@ include_directories(lib/)
 include_directories(src/)
 
 add_executable(main src/main.c src/glad.c src/window.c src/shader.c src/camera.c src/block.c src/chunk.c src/world.c src/player.c src/direction.c
-                    src/atlas.c src/gpu.c src/hashtable.c src/stack.c src/fixed_array.c src/queue.c src/frustum.c src/chunk_mesh.c)
+                    src/atlas.c src/gpu.c src/hashtable.c src/stack.c src/fixed_array.c src/queue_og.c src/frustum.c src/chunk_mesh.c src/queue.c)
 set_property(TARGET main PROPERTY C_STANDARD 11)
 
 if( WIN32 )

src/gpu.c

@@ -230,7 +230,7 @@ void _gpu_create_command(gpu * gpu, enum command_types type, void * args){
     assert(com);
     com->type = type;
     com->args = args;
-    queue_enqueue(gpu->command_queue, (void *) com);
+    queue_produce(gpu->command_queue, (void *) com);
 }
 
 void gpu_set_VAO(gpu* gpu, uint64_t vao_index){
@@ -478,108 +478,107 @@ void* render_thread_init(void * thread_args){
     printf("render thread looping\n");
     bool running = true;
     while(running){
-        if(!queue_is_empty(gpu->command_queue)){
-            gpu_command *command = queue_dequeue(gpu->command_queue);
-            switch (command->type)
-            {
-            case COMMAND_UPLOAD:
-            {
-                struct gpu_command_upload * args = command->args;
-                _gpu_upload(gpu, args->chunk_index, args->c);
-                break; 
-            }    
-            case COMMAND_DRAW_CHUNK:
-            {
-                struct gpu_command_draw_chunk * args = command->args;
-                _gpu_draw_chunk(gpu, args);
-                break; 
-            }    
-            case COMMAND_SCREEN_CLEAR:
-            {
-                _gpu_clear_screen(gpu);
-                break; 
-            }    
-            case COMMAND_DRAW_END:
-            {
-                glfwSwapBuffers(*th_args->window_handle);
-                glfwPollEvents();
-                pthread_mutex_unlock(&gpu->draw_mutex);
-                break; 
-            }    
-            case COMMAND_DRAW_START:
-            {
-                pthread_mutex_lock(&gpu->draw_mutex);
-                break; 
-            }    
-            case COMMAND_SHADER_INIT:
-            {
-                struct gpu_command_shader_init * args = command->args;
-                _gpu_shader_init(gpu, args);
-                break; 
-            }    
-            case COMMAND_SHADER_USE:
-            {
-                struct gpu_command_shader_init * args = command->args;
-                _gpu_shader_use(gpu, args);
-                break; 
-            }    
-            case COMMAND_DRAW_SKYBOX:
-            {
-                struct gpu_command_draw_skybox * args = command->args;
-                _gpu_draw_skybox(gpu, args);
-                break; 
-            }    
-            case COMMAND_SHADER_SET_M4:
-            {
-                struct gpu_command_shader_mat4 * args = command->args;
-                _gpu_shader_set_m4(gpu, args);
-                break; 
-            }    
-            case COMMAND_SHADER_SET_TRANSFORM_MAT:
-            {
-                struct gpu_command_shader_transform_mat * args = command->args;
-                _gpu_shader_set_transform_matrices(gpu, args);
-                break; 
-            }    
-            case COMMAND_SHADER_SET_FLOAT:
-            {
-                struct gpu_command_shader_float * args = command->args;
-                _gpu_shader_set_float(gpu, args);
-                break; 
-            }
-            case COMMAND_SHADER_SET_FLOAT4:
-            {
-                struct gpu_command_shader_vec4 * args = command->args;
-                _gpu_shader_set_float4(gpu, args);
-                break; 
-            }
-            case COMMAND_SHADER_CLEANUP:
-            {
-                struct gpu_command_shader_init * args = command->args;
-                _gpu_shader_cleanup(gpu, args);
-                break; 
-            }   
-            case COMMAND_SHADER_RELOAD:
-            {
-                _gpu_shader_reload(gpu);
-                break; 
-            }   
-            case COMMAND_WIREFRAME:
-            {
-                _gpu_cycle_wireframe(gpu);
-                break;
-            }
-            case COMMAND_CLEANUP:
-            {
-                running = false;
-                break;
-            }
-            default:
-                break;
-            }
-            free(command->args);
-            free(command);
+        gpu_command *command = queue_consume(gpu->command_queue);
+
+        switch (command->type)
+        {
+        case COMMAND_UPLOAD:
+        {
+            struct gpu_command_upload * args = command->args;
+            _gpu_upload(gpu, args->chunk_index, args->c);
+            break; 
+        }    
+        case COMMAND_DRAW_CHUNK:
+        {
+            struct gpu_command_draw_chunk * args = command->args;
+            _gpu_draw_chunk(gpu, args);
+            break; 
+        }    
+        case COMMAND_SCREEN_CLEAR:
+        {
+            _gpu_clear_screen(gpu);
+            break; 
+        }    
+        case COMMAND_DRAW_END:
+        {
+            glfwSwapBuffers(*th_args->window_handle);
+            glfwPollEvents();
+            pthread_mutex_unlock(&gpu->draw_mutex);
+            break; 
+        }    
+        case COMMAND_DRAW_START:
+        {
+            pthread_mutex_lock(&gpu->draw_mutex);
+            break; 
+        }    
+        case COMMAND_SHADER_INIT:
+        {
+            struct gpu_command_shader_init * args = command->args;
+            _gpu_shader_init(gpu, args);
+            break; 
+        }    
+        case COMMAND_SHADER_USE:
+        {
+            struct gpu_command_shader_init * args = command->args;
+            _gpu_shader_use(gpu, args);
+            break; 
+        }    
+        case COMMAND_DRAW_SKYBOX:
+        {
+            struct gpu_command_draw_skybox * args = command->args;
+            _gpu_draw_skybox(gpu, args);
+            break; 
+        }    
+        case COMMAND_SHADER_SET_M4:
+        {
+            struct gpu_command_shader_mat4 * args = command->args;
+            _gpu_shader_set_m4(gpu, args);
+            break; 
+        }    
+        case COMMAND_SHADER_SET_TRANSFORM_MAT:
+        {
+            struct gpu_command_shader_transform_mat * args = command->args;
+            _gpu_shader_set_transform_matrices(gpu, args);
+            break; 
+        }    
+        case COMMAND_SHADER_SET_FLOAT:
+        {
+            struct gpu_command_shader_float * args = command->args;
+            _gpu_shader_set_float(gpu, args);
+            break; 
+        }
+        case COMMAND_SHADER_SET_FLOAT4:
+        {
+            struct gpu_command_shader_vec4 * args = command->args;
+            _gpu_shader_set_float4(gpu, args);
+            break; 
+        }
+        case COMMAND_SHADER_CLEANUP:
+        {
+            struct gpu_command_shader_init * args = command->args;
+            _gpu_shader_cleanup(gpu, args);
+            break; 
+        }   
+        case COMMAND_SHADER_RELOAD:
+        {
+            _gpu_shader_reload(gpu);
+            break; 
+        }   
+        case COMMAND_WIREFRAME:
+        {
+            _gpu_cycle_wireframe(gpu);
+            break;
+        }
+        case COMMAND_CLEANUP:
+        {
+            running = false;
+            break;
+        }
+        default:
+            break;
         }
+        free(command->args);
+        free(command);
     }
 
     return 0;

src/queue_og.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <pthread.h>
+
+typedef struct queue_og {
+    void ** container;
+    uint64_t size;
+    uint64_t front;
+    uint64_t count;
+    uint64_t back;
+    pthread_mutex_t mutex;
+} queue_og;
+
+
+queue_og * queue_og_init(uint64_t intial_size);
+void queue_og_enqueue_og(queue_og* q, void* value);
+void *queue_og_dequeue_og(queue_og* q);
+bool queue_og_is_empty(queue_og* q);
+bool queue_og_is_full(queue_og* q);
+void queue_og_cleanup(queue_og* q);

src/world.c

@@ -21,10 +21,10 @@ world * world_init(gpu * gpu){
     world * w = malloc(sizeof(*w));
     assert(w);
     w->gpu = gpu;
-    w->chunk_to_acquire = queue_init(2*TOTAL_CHUNKS*20);
+    w->chunk_to_acquire = queue_og_init(2*TOTAL_CHUNKS*20);
     w->loaded_chunks = fixray_init(TOTAL_CHUNKS);
     w->cache = htb_init(100000);
-    // Enqueues all the starting chunks in a kind of spiral pattern (square radius increasing until render distance)
+    // Enqueue_ogs all the starting chunks in a kind of spiral pattern (square radius increasing until render distance)
     for(int square_radius = 0; square_radius <= RENDER_DISTANCE; square_radius++){
     for (int z = -square_radius ; z < square_radius+1 ; z++){
         for (int x = -square_radius;  x < square_radius+1; x++){
@@ -35,8 +35,8 @@ world * world_init(gpu * gpu){
                 gpu_upload(w->gpu, chunk_index, c);
                 c->ready = true;
             }else{
-                queue_enqueue(w->chunk_to_acquire, (void*)(intptr_t)x);
-                queue_enqueue(w->chunk_to_acquire, (void*)(intptr_t)z);
+                queue_og_enqueue_og(w->chunk_to_acquire, (void*)(intptr_t)x);
+                queue_og_enqueue_og(w->chunk_to_acquire, (void*)(intptr_t)z);
             }
         }
     }
@@ -195,11 +195,11 @@ void world_update_acquired(world * w, int *acquired){
         // create a thread that generate said chunk, including its mesh data then fixray and upload
         x = acquired[index*2 + 0];
         z = acquired[index*2 + 1];
-        queue_enqueue(w->chunk_to_acquire, (void*)(intptr_t)x);
-        queue_enqueue(w->chunk_to_acquire, (void*)(intptr_t)z);
+        queue_og_enqueue_og(w->chunk_to_acquire, (void*)(intptr_t)x);
+        queue_og_enqueue_og(w->chunk_to_acquire, (void*)(intptr_t)z);
         index++;
     }
-    printf("Acquired %d\n", index);
+    // printf("Acquired %d\n", index);
 }
 
 bool chunk_in_range(chunk *c, int center_x, int center_z){
@@ -218,13 +218,12 @@ bool world_update_position(world * w, float x, float z){
     static int acquired[TOTAL_CHUNKS*2+1]; //x0,y0,x1,y1 INT_MAX terminated;
     acquired[0] = INT_MAX;
 
-
     // printf("center chunk faces %u, total sizeof in bytes : %zu\n", w->center_chunk->faces_count, chunk_sizeof(w->center_chunk));
     // get last chunk
     int count = 0;
-    while (!queue_is_empty(w->chunk_to_acquire) && count < CHUNK_LOAD_PER_FRAME){
-        int x = (int)(intptr_t)queue_dequeue(w->chunk_to_acquire);
-        int z = (int)(intptr_t)queue_dequeue(w->chunk_to_acquire);
+    while (!queue_og_is_empty(w->chunk_to_acquire) && count < CHUNK_LOAD_PER_FRAME){
+        int x = (int)(intptr_t)queue_og_dequeue_og(w->chunk_to_acquire);
+        int z = (int)(intptr_t)queue_og_dequeue_og(w->chunk_to_acquire);
         if (x >= (new_center_x - (RENDER_DISTANCE)) &&
             z >= (new_center_z - (RENDER_DISTANCE)) &&
             x < (new_center_x + (RENDER_DISTANCE)) &&
@@ -252,13 +251,9 @@ bool world_update_position(world * w, float x, float z){
         printf("new center chunk %d,%d (previous %d,%d)\n", new_center_x, new_center_z, w->center_chunk->x, w->center_chunk->z);
 
         // Find the chunks that were discarded 
-        // ToDo : just like the acquired chunks this could be computed by a function instead of looping
-        
         world_compute_acquired_chunks(w->center_chunk->x, new_center_x, w->center_chunk->z, new_center_z, acquired);
-
         world_update_acquired(w, acquired);
 
-
         w->center_chunk = world_get_loaded_chunk(w, new_center_x, new_center_z);
         // Force the chunk generation
         if (!w->center_chunk){
@@ -269,7 +264,7 @@ bool world_update_position(world * w, float x, float z){
             w->center_chunk = world_get_loaded_chunk(w, new_center_x, new_center_z);
         }
         assert(w->center_chunk);
-        printf("chunk cache bucket used %zu, total entries %zu\n", w->cache->used_buckets, w->cache->total_entries);
+        // printf("chunk cache bucket used %zu, total entries %zu\n", w->cache->used_buckets, w->cache->total_entries);
         return true;
     }
     return false;
@@ -325,7 +320,7 @@ void world_cleanup(world * w){
     }
 
     htb_cleanup(w->cache, (void (*)(void*))chunk_cleanup);
-    queue_cleanup(w->chunk_to_acquire);
+    queue_og_cleanup(w->chunk_to_acquire);
     fixray_cleanup(w->loaded_chunks);
     free(w);
 }

src/world.h

@@ -7,7 +7,7 @@
 #include <gpu.h>
 #include <hashtable.h>
 #include <fixed_array.h>
-#include <queue.h>
+#include <queue_og.h>
 
 #define CHUNK_LOAD_PER_FRAME 8
 
@@ -16,7 +16,7 @@ typedef struct world {
     htb* cache;
     fixray* loaded_chunks;
     chunk* center_chunk; // chunk in the center of the loaded world, where the player currently is
-    queue* chunk_to_acquire;
+    queue_og* chunk_to_acquire;
 } world;