util_dynarray_fini(&batch->jobs);
if (!pan_is_bifrost(pdev))
panfrost_bo_unreference(batch->tiler.ctx.midgard.polygon_list);
+
+ util_dynarray_fini(&batch->event_ops);
+
vk_free(&cmdbuf->pool->alloc, batch);
}
util_dynarray_fini(&batch->jobs);
if (!pan_is_bifrost(pdev))
panfrost_bo_unreference(batch->tiler.ctx.midgard.polygon_list);
+
+ util_dynarray_fini(&batch->event_ops);
+
vk_free(&cmdbuf->pool->alloc, batch);
}
sizeof(*cmdbuf->state.batch), 8,
VK_SYSTEM_ALLOCATION_SCOPE_COMMAND);
util_dynarray_init(&cmdbuf->state.batch->jobs, NULL);
+ util_dynarray_init(&cmdbuf->state.batch->event_ops, NULL);
cmdbuf->state.clear = vk_zalloc(&cmdbuf->pool->alloc,
sizeof(*cmdbuf->state.clear) *
pRenderPassBegin->clearValueCount, 8,
void
panvk_cmd_close_batch(struct panvk_cmd_buffer *cmdbuf)
{
- assert(cmdbuf->state.batch);
+ struct panvk_batch *batch = cmdbuf->state.batch;
- if (!cmdbuf->state.batch->fragment_job &&
- !cmdbuf->state.batch->scoreboard.first_job) {
- vk_free(&cmdbuf->pool->alloc, cmdbuf->state.batch);
+ assert(batch);
+
+ if (!batch->fragment_job && !batch->scoreboard.first_job) {
+ if (util_dynarray_num_elements(&batch->event_ops, struct panvk_event_op) == 0) {
+ /* Content-less batch, let's drop it */
+ vk_free(&cmdbuf->pool->alloc, batch);
+ } else {
+ /* Batch has no jobs but is needed for synchronization, let's add a
+ * NULL job so the SUBMIT ioctl doesn't choke on it.
+ */
+ struct panfrost_ptr ptr = pan_pool_alloc_desc(&cmdbuf->desc_pool.base,
+ JOB_HEADER);
+ util_dynarray_append(&batch->jobs, void *, ptr.cpu);
+ panfrost_add_job(&cmdbuf->desc_pool.base, &batch->scoreboard,
+ MALI_JOB_TYPE_NULL, false, false, 0, 0,
+ &ptr, false);
+ list_addtail(&batch->node, &cmdbuf->batches);
+ }
cmdbuf->state.batch = NULL;
return;
}
struct panfrost_device *pdev = &cmdbuf->device->physical_device->pdev;
- struct panvk_batch *batch = cmdbuf->state.batch;
list_addtail(&cmdbuf->state.batch->node, &cmdbuf->batches);
}
}
+static void
+panvk_add_set_event_operation(struct panvk_cmd_buffer *cmdbuf,
+ struct panvk_event *event,
+ enum panvk_event_op_type type)
+{
+ struct panvk_event_op op = {
+ .type = type,
+ .event = event,
+ };
+
+ if (cmdbuf->state.batch == NULL) {
+ /* No open batch, let's create a new one so this operation happens in
+ * the right order.
+ */
+ panvk_cmd_open_batch(cmdbuf);
+ util_dynarray_append(&cmdbuf->state.batch->event_ops,
+ struct panvk_event_op,
+ op);
+ panvk_cmd_close_batch(cmdbuf);
+ } else {
+ /* Let's close the current batch so the operation executes before any
+ * future commands.
+ */
+ util_dynarray_append(&cmdbuf->state.batch->event_ops,
+ struct panvk_event_op,
+ op);
+ panvk_cmd_close_batch(cmdbuf);
+ panvk_cmd_open_batch(cmdbuf);
+ }
+}
+
+static void
+panvk_add_wait_event_operation(struct panvk_cmd_buffer *cmdbuf,
+ struct panvk_event *event)
+{
+ struct panvk_event_op op = {
+ .type = PANVK_EVENT_OP_WAIT,
+ .event = event,
+ };
+
+ if (cmdbuf->state.batch == NULL) {
+ /* No open batch, let's create a new one and have it wait for this event. */
+ panvk_cmd_open_batch(cmdbuf);
+ util_dynarray_append(&cmdbuf->state.batch->event_ops,
+ struct panvk_event_op,
+ op);
+ } else {
+ /* Let's close the current batch so any future commands wait on the
+ * event signal operation.
+ */
+ if (cmdbuf->state.batch->fragment_job ||
+ cmdbuf->state.batch->scoreboard.first_job) {
+ panvk_cmd_close_batch(cmdbuf);
+ panvk_cmd_open_batch(cmdbuf);
+ }
+ util_dynarray_append(&cmdbuf->state.batch->event_ops,
+ struct panvk_event_op,
+ op);
+ }
+}
+
void
panvk_CmdSetEvent(VkCommandBuffer commandBuffer,
VkEvent _event,
VkPipelineStageFlags stageMask)
{
- panvk_stub();
+ VK_FROM_HANDLE(panvk_cmd_buffer, cmdbuf, commandBuffer);
+ VK_FROM_HANDLE(panvk_event, event, _event);
+
+ /* vkCmdSetEvent cannot be called inside a render pass */
+ assert(cmdbuf->state.pass == NULL);
+
+ panvk_add_set_event_operation(cmdbuf, event, PANVK_EVENT_OP_SET);
}
void
VkEvent _event,
VkPipelineStageFlags stageMask)
{
- panvk_stub();
+ VK_FROM_HANDLE(panvk_cmd_buffer, cmdbuf, commandBuffer);
+ VK_FROM_HANDLE(panvk_event, event, _event);
+
+ /* vkCmdResetEvent cannot be called inside a render pass */
+ assert(cmdbuf->state.pass == NULL);
+
+ panvk_add_set_event_operation(cmdbuf, event, PANVK_EVENT_OP_RESET);
}
void
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier *pImageMemoryBarriers)
{
- panvk_stub();
+ VK_FROM_HANDLE(panvk_cmd_buffer, cmdbuf, commandBuffer);
+
+ assert(eventCount > 0);
+
+ for (uint32_t i = 0; i < eventCount; i++) {
+ VK_FROM_HANDLE(panvk_event, event, pEvents[i]);
+ panvk_add_wait_event_operation(cmdbuf, event);
+ }
}
void
close(handle.fd);
}
+static void
+panvk_add_wait_event_syncobjs(struct panvk_batch *batch, uint32_t *in_fences, unsigned *nr_in_fences)
+{
+ util_dynarray_foreach(&batch->event_ops, struct panvk_event_op, op) {
+ switch (op->type) {
+ case PANVK_EVENT_OP_SET:
+ /* Nothing to do yet */
+ break;
+ case PANVK_EVENT_OP_RESET:
+ /* Nothing to do yet */
+ break;
+ case PANVK_EVENT_OP_WAIT:
+ in_fences[*nr_in_fences++] = op->event->syncobj;
+ break;
+ default:
+ unreachable("bad panvk_event_op type\n");
+ }
+ }
+}
+
+static void
+panvk_signal_event_syncobjs(struct panvk_queue *queue, struct panvk_batch *batch)
+{
+ const struct panfrost_device *pdev = &queue->device->physical_device->pdev;
+
+ util_dynarray_foreach(&batch->event_ops, struct panvk_event_op, op) {
+ switch (op->type) {
+ case PANVK_EVENT_OP_SET: {
+ panvk_queue_transfer_sync(queue, op->event->syncobj);
+ break;
+ }
+ case PANVK_EVENT_OP_RESET: {
+ struct panvk_event *event = op->event;
+
+ struct drm_syncobj_array objs = {
+ .handles = (uint64_t) (uintptr_t) &event->syncobj,
+ .count_handles = 1
+ };
+
+ int ret = drmIoctl(pdev->fd, DRM_IOCTL_SYNCOBJ_RESET, &objs);
+ assert(!ret);
+ break;
+ }
+ case PANVK_EVENT_OP_WAIT:
+ /* Nothing left to do */
+ break;
+ default:
+ unreachable("bad panvk_event_op type\n");
+ }
+ }
+}
+
VkResult
panvk_QueueSubmit(VkQueue _queue,
uint32_t submitCount,
for (uint32_t i = 0; i < submitCount; ++i) {
const VkSubmitInfo *submit = pSubmits + i;
- unsigned nr_in_fences = submit->waitSemaphoreCount + 1;
- uint32_t in_fences[nr_in_fences];
+ unsigned nr_semaphores = submit->waitSemaphoreCount + 1;
+ uint32_t semaphores[nr_semaphores];
- in_fences[0] = queue->sync;
+ semaphores[0] = queue->sync;
for (unsigned i = 0; i < submit->waitSemaphoreCount; i++) {
VK_FROM_HANDLE(panvk_semaphore, sem, submit->pWaitSemaphores[i]);
- in_fences[i + 1] = sem->syncobj.temporary ? : sem->syncobj.permanent;
+ semaphores[i + 1] = sem->syncobj.temporary ? : sem->syncobj.permanent;
}
for (uint32_t j = 0; j < submit->commandBufferCount; ++j) {
bos[bo_idx++] = pdev->sample_positions->gem_handle;
assert(bo_idx == nr_bos);
+
+ unsigned nr_in_fences = 0;
+ unsigned max_wait_event_syncobjs =
+ util_dynarray_num_elements(&batch->event_ops,
+ struct panvk_event_op);
+ uint32_t in_fences[nr_semaphores + max_wait_event_syncobjs];
+ memcpy(in_fences, semaphores, nr_semaphores * sizeof(*in_fences));
+ nr_in_fences += nr_semaphores;
+
+ panvk_add_wait_event_syncobjs(batch, in_fences, &nr_in_fences);
+
panvk_queue_submit_batch(queue, batch, bos, nr_bos, in_fences, nr_in_fences);
+
+ panvk_signal_event_syncobjs(queue, batch);
}
}
const VkAllocationCallbacks *pAllocator,
VkEvent *pEvent)
{
- panvk_stub();
+ VK_FROM_HANDLE(panvk_device, device, _device);
+ const struct panfrost_device *pdev = &device->physical_device->pdev;
+ struct panvk_event *event =
+ vk_object_zalloc(&device->vk, pAllocator, sizeof(*event),
+ VK_OBJECT_TYPE_EVENT);
+ if (!event)
+ return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
+
+ struct drm_syncobj_create create = {
+ .flags = 0,
+ };
+
+ int ret = drmIoctl(pdev->fd, DRM_IOCTL_SYNCOBJ_CREATE, &create);
+ if (ret)
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
+
+ event->syncobj = create.handle;
+ *pEvent = panvk_event_to_handle(event);
+
return VK_SUCCESS;
}
VkEvent _event,
const VkAllocationCallbacks *pAllocator)
{
- panvk_stub();
+ VK_FROM_HANDLE(panvk_device, device, _device);
+ VK_FROM_HANDLE(panvk_event, event, _event);
+ const struct panfrost_device *pdev = &device->physical_device->pdev;
+
+ if (!event)
+ return;
+
+ struct drm_syncobj_destroy destroy = { .handle = event->syncobj };
+ drmIoctl(pdev->fd, DRM_IOCTL_SYNCOBJ_DESTROY, &destroy);
+
+ vk_object_free(&device->vk, pAllocator, event);
}
VkResult
panvk_GetEventStatus(VkDevice _device, VkEvent _event)
{
- panvk_stub();
- return VK_EVENT_RESET;
+ VK_FROM_HANDLE(panvk_device, device, _device);
+ VK_FROM_HANDLE(panvk_event, event, _event);
+ const struct panfrost_device *pdev = &device->physical_device->pdev;
+ bool signaled;
+
+ struct drm_syncobj_wait wait = {
+ .handles = (uintptr_t) &event->syncobj,
+ .count_handles = 1,
+ .timeout_nsec = 0,
+ .flags = DRM_SYNCOBJ_WAIT_FLAGS_WAIT_FOR_SUBMIT,
+ };
+
+ int ret = drmIoctl(pdev->fd, DRM_IOCTL_SYNCOBJ_WAIT, &wait);
+ if (ret) {
+ if (errno == ETIME)
+ signaled = false;
+ else {
+ assert(0);
+ return VK_ERROR_DEVICE_LOST; /* TODO */
+ }
+ } else
+ signaled = true;
+
+ return signaled ? VK_EVENT_SET : VK_EVENT_RESET;
}
VkResult
panvk_SetEvent(VkDevice _device, VkEvent _event)
{
- panvk_stub();
- return VK_SUCCESS;
+ VK_FROM_HANDLE(panvk_device, device, _device);
+ VK_FROM_HANDLE(panvk_event, event, _event);
+ const struct panfrost_device *pdev = &device->physical_device->pdev;
+
+ struct drm_syncobj_array objs = {
+ .handles = (uint64_t) (uintptr_t) &event->syncobj,
+ .count_handles = 1
+ };
+
+ /* This is going to just replace the fence for this syncobj with one that
+ * is already in signaled state. This won't be a problem because the spec
+ * mandates that the event will have been set before the vkCmdWaitEvents
+ * command executes.
+ * https://www.khronos.org/registry/vulkan/specs/1.2/html/chap6.html#commandbuffers-submission-progress
+ */
+ if (drmIoctl(pdev->fd, DRM_IOCTL_SYNCOBJ_SIGNAL, &objs))
+ return VK_ERROR_DEVICE_LOST;
+
+ return VK_SUCCESS;
}
VkResult
panvk_ResetEvent(VkDevice _device, VkEvent _event)
{
- panvk_stub();
- return VK_SUCCESS;
+ VK_FROM_HANDLE(panvk_device, device, _device);
+ VK_FROM_HANDLE(panvk_event, event, _event);
+ const struct panfrost_device *pdev = &device->physical_device->pdev;
+
+ struct drm_syncobj_array objs = {
+ .handles = (uint64_t) (uintptr_t) &event->syncobj,
+ .count_handles = 1
+ };
+
+ if (drmIoctl(pdev->fd, DRM_IOCTL_SYNCOBJ_RESET, &objs))
+ return VK_ERROR_DEVICE_LOST;
+
+ return VK_SUCCESS;
}
VkResult