From ded57c3ccaf79d139ec64ce6711f4de0fea681c7 Mon Sep 17 00:00:00 2001 From: Jason Ekstrand Date: Sat, 20 Feb 2016 11:45:50 -0800 Subject: [PATCH] anv: Use ISL to fill out surface states --- src/intel/vulkan/anv_image.c | 150 ++++++++++++++++++----------------- 1 file changed, 79 insertions(+), 71 deletions(-) diff --git a/src/intel/vulkan/anv_image.c b/src/intel/vulkan/anv_image.c index 0a412a3f8c6..11ceea38829 100644 --- a/src/intel/vulkan/anv_image.c +++ b/src/intel/vulkan/anv_image.c @@ -427,37 +427,6 @@ anv_validate_CreateImageView(VkDevice _device, return anv_CreateImageView(_device, pCreateInfo, pAllocator, pView); } -void -anv_fill_image_surface_state(struct anv_device *device, struct anv_state state, - struct anv_image_view *iview, - const VkImageViewCreateInfo *pCreateInfo, - VkImageUsageFlagBits usage) -{ - switch (device->info.gen) { - case 7: - if (device->info.is_haswell) - gen75_fill_image_surface_state(device, state.map, iview, - pCreateInfo, usage); - else - gen7_fill_image_surface_state(device, state.map, iview, - pCreateInfo, usage); - break; - case 8: - gen8_fill_image_surface_state(device, state.map, iview, - pCreateInfo, usage); - break; - case 9: - gen9_fill_image_surface_state(device, state.map, iview, - pCreateInfo, usage); - break; - default: - unreachable("unsupported gen\n"); - } - - if (!device->info.has_llc) - anv_state_clflush(state); -} - static struct anv_state alloc_surface_state(struct anv_device *device, struct anv_cmd_buffer *cmd_buffer) @@ -479,7 +448,7 @@ has_matching_storage_typed_format(const struct anv_device *device, device->info.gen >= 9); } -static VkComponentSwizzle +static enum isl_channel_select remap_swizzle(VkComponentSwizzle swizzle, VkComponentSwizzle component, struct anv_format_swizzle format_swizzle) { @@ -488,17 +457,17 @@ remap_swizzle(VkComponentSwizzle swizzle, VkComponentSwizzle component, switch (swizzle) { case VK_COMPONENT_SWIZZLE_ZERO: - return VK_COMPONENT_SWIZZLE_ZERO; + return ISL_CHANNEL_SELECT_ZERO; case VK_COMPONENT_SWIZZLE_ONE: - return VK_COMPONENT_SWIZZLE_ONE; + return ISL_CHANNEL_SELECT_ONE; case VK_COMPONENT_SWIZZLE_R: - return VK_COMPONENT_SWIZZLE_R + format_swizzle.r; + return ISL_CHANNEL_SELECT_RED + format_swizzle.r; case VK_COMPONENT_SWIZZLE_G: - return VK_COMPONENT_SWIZZLE_R + format_swizzle.g; + return ISL_CHANNEL_SELECT_RED + format_swizzle.g; case VK_COMPONENT_SWIZZLE_B: - return VK_COMPONENT_SWIZZLE_R + format_swizzle.b; + return ISL_CHANNEL_SELECT_RED + format_swizzle.b; case VK_COMPONENT_SWIZZLE_A: - return VK_COMPONENT_SWIZZLE_R + format_swizzle.a; + return ISL_CHANNEL_SELECT_RED + format_swizzle.a; default: unreachable("Invalid swizzle"); } @@ -513,8 +482,6 @@ anv_image_view_init(struct anv_image_view *iview, { ANV_FROM_HANDLE(anv_image, image, pCreateInfo->image); const VkImageSubresourceRange *range = &pCreateInfo->subresourceRange; - VkImageViewCreateInfo mCreateInfo; - memcpy(&mCreateInfo, pCreateInfo, sizeof(VkImageViewCreateInfo)); assert(range->layerCount > 0); assert(range->baseMipLevel < image->levels); @@ -549,18 +516,30 @@ anv_image_view_init(struct anv_image_view *iview, struct anv_format_swizzle swizzle; iview->format = anv_get_isl_format(pCreateInfo->format, iview->aspect_mask, image->tiling, &swizzle); - iview->swizzle.r = remap_swizzle(pCreateInfo->components.r, - VK_COMPONENT_SWIZZLE_R, swizzle); - iview->swizzle.g = remap_swizzle(pCreateInfo->components.g, - VK_COMPONENT_SWIZZLE_G, swizzle); - iview->swizzle.b = remap_swizzle(pCreateInfo->components.b, - VK_COMPONENT_SWIZZLE_B, swizzle); - iview->swizzle.a = remap_swizzle(pCreateInfo->components.a, - VK_COMPONENT_SWIZZLE_A, swizzle); iview->base_layer = range->baseArrayLayer; iview->base_mip = range->baseMipLevel; + struct isl_view isl_view = { + .format = iview->format, + .base_level = range->baseMipLevel, + .levels = range->levelCount, + .base_array_layer = range->baseArrayLayer, + .array_len = range->layerCount, + .channel_select = { + remap_swizzle(pCreateInfo->components.r, + VK_COMPONENT_SWIZZLE_R, swizzle), + remap_swizzle(pCreateInfo->components.g, + VK_COMPONENT_SWIZZLE_G, swizzle), + remap_swizzle(pCreateInfo->components.b, + VK_COMPONENT_SWIZZLE_B, swizzle), + remap_swizzle(pCreateInfo->components.a, + VK_COMPONENT_SWIZZLE_A, swizzle), + }, + }; + + struct isl_extent4d level0_extent_px; + if (!isl_format_is_compressed(iview->format) && isl_format_is_compressed(image->format->isl_format)) { /* Scale the ImageView extent by the backing Image. This is used @@ -570,31 +549,46 @@ anv_image_view_init(struct anv_image_view *iview, */ const struct isl_format_layout * isl_layout = image->format->isl_layout; - iview->level_0_extent.depth = anv_minify(image->extent.depth, range->baseMipLevel); - iview->level_0_extent.depth = DIV_ROUND_UP(iview->level_0_extent.depth, isl_layout->bd); + level0_extent_px.depth = anv_minify(image->extent.depth, range->baseMipLevel); + level0_extent_px.depth = DIV_ROUND_UP(level0_extent_px.depth, isl_layout->bd); - iview->level_0_extent.height = isl_surf_get_array_pitch_el_rows(&surface->isl) * image->array_size; - iview->level_0_extent.width = isl_surf_get_row_pitch_el(&surface->isl); - mCreateInfo.subresourceRange.baseMipLevel = 0; - mCreateInfo.subresourceRange.baseArrayLayer = 0; + level0_extent_px.height = isl_surf_get_array_pitch_el_rows(&surface->isl) * image->array_size; + level0_extent_px.width = isl_surf_get_row_pitch_el(&surface->isl); + isl_view.base_level = 0; + isl_view.base_array_layer = 0; } else { - iview->level_0_extent.width = image->extent.width; - iview->level_0_extent.height = image->extent.height; - iview->level_0_extent.depth = image->extent.depth; + level0_extent_px.width = image->extent.width; + level0_extent_px.height = image->extent.height; + level0_extent_px.depth = image->extent.depth; } iview->extent = (VkExtent3D) { - .width = anv_minify(iview->level_0_extent.width , range->baseMipLevel), - .height = anv_minify(iview->level_0_extent.height, range->baseMipLevel), - .depth = anv_minify(iview->level_0_extent.depth , range->baseMipLevel), + .width = anv_minify(image->extent.width , range->baseMipLevel), + .height = anv_minify(image->extent.height, range->baseMipLevel), + .depth = anv_minify(image->extent.depth , range->baseMipLevel), }; + isl_surf_usage_flags_t cube_usage; + if (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE || + pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY) { + cube_usage = ISL_SURF_USAGE_CUBE_BIT; + } else { + cube_usage = 0; + } + if (image->usage & VK_IMAGE_USAGE_SAMPLED_BIT) { iview->sampler_surface_state = alloc_surface_state(device, cmd_buffer); - anv_fill_image_surface_state(device, iview->sampler_surface_state, - iview, &mCreateInfo, - VK_IMAGE_USAGE_SAMPLED_BIT); + isl_view.usage = cube_usage | ISL_SURF_USAGE_TEXTURE_BIT; + isl_surf_fill_state(&device->isl_dev, + iview->sampler_surface_state.map, + .surf = &surface->isl, + .view = &isl_view, + .mocs = device->default_mocs, + .level0_extent_px = level0_extent_px); + + if (!device->info.has_llc) + anv_state_clflush(iview->sampler_surface_state); } else { iview->sampler_surface_state.alloc_size = 0; } @@ -602,9 +596,16 @@ anv_image_view_init(struct anv_image_view *iview, if (image->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) { iview->color_rt_surface_state = alloc_surface_state(device, cmd_buffer); - anv_fill_image_surface_state(device, iview->color_rt_surface_state, - iview, &mCreateInfo, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT); + isl_view.usage = cube_usage | ISL_SURF_USAGE_RENDER_TARGET_BIT; + isl_surf_fill_state(&device->isl_dev, + iview->color_rt_surface_state.map, + .surf = &surface->isl, + .view = &isl_view, + .mocs = device->default_mocs, + .level0_extent_px = level0_extent_px); + + if (!device->info.has_llc) + anv_state_clflush(iview->color_rt_surface_state); } else { iview->color_rt_surface_state.alloc_size = 0; } @@ -612,16 +613,23 @@ anv_image_view_init(struct anv_image_view *iview, if (image->usage & VK_IMAGE_USAGE_STORAGE_BIT) { iview->storage_surface_state = alloc_surface_state(device, cmd_buffer); - if (has_matching_storage_typed_format(device, iview->format)) - anv_fill_image_surface_state(device, iview->storage_surface_state, - iview, &mCreateInfo, - VK_IMAGE_USAGE_STORAGE_BIT); - else + if (has_matching_storage_typed_format(device, iview->format)) { + isl_view.usage = cube_usage | ISL_SURF_USAGE_STORAGE_BIT; + isl_surf_fill_state(&device->isl_dev, + iview->storage_surface_state.map, + .surf = &surface->isl, + .view = &isl_view, + .mocs = device->default_mocs, + .level0_extent_px = level0_extent_px); + } else { anv_fill_buffer_surface_state(device, iview->storage_surface_state, ISL_FORMAT_RAW, iview->offset, iview->bo->size - iview->offset, 1); + } + if (!device->info.has_llc) + anv_state_clflush(iview->storage_surface_state); } else { iview->storage_surface_state.alloc_size = 0; } -- 2.30.2