/* * Copyright © 2016 Red Hat * based on intel anv code: * Copyright © 2015 Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ #include "radv_meta.h" #include #include #include #include void radv_meta_save(struct radv_meta_saved_state *state, const struct radv_cmd_buffer *cmd_buffer, uint32_t dynamic_mask) { state->old_pipeline = cmd_buffer->state.pipeline; state->old_descriptor_set0 = cmd_buffer->state.descriptors[0]; memcpy(state->old_vertex_bindings, cmd_buffer->state.vertex_bindings, sizeof(state->old_vertex_bindings)); state->dynamic_mask = dynamic_mask; radv_dynamic_state_copy(&state->dynamic, &cmd_buffer->state.dynamic, dynamic_mask); memcpy(state->push_constants, cmd_buffer->push_constants, MAX_PUSH_CONSTANTS_SIZE); } void radv_meta_restore(const struct radv_meta_saved_state *state, struct radv_cmd_buffer *cmd_buffer) { cmd_buffer->state.pipeline = state->old_pipeline; radv_bind_descriptor_set(cmd_buffer, state->old_descriptor_set0, 0); memcpy(cmd_buffer->state.vertex_bindings, state->old_vertex_bindings, sizeof(state->old_vertex_bindings)); cmd_buffer->state.vb_dirty |= (1 << RADV_META_VERTEX_BINDING_COUNT) - 1; cmd_buffer->state.dirty |= RADV_CMD_DIRTY_PIPELINE; radv_dynamic_state_copy(&cmd_buffer->state.dynamic, &state->dynamic, state->dynamic_mask); cmd_buffer->state.dirty |= state->dynamic_mask; memcpy(cmd_buffer->push_constants, state->push_constants, MAX_PUSH_CONSTANTS_SIZE); cmd_buffer->push_constant_stages |= VK_SHADER_STAGE_ALL_GRAPHICS | VK_SHADER_STAGE_COMPUTE_BIT; } void radv_meta_save_pass(struct radv_meta_saved_pass_state *state, const struct radv_cmd_buffer *cmd_buffer) { state->pass = cmd_buffer->state.pass; state->subpass = cmd_buffer->state.subpass; state->framebuffer = cmd_buffer->state.framebuffer; state->attachments = cmd_buffer->state.attachments; state->render_area = cmd_buffer->state.render_area; } void radv_meta_restore_pass(const struct radv_meta_saved_pass_state *state, struct radv_cmd_buffer *cmd_buffer) { cmd_buffer->state.pass = state->pass; cmd_buffer->state.subpass = state->subpass; cmd_buffer->state.framebuffer = state->framebuffer; cmd_buffer->state.attachments = state->attachments; cmd_buffer->state.render_area = state->render_area; if (state->subpass) radv_emit_framebuffer_state(cmd_buffer); } void radv_meta_save_compute(struct radv_meta_saved_compute_state *state, const struct radv_cmd_buffer *cmd_buffer, unsigned push_constant_size) { state->old_pipeline = cmd_buffer->state.compute_pipeline; state->old_descriptor_set0 = cmd_buffer->state.descriptors[0]; if (push_constant_size) memcpy(state->push_constants, cmd_buffer->push_constants, push_constant_size); } void radv_meta_restore_compute(const struct radv_meta_saved_compute_state *state, struct radv_cmd_buffer *cmd_buffer, unsigned push_constant_size) { radv_CmdBindPipeline(radv_cmd_buffer_to_handle(cmd_buffer), VK_PIPELINE_BIND_POINT_COMPUTE, radv_pipeline_to_handle(state->old_pipeline)); radv_bind_descriptor_set(cmd_buffer, state->old_descriptor_set0, 0); if (push_constant_size) { memcpy(cmd_buffer->push_constants, state->push_constants, push_constant_size); cmd_buffer->push_constant_stages |= VK_SHADER_STAGE_COMPUTE_BIT; } } VkImageViewType radv_meta_get_view_type(const struct radv_image *image) { switch (image->type) { case VK_IMAGE_TYPE_1D: return VK_IMAGE_VIEW_TYPE_1D; case VK_IMAGE_TYPE_2D: return VK_IMAGE_VIEW_TYPE_2D; case VK_IMAGE_TYPE_3D: return VK_IMAGE_VIEW_TYPE_3D; default: unreachable("bad VkImageViewType"); } } /** * When creating a destination VkImageView, this function provides the needed * VkImageViewCreateInfo::subresourceRange::baseArrayLayer. */ uint32_t radv_meta_get_iview_layer(const struct radv_image *dest_image, const VkImageSubresourceLayers *dest_subresource, const VkOffset3D *dest_offset) { switch (dest_image->type) { case VK_IMAGE_TYPE_1D: case VK_IMAGE_TYPE_2D: return dest_subresource->baseArrayLayer; case VK_IMAGE_TYPE_3D: /* HACK: Vulkan does not allow attaching a 3D image to a framebuffer, * but meta does it anyway. When doing so, we translate the * destination's z offset into an array offset. */ return dest_offset->z; default: assert(!"bad VkImageType"); return 0; } } static void * meta_alloc(void* _device, size_t size, size_t alignment, VkSystemAllocationScope allocationScope) { struct radv_device *device = _device; return device->alloc.pfnAllocation(device->alloc.pUserData, size, alignment, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); } static void * meta_realloc(void* _device, void *original, size_t size, size_t alignment, VkSystemAllocationScope allocationScope) { struct radv_device *device = _device; return device->alloc.pfnReallocation(device->alloc.pUserData, original, size, alignment, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); } static void meta_free(void* _device, void *data) { struct radv_device *device = _device; return device->alloc.pfnFree(device->alloc.pUserData, data); } static bool radv_builtin_cache_path(char *path) { char *xdg_cache_home = getenv("XDG_CACHE_HOME"); const char *suffix = "/radv_builtin_shaders"; const char *suffix2 = "/.cache/radv_builtin_shaders"; struct passwd pwd, *result; char path2[PATH_MAX + 1]; /* PATH_MAX is not a real max,but suffices here. */ if (xdg_cache_home) { if (strlen(xdg_cache_home) + strlen(suffix) > PATH_MAX) return false; strcpy(path, xdg_cache_home); strcat(path, suffix); return true; } getpwuid_r(getuid(), &pwd, path2, PATH_MAX - strlen(suffix2), &result); if (!result) return false; strcpy(path, pwd.pw_dir); strcat(path, "/.cache"); mkdir(path, 0755); strcat(path, suffix); return true; } static void radv_load_meta_pipeline(struct radv_device *device) { char path[PATH_MAX + 1]; struct stat st; void *data = NULL; if (!radv_builtin_cache_path(path)) return; int fd = open(path, O_RDONLY); if (fd < 0) return; if (fstat(fd, &st)) goto fail; data = malloc(st.st_size); if (!data) goto fail; if(read(fd, data, st.st_size) == -1) goto fail; radv_pipeline_cache_load(&device->meta_state.cache, data, st.st_size); fail: free(data); close(fd); } static void radv_store_meta_pipeline(struct radv_device *device) { char path[PATH_MAX + 1], path2[PATH_MAX + 7]; size_t size; void *data = NULL; if (!device->meta_state.cache.modified) return; if (radv_GetPipelineCacheData(radv_device_to_handle(device), radv_pipeline_cache_to_handle(&device->meta_state.cache), &size, NULL)) return; if (!radv_builtin_cache_path(path)) return; strcpy(path2, path); strcat(path2, "XXXXXX"); int fd = mkstemp(path2);//open(path, O_WRONLY | O_CREAT, 0600); if (fd < 0) return; data = malloc(size); if (!data) goto fail; if (radv_GetPipelineCacheData(radv_device_to_handle(device), radv_pipeline_cache_to_handle(&device->meta_state.cache), &size, data)) goto fail; if(write(fd, data, size) == -1) goto fail; rename(path2, path); fail: free(data); close(fd); unlink(path2); } VkResult radv_device_init_meta(struct radv_device *device) { VkResult result; device->meta_state.alloc = (VkAllocationCallbacks) { .pUserData = device, .pfnAllocation = meta_alloc, .pfnReallocation = meta_realloc, .pfnFree = meta_free, }; device->meta_state.cache.alloc = device->meta_state.alloc; radv_pipeline_cache_init(&device->meta_state.cache, device); radv_load_meta_pipeline(device); result = radv_device_init_meta_clear_state(device); if (result != VK_SUCCESS) goto fail_clear; result = radv_device_init_meta_resolve_state(device); if (result != VK_SUCCESS) goto fail_resolve; result = radv_device_init_meta_blit_state(device); if (result != VK_SUCCESS) goto fail_blit; result = radv_device_init_meta_blit2d_state(device); if (result != VK_SUCCESS) goto fail_blit2d; result = radv_device_init_meta_bufimage_state(device); if (result != VK_SUCCESS) goto fail_bufimage; result = radv_device_init_meta_depth_decomp_state(device); if (result != VK_SUCCESS) goto fail_depth_decomp; result = radv_device_init_meta_buffer_state(device); if (result != VK_SUCCESS) goto fail_buffer; result = radv_device_init_meta_fast_clear_flush_state(device); if (result != VK_SUCCESS) goto fail_fast_clear; result = radv_device_init_meta_resolve_compute_state(device); if (result != VK_SUCCESS) goto fail_resolve_compute; return VK_SUCCESS; fail_resolve_compute: radv_device_finish_meta_fast_clear_flush_state(device); fail_fast_clear: radv_device_finish_meta_buffer_state(device); fail_buffer: radv_device_finish_meta_depth_decomp_state(device); fail_depth_decomp: radv_device_finish_meta_bufimage_state(device); fail_bufimage: radv_device_finish_meta_blit2d_state(device); fail_blit2d: radv_device_finish_meta_blit_state(device); fail_blit: radv_device_finish_meta_resolve_state(device); fail_resolve: radv_device_finish_meta_clear_state(device); fail_clear: radv_pipeline_cache_finish(&device->meta_state.cache); return result; } void radv_device_finish_meta(struct radv_device *device) { radv_device_finish_meta_clear_state(device); radv_device_finish_meta_resolve_state(device); radv_device_finish_meta_blit_state(device); radv_device_finish_meta_blit2d_state(device); radv_device_finish_meta_bufimage_state(device); radv_device_finish_meta_depth_decomp_state(device); radv_device_finish_meta_buffer_state(device); radv_device_finish_meta_fast_clear_flush_state(device); radv_device_finish_meta_resolve_compute_state(device); radv_store_meta_pipeline(device); radv_pipeline_cache_finish(&device->meta_state.cache); } /* * The most common meta operations all want to have the viewport * reset and any scissors disabled. The rest of the dynamic state * should have no effect. */ void radv_meta_save_graphics_reset_vport_scissor(struct radv_meta_saved_state *saved_state, struct radv_cmd_buffer *cmd_buffer) { uint32_t dirty_state = (1 << VK_DYNAMIC_STATE_VIEWPORT) | (1 << VK_DYNAMIC_STATE_SCISSOR); radv_meta_save(saved_state, cmd_buffer, dirty_state); cmd_buffer->state.dynamic.viewport.count = 0; cmd_buffer->state.dynamic.scissor.count = 0; cmd_buffer->state.dirty |= dirty_state; }