device.c

#include <kiba/gpu/device.h>
 
#include <kiba/core/memory.h>
#include <kiba/gpu/buffer.h>
#include <kiba/gpu/command.h>
#include <kiba/gpu/pipeline.h>
#include <kiba/gpu/shader.h>
#include <kiba/gpu/texture.h>
 
static inline void gpu_device_resource_destroy(struct gpu_device_resource resource) {
    switch (resource.type) {
        case GPU_DEVICE_RESOURCE_TEXTURE:
            gpu_device_resource_texture_destroy((gpu_texture) resource.handle);
            break;
        case GPU_DEVICE_RESOURCE_TEXTURE_VIEW:
            gpu_device_resource_texture_view_destroy((gpu_texture_view) resource.handle);
            break;
        case GPU_DEVICE_RESOURCE_PIPELINE:
            gpu_device_resource_pipeline_destroy((gpu_pipeline) resource.handle);
            break;
        case GPU_DEVICE_RESOURCE_PIPELINE_LAYOUT:
            gpu_device_resource_pipeline_layout_destroy((gpu_pipeline_layout) resource.handle);
            break;
        case GPU_DEVICE_RESOURCE_SHADER_MODULE:
            gpu_device_resource_shader_module_destroy((gpu_shader_module) resource.handle);
            break;
        case GPU_DEVICE_RESOURCE_BUFFER:
            gpu_device_resource_buffer_destroy((gpu_buffer) resource.handle);
            break;
        case GPU_DEVICE_RESOURCE_COMMAND_ENCODER:
            gpu_device_resource_command_encoder_destroy((gpu_command_encoder) resource.handle);
            break;
    }
}
 
b8 gpu_device_create(gpu_device *device) {
    // TODO error reporting
    allocator dev_alloc = {0};
    if (allocator_create(&dev_alloc, ALLOCATOR_FREE_LIST, KB_KILOBYTE(4))) {
        struct gpu_device *new_dev = allocator_allocate(&dev_alloc, sizeof(struct gpu_device));
        if (new_dev != KB_NULL) {
            new_dev->alloc = dev_alloc;
            if (id_generator_create(&new_dev->texture_id_gen, &new_dev->alloc)
                && id_generator_create(&new_dev->buffer_id_gen, &new_dev->alloc)) {
                new_dev->textures = array_create(struct gpu_texture_tracker, 8, &new_dev->alloc);
                new_dev->buffer_trackers = array_create(struct gpu_buffer_tracker, 8, &new_dev->alloc);
                if (new_dev->textures && new_dev->buffer_trackers) {
                    array_resize(&new_dev->textures, 8);  // is safe due to <= capacity
                    array_resize(&new_dev->buffer_trackers, 8);  // is safe due to <= capacity
                    new_dev->destruction_queue_index     = 0;
                    for (usize i = 0; i < 2; ++i) {
                        new_dev->destruction_queues[i].resources =
                            array_create(struct gpu_device_resource, 8, &new_dev->alloc);
                        KB_ASSERT(new_dev->destruction_queues[i].resources, "FIXME this is temp");
                    }
                    if (gpu_backend_device_create(&new_dev->bd)) {
                        *device = new_dev;
                        return true;
                    }
                    array_destroy(&new_dev->textures);
                }
                id_generator_destroy(new_dev->buffer_id_gen);
                id_generator_destroy(new_dev->texture_id_gen);
            }
            allocator_free(&dev_alloc, new_dev);
        }
        allocator_destroy(&dev_alloc);
    }
    *device = KB_NULL;
    return false;
}
 
void gpu_device_update(gpu_device device) {
    device->destruction_queue_index ^= 1;
    array_of(struct gpu_device_resource) resources =
        device->destruction_queues[device->destruction_queue_index].resources;
    array_for_each(struct gpu_device_resource, resource, resources) {
        KB_INFO("destroying {u32} resource {pointer}", resource->type, resource->handle);
        gpu_device_resource_destroy(*resource);
    }
    array_resize(&device->destruction_queues[device->destruction_queue_index].resources, 0);
}
 
void gpu_device_destroy(gpu_device *device) {
    KB_ASSERT(device != KB_NULL, "device handle must not be NULL");
    struct gpu_device *dev = *device;
    if (dev) {
        gpu_backend_device_finish_running_tasks(&dev->bd);
        // TODO cleanup resource arrays
        for (usize i = 0; i < 2; ++i) {
            if (dev->destruction_queues[i].resources) {
                array_for_each(struct gpu_device_resource, resource, dev->destruction_queues[i].resources) {
                    KB_INFO("destroying {u32} resource {pointer}", resource->type, resource->handle);
                    gpu_device_resource_destroy(*resource);
                }
                array_destroy(&dev->destruction_queues[i].resources);
            }
        }
        gpu_backend_device_destroy(&dev->bd);
        array_destroy(&dev->buffer_trackers);
        array_destroy(&dev->textures);
        id_generator_destroy(dev->buffer_id_gen);
        id_generator_destroy(dev->texture_id_gen);
        allocator dev_alloc = dev->alloc;
        allocator_free(&dev_alloc, dev);
        allocator_destroy(&dev_alloc);
    }
    *device = KB_NULL;
}
 
b8 gpu_device_resource_texture_create(gpu_device device, gpu_texture *texture) {
    identifier  track_id      = id_request(device->texture_id_gen);
    const usize textures_size = array_size(device->textures);
    if (track_id >= textures_size && !array_resize(&device->textures, textures_size * 2)) {
        KB_ERROR("unable to allocate space for new textures");
        return false;
    }
 
    // TODO get alignment of type
    struct gpu_texture *tex = allocator_allocate_aligned(&device->alloc, sizeof(struct gpu_texture), 16);
    if (!tex) {
        KB_ERROR("unable to allocate memory for texture metadata");
        id_return(device->texture_id_gen, track_id);
        return false;
    }
    tex->device                          = device;
    tex->tracker_id                      = track_id;
    device->textures[track_id].texture   = tex;
    device->textures[track_id].start_use = GPU_TEXTURE_USE_UNINITIALIZED;
    device->textures[track_id].cur_use   = GPU_TEXTURE_USE_UNINITIALIZED;
    *texture                             = tex;
    return true;
}
 
void gpu_device_resource_texture_enqueue_destroy(gpu_texture texture) {
    gpu_device device = texture->device;
    KB_ASSERT(device, "texture must have valid device handle");
    struct gpu_device_resource resource = {
        .type   = GPU_DEVICE_RESOURCE_TEXTURE,
        .handle = texture,
    };
    array_push_checked(&device->destruction_queues[device->destruction_queue_index].resources, &resource);
}
 
void gpu_device_resource_texture_destroy(gpu_texture texture) {
    gpu_texture_destroy_internal(texture);
    gpu_device_resource_texture_release(texture);
}
 
void gpu_device_resource_texture_release(gpu_texture texture) {
    gpu_device device = texture->device;
    KB_ASSERT(device, "texture must have valid device handle");
    const usize textures_size = array_size(device->textures);
    if (texture->tracker_id < textures_size) {
        device->textures[texture->tracker_id].texture = KB_NULL;
        id_return(device->texture_id_gen, texture->tracker_id);
    }
    allocator_free(&device->alloc, texture);
}
 
b8 gpu_device_resource_texture_view_create(gpu_device device, gpu_texture_view *view) {
    // TODO get alignment of type
    struct gpu_texture_view *v = allocator_allocate_aligned(&device->alloc, sizeof(struct gpu_texture_view), 16);
    if (!v) {
        KB_ERROR("unable to allocate memory for texture view metadata");
        return false;
    }
    v->device = device;
    *view     = v;
    return true;
}
 
void gpu_device_resource_texture_view_enqueue_destroy(gpu_texture_view view) {
    gpu_device device = view->device;
    KB_ASSERT(device, "texture view must have valid device handle");
    struct gpu_device_resource resource = {
        .type   = GPU_DEVICE_RESOURCE_TEXTURE_VIEW,
        .handle = view,
    };
    array_push_checked(&device->destruction_queues[device->destruction_queue_index].resources, &resource);
}
 
void gpu_device_resource_texture_view_destroy(gpu_texture_view view) {
    gpu_texture_view_destroy_internal(view);
    allocator_free(&view->device->alloc, view);
}
 
b8 gpu_device_resource_pipeline_layout_create(gpu_device device, gpu_pipeline_layout *layout) {
    // TODO get alignment of type
    struct gpu_pipeline_layout *l = allocator_allocate_aligned(&device->alloc, sizeof(struct gpu_pipeline_layout), 16);
    if (!l) {
        KB_ERROR("unable to allocate memory for pipeline layout metadata");
        return false;
    }
    l->device = device;
    *layout   = l;
    return true;
}
 
void gpu_device_resource_pipeline_layout_enqueue_destroy(gpu_pipeline_layout layout) {
    gpu_device device = layout->device;
    KB_ASSERT(device, "pipeline layout must have valid device handle");
    struct gpu_device_resource resource = {
        .type   = GPU_DEVICE_RESOURCE_PIPELINE_LAYOUT,
        .handle = layout,
    };
    array_push_checked(&device->destruction_queues[device->destruction_queue_index].resources, &resource);
}
 
void gpu_device_resource_pipeline_layout_destroy(gpu_pipeline_layout layout) {
    gpu_pipeline_layout_destroy_internal(layout);
    allocator_free(&layout->device->alloc, layout);
}
 
b8 gpu_device_resource_pipeline_create(gpu_device device, gpu_pipeline *pipeline) {
    // TODO get alignment of type
    struct gpu_pipeline *p = allocator_allocate_aligned(&device->alloc, sizeof(struct gpu_pipeline), 16);
    if (!p) {
        KB_ERROR("unable to allocate memory for pipeline metadata");
        return false;
    }
    p->device = device;
    *pipeline = p;
    return true;
}
 
void gpu_device_resource_pipeline_enqueue_destroy(gpu_pipeline pipeline) {
    gpu_device device = pipeline->device;
    KB_ASSERT(device, "pipeline must have valid device handle");
    struct gpu_device_resource resource = {
        .type   = GPU_DEVICE_RESOURCE_PIPELINE,
        .handle = pipeline,
    };
    array_push_checked(&device->destruction_queues[device->destruction_queue_index].resources, &resource);
}
 
void gpu_device_resource_pipeline_destroy(gpu_pipeline pipeline) {
    gpu_render_pipeline_destroy_internal(pipeline);
    allocator_free(&pipeline->device->alloc, pipeline);
}
 
b8 gpu_device_resource_shader_module_create(gpu_device device, gpu_shader_module *shader) {
    // TODO get alignment of type
    struct gpu_shader_module *s = allocator_allocate_aligned(&device->alloc, sizeof(struct gpu_shader_module), 16);
    if (!s) {
        KB_ERROR("unable to allocate memory for shader metadata");
        return false;
    }
    s->device = device;
    *shader   = s;
    return true;
}
 
void gpu_device_resource_shader_module_enqueue_destroy(gpu_shader_module shader) {
    gpu_device device = shader->device;
    KB_ASSERT(device, "shader must have valid device handle");
    struct gpu_device_resource resource = {
        .type   = GPU_DEVICE_RESOURCE_SHADER_MODULE,
        .handle = shader,
    };
    array_push_checked(&device->destruction_queues[device->destruction_queue_index].resources, &resource);
}
 
void gpu_device_resource_shader_module_destroy(gpu_shader_module shader) {
    gpu_shader_module_destroy_internal(shader);
    allocator_free(&shader->device->alloc, shader);
}
 
b8 gpu_device_resource_buffer_create(gpu_device device, gpu_buffer *buffer) {
    identifier  track_id     = id_request(device->buffer_id_gen);
    const usize buffers_size = array_size(device->buffer_trackers);
    if (track_id >= buffers_size && !array_resize(&device->buffer_trackers, buffers_size * 2)) {
        KB_ERROR("unable to allocate space for new buffers");
        return false;
    }
 
    // TODO get alignment of type
    struct gpu_buffer *buf = allocator_allocate_aligned(&device->alloc, sizeof(struct gpu_buffer), 16);
    if (!buf) {
        KB_ERROR("unable to allocate memory for buffer metadata");
        id_return(device->buffer_id_gen, track_id);
        return false;
    }
    buf->device                                 = device;
    buf->tracker_id                             = track_id;
    device->buffer_trackers[track_id].buffer    = buf;
    device->buffer_trackers[track_id].start_use = 0;
    device->buffer_trackers[track_id].cur_use   = 0;
    *buffer                                     = buf;
    return true;
}
 
void gpu_device_resource_buffer_enqueue_destroy(gpu_buffer buffer) {
    gpu_device device = buffer->device;
    KB_ASSERT(device, "buffer must have valid device handle");
    struct gpu_device_resource resource = {
        .type   = GPU_DEVICE_RESOURCE_BUFFER,
        .handle = buffer,
    };
    array_push_checked(&device->destruction_queues[device->destruction_queue_index].resources, &resource);
}
 
void gpu_device_resource_buffer_destroy(gpu_buffer buffer) {
    gpu_buffer_destroy_internal(buffer);
    gpu_device_resource_buffer_release(buffer);
}
 
void gpu_device_resource_buffer_release(gpu_buffer buffer) {
    gpu_device device = buffer->device;
    KB_ASSERT(device, "buffer must have valid device handle");
    const usize buffers_size = array_size(device->buffer_trackers);
    if (buffer->tracker_id < buffers_size) {
        device->buffer_trackers[buffer->tracker_id].buffer = KB_NULL;
        id_return(device->buffer_id_gen, buffer->tracker_id);
    }
    allocator_free(&device->alloc, buffer);
}
 
b8 gpu_device_resource_command_encoder_create(gpu_device device, gpu_command_encoder *encoder) {
    // TODO get alignment of type
    struct gpu_command_encoder *e = allocator_allocate_aligned(&device->alloc, sizeof(struct gpu_command_encoder), 16);
    if (!e) {
        KB_ERROR("unable to allocate memory for encoder metadata");
        return false;
    }
    e->device = device;
    *encoder  = e;
    return true;
}
 
void gpu_device_resource_command_encoder_enqueue_destroy(gpu_command_encoder encoder) {
    gpu_device device = encoder->device;
    KB_ASSERT(device, "encoder must have valid device handle");
    struct gpu_device_resource resource = {
        .type   = GPU_DEVICE_RESOURCE_COMMAND_ENCODER,
        .handle = encoder,
    };
    array_push_checked(&device->destruction_queues[device->destruction_queue_index].resources, &resource);
}
 
void gpu_device_resource_command_encoder_destroy(gpu_command_encoder encoder) {
    gpu_command_encoder_destroy_internal(encoder);
    allocator_free(&encoder->device->alloc, encoder);
}