src/graphics/lib/compute/common/vk/event_pool.c

// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//
//
//

#include "event_pool.h"

#include "assert_vk.h"
#include "host_alloc.h"

//
//
//

struct vk_event_pool
{
  VkEvent *                     events;
  VkAllocationCallbacks const * allocator;
  VkDevice                      device;
  uint32_t                      resize;
  uint32_t                      size;
  uint32_t                      next;
};

static void
vk_event_pool_resize(struct vk_event_pool * const event_pool)
{
  static struct VkEventCreateInfo const eci = { .sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
                                                .pNext = NULL,
                                                .flags = 0 };

  // FIXME -- respect allocator

  event_pool->size += event_pool->resize;
  event_pool->events =
    vk_host_realloc(event_pool->allocator, event_pool->events, sizeof(VkEvent) * event_pool->size);

  for (uint32_t ii = event_pool->next; ii < event_pool->size; ii++)
    {
      vk(CreateEvent(event_pool->device, &eci, event_pool->allocator, event_pool->events + ii));
    }
}

struct vk_event_pool *
vk_event_pool_create(VkDevice                      device,
                     VkAllocationCallbacks const * allocator,
                     uint32_t const                resize)
{
  struct vk_event_pool * const event_pool = vk_host_alloc(allocator, sizeof(*event_pool));

  event_pool->events    = NULL;
  event_pool->allocator = allocator;
  event_pool->device    = device;
  event_pool->resize    = resize;
  event_pool->size      = 0;
  event_pool->next      = 0;

  vk_event_pool_resize(event_pool);

  return event_pool;
}

void
vk_event_pool_release(struct vk_event_pool * const event_pool)
{
  for (uint32_t ii = 0; ii < event_pool->size; ii++)
    {
      vkDestroyEvent(event_pool->device, event_pool->events[ii], event_pool->allocator);
    }

  vk_host_free(event_pool->allocator, event_pool->events);
  vk_host_free(event_pool->allocator, event_pool);
}

void
vk_event_pool_reset(struct vk_event_pool * const event_pool)
{
  for (uint32_t ii = 0; ii < event_pool->next; ii++)
    vk(ResetEvent(event_pool->device, event_pool->events[ii]));

  event_pool->next = 0;
}

VkEvent
vk_event_pool_acquire(struct vk_event_pool * const event_pool)
{
  if (event_pool->next == event_pool->size)
    vk_event_pool_resize(event_pool);

  return event_pool->events[event_pool->next++];
}

//
//
//