| // 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 "styling_impl.h" |
| |
| #include <stdlib.h> |
| |
| #include "common/vk/assert.h" |
| #include "common/vk/barrier.h" |
| #include "core.h" |
| #include "device.h" |
| #include "queue_pool.h" |
| #include "spinel/spinel_assert.h" |
| #include "spinel/spinel_opcodes.h" |
| #include "state_assert.h" |
| |
| // |
| // Styling states |
| // |
| typedef enum spinel_si_state_e |
| { |
| SPN_SI_STATE_UNSEALED, |
| SPN_SI_STATE_SEALING, |
| SPN_SI_STATE_SEALED, |
| } spinel_si_state_e; |
| |
| // |
| // VK |
| // |
| struct spinel_si_vk |
| { |
| struct spinel_dbi_dm_devaddr h; |
| struct spinel_dbi_dm_devaddr d; |
| }; |
| |
| // |
| // IMPL |
| // |
| struct spinel_styling_impl |
| { |
| struct spinel_styling * styling; |
| struct spinel_device * device; |
| |
| // |
| // Vulkan resources |
| // |
| struct spinel_si_vk vk; |
| |
| uint32_t lock_count; // # of wip renders |
| spinel_si_state_e state; |
| |
| struct |
| { |
| struct |
| { |
| spinel_deps_immediate_semaphore_t immediate; |
| } sealing; |
| } signal; |
| }; |
| |
| // |
| // A callback is only invoked if a H2D copy is required. |
| // |
| struct spinel_si_complete_payload |
| { |
| struct spinel_styling_impl * impl; |
| }; |
| |
| // |
| // |
| // |
| static void |
| spinel_si_seal_complete(void * data0, void * data1) |
| { |
| struct spinel_styling_impl * const impl = data0; |
| |
| impl->state = SPN_SI_STATE_SEALED; |
| impl->signal.sealing.immediate = SPN_DEPS_IMMEDIATE_SEMAPHORE_INVALID; |
| } |
| |
| // |
| // Record commands |
| // |
| static VkPipelineStageFlags |
| spinel_si_seal_record(VkCommandBuffer cb, void * data0, void * data1) |
| { |
| struct spinel_styling_impl * const impl = data0; |
| |
| VkDeviceSize const copy_size = impl->styling->dwords.next * sizeof(uint32_t); |
| |
| VkBufferCopy const bc = { |
| .srcOffset = impl->vk.h.dbi_dm.dbi.offset, |
| .dstOffset = impl->vk.d.dbi_dm.dbi.offset, |
| .size = copy_size, |
| }; |
| |
| vkCmdCopyBuffer(cb, // |
| impl->vk.h.dbi_dm.dbi.buffer, |
| impl->vk.d.dbi_dm.dbi.buffer, |
| 1, |
| &bc); |
| |
| // |
| // This command buffer ends with a transfer |
| // |
| return VK_PIPELINE_STAGE_TRANSFER_BIT; |
| } |
| |
| // |
| // |
| // |
| static spinel_result_t |
| spinel_si_seal(struct spinel_styling_impl * const impl) |
| { |
| // |
| // Return if SEALING or SEALED |
| // |
| if (impl->state >= SPN_SI_STATE_SEALING) |
| { |
| return SPN_SUCCESS; |
| } |
| |
| // |
| // Otherwise, kick off the UNSEALED > SEALING > SEALED transition |
| // |
| struct spinel_device * const device = impl->device; |
| |
| // |
| // If the host buffer is not coherent then it has to be flushed. |
| // |
| // TODO(https://fxbug.dev/42052239): Only flush what has changed. |
| // |
| if (!spinel_allocator_is_coherent(&device->allocator.device.perm.hw_dr)) |
| { |
| // clang-format off |
| VkDeviceSize const flush_size = impl->styling->dwords.next * sizeof(uint32_t); |
| VkDeviceSize const flush_size_ru = ROUND_UP_POW2_MACRO(flush_size, // |
| device->vk.limits.noncoherent_atom_size); |
| // clang-format on |
| |
| VkMappedMemoryRange const mmr = { |
| .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, |
| .pNext = NULL, |
| .memory = impl->vk.h.dbi_dm.dm, |
| .offset = 0, |
| .size = flush_size_ru, |
| }; |
| |
| vk(FlushMappedMemoryRanges(device->vk.d, 1, &mmr)); |
| } |
| |
| // |
| // If this is a discrete GPU then styling data is copied from the host to |
| // device. |
| // |
| if (!spinel_allocator_is_device_local(&device->allocator.device.perm.hw_dr)) |
| { |
| // |
| // Move to SEALING state |
| // |
| impl->state = SPN_SI_STATE_SEALING; |
| |
| // |
| // Acquire an immediate semaphore |
| // |
| struct spinel_deps_immediate_submit_info const disi = { |
| .record = { |
| .pfn = spinel_si_seal_record, |
| .data0 = impl, |
| }, |
| .completion = { |
| .pfn = spinel_si_seal_complete, |
| .data0 = impl, |
| }, |
| }; |
| |
| struct spinel_device * const device = impl->device; |
| |
| spinel_deps_immediate_submit(device->deps, |
| &device->vk, |
| &disi, |
| &impl->signal.sealing.immediate); |
| } |
| else |
| { |
| // |
| // We don't need to copy from the host to device so just |
| // transition directly to the SEALED state. |
| // |
| impl->state = SPN_SI_STATE_SEALED; |
| } |
| |
| return SPN_SUCCESS; |
| } |
| |
| // |
| // |
| // |
| static spinel_result_t |
| spinel_si_unseal(struct spinel_styling_impl * const impl) |
| { |
| // |
| // return if already unsealed |
| // |
| if (impl->state == SPN_SI_STATE_UNSEALED) |
| { |
| return SPN_SUCCESS; |
| } |
| |
| // |
| // otherwise, we know we're either SEALING or SEALED |
| // |
| struct spinel_device * const device = impl->device; |
| |
| while (impl->state != SPN_SI_STATE_SEALED) |
| { |
| // wait for SEALING > SEALED transition ... |
| spinel_deps_drain_1(device->deps, &device->vk); |
| } |
| |
| // |
| // wait for any rendering locks to be released |
| // |
| while (impl->lock_count > 0) |
| { |
| spinel_deps_drain_1(device->deps, &device->vk); |
| } |
| |
| // |
| // transition to unsealed |
| // |
| impl->state = SPN_SI_STATE_UNSEALED; |
| |
| return SPN_SUCCESS; |
| } |
| |
| // |
| // |
| // |
| static spinel_result_t |
| spinel_si_release(struct spinel_styling_impl * const impl) |
| { |
| // |
| // wait for any in-flight renders to complete |
| // |
| struct spinel_device * const device = impl->device; |
| |
| while (impl->lock_count > 0) |
| { |
| spinel_deps_drain_1(device->deps, &device->vk); |
| } |
| |
| // |
| // free device allocations |
| // |
| vkUnmapMemory(device->vk.d, impl->vk.h.dbi_dm.dm); // not necessary |
| |
| spinel_allocator_free_dbi_dm(&device->allocator.device.perm.hw_dr, |
| device->vk.d, |
| device->vk.ac, |
| &impl->vk.h.dbi_dm); |
| |
| if (!spinel_allocator_is_device_local(&device->allocator.device.perm.hw_dr)) |
| { |
| spinel_allocator_free_dbi_dm(&device->allocator.device.perm.drw, |
| device->vk.d, |
| device->vk.ac, |
| &impl->vk.d.dbi_dm); |
| } |
| |
| // |
| // free host allocations |
| // |
| free(impl->styling); |
| free(impl); |
| |
| spinel_context_release(device->context); |
| |
| return SPN_SUCCESS; |
| } |
| |
| // |
| // |
| // |
| spinel_result_t |
| spinel_styling_impl_create(struct spinel_device * device, |
| spinel_styling_create_info_t const * create_info, |
| spinel_styling_t * styling) |
| { |
| spinel_context_retain(device->context); |
| |
| // |
| // Allocate impl |
| // |
| struct spinel_styling_impl * const impl = MALLOC_MACRO(sizeof(*impl)); |
| |
| // |
| // Allocate styling |
| // |
| struct spinel_styling * const s = *styling = MALLOC_MACRO(sizeof(*s)); |
| |
| // |
| // Init forward/backward pointers |
| // |
| impl->styling = s; |
| impl->device = device; |
| s->impl = impl; |
| |
| // |
| // Initialize styling pfns |
| // |
| s->seal = spinel_si_seal; |
| s->unseal = spinel_si_unseal; |
| s->release = spinel_si_release; |
| s->ref_count = 1; |
| s->layers.count = create_info->layer_count; |
| |
| uint32_t const layers_dwords = create_info->layer_count * SPN_STYLING_LAYER_COUNT_DWORDS; |
| uint32_t const dwords_count = layers_dwords + create_info->cmd_count; |
| |
| s->dwords.next = layers_dwords; |
| s->dwords.count = dwords_count; |
| |
| // |
| // Initialize rest of impl |
| // |
| impl->lock_count = 0; |
| impl->state = SPN_SI_STATE_UNSEALED; |
| impl->signal.sealing.immediate = SPN_DEPS_IMMEDIATE_SEMAPHORE_INVALID; |
| |
| // |
| // Initialize styling extent |
| // |
| // Round up to a coherent atom whether or not allocator is coherent. |
| // |
| // clang-format off |
| VkDeviceSize const styling_size = sizeof(uint32_t) * dwords_count; |
| VkDeviceSize const styling_size_ru = ROUND_UP_POW2_MACRO(styling_size, // |
| device->vk.limits.noncoherent_atom_size); |
| // clang-format on |
| |
| spinel_allocator_alloc_dbi_dm_devaddr(&device->allocator.device.perm.hw_dr, |
| device->vk.pd, |
| device->vk.d, |
| device->vk.ac, |
| styling_size_ru, |
| NULL, |
| &impl->vk.h); |
| |
| vk(MapMemory(device->vk.d, // |
| impl->vk.h.dbi_dm.dm, |
| 0, |
| VK_WHOLE_SIZE, |
| 0, |
| (void **)&s->extent)); |
| |
| if (!spinel_allocator_is_device_local(&device->allocator.device.perm.hw_dr)) |
| { |
| spinel_allocator_alloc_dbi_dm_devaddr(&device->allocator.device.perm.drw, |
| device->vk.pd, |
| device->vk.d, |
| device->vk.ac, |
| styling_size_ru, |
| NULL, |
| &impl->vk.d); |
| } |
| else |
| { |
| impl->vk.d = impl->vk.h; |
| } |
| |
| return SPN_SUCCESS; |
| } |
| |
| // |
| // |
| // |
| spinel_deps_immediate_semaphore_t |
| spinel_styling_retain_and_lock(struct spinel_styling * styling) |
| { |
| struct spinel_styling_impl * const impl = styling->impl; |
| |
| assert(impl->state >= SPN_SI_STATE_SEALING); |
| |
| spinel_styling_retain(styling); |
| |
| impl->lock_count += 1; |
| |
| return impl->signal.sealing.immediate; |
| } |
| |
| // |
| // |
| // |
| void |
| spinel_styling_unlock_and_release(struct spinel_styling * styling) |
| { |
| styling->impl->lock_count -= 1; |
| |
| spinel_styling_release(styling); |
| } |
| |
| // |
| // Initialize RENDER push constants with styling bufrefs |
| // |
| void |
| spinel_styling_push_render_init(struct spinel_styling * styling, |
| struct spinel_push_render * push_render) |
| { |
| push_render->devaddr_styling = styling->impl->vk.d.devaddr; |
| } |
| |
| // |
| // |
| // |
