src/intel/vulkan/anv_pass.c

   1 /*
   2  * Copyright © 2015 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #include "anv_private.h"
  25
  26 #include "vk_util.h"
  27
  28 static unsigned
  29 num_subpass_attachments(const VkSubpassDescription *desc)
  30 {
  31    return desc->inputAttachmentCount +
  32           desc->colorAttachmentCount +
  33           (desc->pResolveAttachments ? desc->colorAttachmentCount : 0) +
  34           (desc->pDepthStencilAttachment != NULL);
  35 }
  36
  37 static void
  38 init_first_subpass_layout(struct anv_render_pass_attachment * const att,
  39                           const VkAttachmentReference att_ref)
  40 {
  41    if (att->first_subpass_layout == VK_IMAGE_LAYOUT_UNDEFINED) {
  42       att->first_subpass_layout = att_ref.layout;
  43       assert(att->first_subpass_layout != VK_IMAGE_LAYOUT_UNDEFINED);
  44    }
  45 }
  46
  47 VkResult anv_CreateRenderPass(
  48     VkDevice                                    _device,
  49     const VkRenderPassCreateInfo*               pCreateInfo,
  50     const VkAllocationCallbacks*                pAllocator,
  51     VkRenderPass*                               pRenderPass)
  52 {
  53    ANV_FROM_HANDLE(anv_device, device, _device);
  54
  55    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
  56
  57    struct anv_render_pass *pass;
  58    struct anv_subpass *subpasses;
  59    struct anv_render_pass_attachment *attachments;
  60    enum anv_pipe_bits *subpass_flushes;
  61
  62    ANV_MULTIALLOC(ma);
  63    anv_multialloc_add(&ma, &pass, 1);
  64    anv_multialloc_add(&ma, &subpasses, pCreateInfo->subpassCount);
  65    anv_multialloc_add(&ma, &attachments, pCreateInfo->attachmentCount);
  66    anv_multialloc_add(&ma, &subpass_flushes, pCreateInfo->subpassCount + 1);
  67
  68    VkAttachmentReference *subpass_attachments;
  69    uint32_t subpass_attachment_count = 0;
  70    for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) {
  71       subpass_attachment_count +=
  72          num_subpass_attachments(&pCreateInfo->pSubpasses[i]);
  73    }
  74    anv_multialloc_add(&ma, &subpass_attachments, subpass_attachment_count);
  75
  76    if (!anv_multialloc_alloc2(&ma, &device->alloc, pAllocator,
  77                               VK_SYSTEM_ALLOCATION_SCOPE_OBJECT))
  78       return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
  79
  80    /* Clear the subpasses along with the parent pass. This required because
  81     * each array member of anv_subpass must be a valid pointer if not NULL.
  82     */
  83    memset(pass, 0, ma.size);
  84    pass->attachment_count = pCreateInfo->attachmentCount;
  85    pass->subpass_count = pCreateInfo->subpassCount;
  86    pass->attachments = attachments;
  87    pass->subpass_flushes = subpass_flushes;
  88
  89    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) {
  90       struct anv_render_pass_attachment *att = &pass->attachments[i];
  91
  92       att->format = pCreateInfo->pAttachments[i].format;
  93       att->samples = pCreateInfo->pAttachments[i].samples;
  94       att->usage = 0;
  95       att->load_op = pCreateInfo->pAttachments[i].loadOp;
  96       att->store_op = pCreateInfo->pAttachments[i].storeOp;
  97       att->stencil_load_op = pCreateInfo->pAttachments[i].stencilLoadOp;
  98       att->initial_layout = pCreateInfo->pAttachments[i].initialLayout;
  99       att->final_layout = pCreateInfo->pAttachments[i].finalLayout;
 100       att->first_subpass_layout = VK_IMAGE_LAYOUT_UNDEFINED;
 101    }
 102
 103    bool has_color = false, has_depth = false, has_input = false;
 104    for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) {
 105       const VkSubpassDescription *desc = &pCreateInfo->pSubpasses[i];
 106       struct anv_subpass *subpass = &pass->subpasses[i];
 107
 108       subpass->input_count = desc->inputAttachmentCount;
 109       subpass->color_count = desc->colorAttachmentCount;
 110       subpass->attachment_count = num_subpass_attachments(desc);
 111       subpass->attachments = subpass_attachments;
 112       subpass->view_mask = 0;
 113
 114       if (desc->inputAttachmentCount > 0) {
 115          subpass->input_attachments = subpass_attachments;
 116          subpass_attachments += desc->inputAttachmentCount;
 117
 118          for (uint32_t j = 0; j < desc->inputAttachmentCount; j++) {
 119             uint32_t a = desc->pInputAttachments[j].attachment;
 120             subpass->input_attachments[j] = desc->pInputAttachments[j];
 121             if (a != VK_ATTACHMENT_UNUSED) {
 122                has_input = true;
 123                pass->attachments[a].usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
 124                pass->attachments[a].last_subpass_idx = i;
 125
 126                init_first_subpass_layout(&pass->attachments[a],
 127                                          desc->pInputAttachments[j]);
 128                if (desc->pDepthStencilAttachment &&
 129                    a == desc->pDepthStencilAttachment->attachment)
 130                   subpass->has_ds_self_dep = true;
 131             }
 132          }
 133       }
 134
 135       if (desc->colorAttachmentCount > 0) {
 136          subpass->color_attachments = subpass_attachments;
 137          subpass_attachments += desc->colorAttachmentCount;
 138
 139          for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
 140             uint32_t a = desc->pColorAttachments[j].attachment;
 141             subpass->color_attachments[j] = desc->pColorAttachments[j];
 142             if (a != VK_ATTACHMENT_UNUSED) {
 143                has_color = true;
 144                pass->attachments[a].usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 145                pass->attachments[a].last_subpass_idx = i;
 146
 147                init_first_subpass_layout(&pass->attachments[a],
 148                                          desc->pColorAttachments[j]);
 149             }
 150          }
 151       }
 152
 153       subpass->has_resolve = false;
 154       if (desc->pResolveAttachments) {
 155          subpass->resolve_attachments = subpass_attachments;
 156          subpass_attachments += desc->colorAttachmentCount;
 157
 158          for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
 159             uint32_t a = desc->pResolveAttachments[j].attachment;
 160             subpass->resolve_attachments[j] = desc->pResolveAttachments[j];
 161             if (a != VK_ATTACHMENT_UNUSED) {
 162                subpass->has_resolve = true;
 163                uint32_t color_att = desc->pColorAttachments[j].attachment;
 164                pass->attachments[color_att].usage |=
 165                   VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
 166                pass->attachments[a].usage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 167                pass->attachments[a].last_subpass_idx = i;
 168
 169                init_first_subpass_layout(&pass->attachments[a],
 170                                          desc->pResolveAttachments[j]);
 171             }
 172          }
 173       }
 174
 175       if (desc->pDepthStencilAttachment) {
 176          uint32_t a = desc->pDepthStencilAttachment->attachment;
 177          *subpass_attachments++ = subpass->depth_stencil_attachment =
 178             *desc->pDepthStencilAttachment;
 179          if (a != VK_ATTACHMENT_UNUSED) {
 180             has_depth = true;
 181             pass->attachments[a].usage |=
 182                VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 183             pass->attachments[a].last_subpass_idx = i;
 184
 185             init_first_subpass_layout(&pass->attachments[a],
 186                                       *desc->pDepthStencilAttachment);
 187          }
 188       } else {
 189          subpass->depth_stencil_attachment.attachment = VK_ATTACHMENT_UNUSED;
 190          subpass->depth_stencil_attachment.layout = VK_IMAGE_LAYOUT_UNDEFINED;
 191       }
 192    }
 193
 194    for (uint32_t i = 0; i < pCreateInfo->dependencyCount; i++) {
 195       const VkSubpassDependency *dep = &pCreateInfo->pDependencies[i];
 196       if (dep->dstSubpass == VK_SUBPASS_EXTERNAL) {
 197          pass->subpass_flushes[pass->subpass_count] |=
 198             anv_pipe_invalidate_bits_for_access_flags(dep->dstAccessMask);
 199       } else {
 200          assert(dep->dstSubpass < pass->subpass_count);
 201          pass->subpass_flushes[dep->dstSubpass] |=
 202             anv_pipe_invalidate_bits_for_access_flags(dep->dstAccessMask);
 203       }
 204
 205       if (dep->srcSubpass == VK_SUBPASS_EXTERNAL) {
 206          pass->subpass_flushes[0] |=
 207             anv_pipe_flush_bits_for_access_flags(dep->srcAccessMask);
 208       } else {
 209          assert(dep->srcSubpass < pass->subpass_count);
 210          pass->subpass_flushes[dep->srcSubpass + 1] |=
 211             anv_pipe_flush_bits_for_access_flags(dep->srcAccessMask);
 212       }
 213    }
 214
 215    /* From the Vulkan 1.0.39 spec:
 216     *
 217     *    If there is no subpass dependency from VK_SUBPASS_EXTERNAL to the
 218     *    first subpass that uses an attachment, then an implicit subpass
 219     *    dependency exists from VK_SUBPASS_EXTERNAL to the first subpass it is
 220     *    used in. The subpass dependency operates as if defined with the
 221     *    following parameters:
 222     *
 223     *    VkSubpassDependency implicitDependency = {
 224     *        .srcSubpass = VK_SUBPASS_EXTERNAL;
 225     *        .dstSubpass = firstSubpass; // First subpass attachment is used in
 226     *        .srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 227     *        .dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 228     *        .srcAccessMask = 0;
 229     *        .dstAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
 230     *                         VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
 231     *                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
 232     *                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
 233     *                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 234     *        .dependencyFlags = 0;
 235     *    };
 236     *
 237     *    Similarly, if there is no subpass dependency from the last subpass
 238     *    that uses an attachment to VK_SUBPASS_EXTERNAL, then an implicit
 239     *    subpass dependency exists from the last subpass it is used in to
 240     *    VK_SUBPASS_EXTERNAL. The subpass dependency operates as if defined
 241     *    with the following parameters:
 242     *
 243     *    VkSubpassDependency implicitDependency = {
 244     *        .srcSubpass = lastSubpass; // Last subpass attachment is used in
 245     *        .dstSubpass = VK_SUBPASS_EXTERNAL;
 246     *        .srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 247     *        .dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 248     *        .srcAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
 249     *                         VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
 250     *                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
 251     *                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
 252     *                         VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 253     *        .dstAccessMask = 0;
 254     *        .dependencyFlags = 0;
 255     *    };
 256     *
 257     * We could implement this by walking over all of the attachments and
 258     * subpasses and checking to see if any of them don't have an external
 259     * dependency.  Or, we could just be lazy and add a couple extra flushes.
 260     * We choose to be lazy.
 261     */
 262    if (has_input) {
 263       pass->subpass_flushes[0] |=
 264          ANV_PIPE_TEXTURE_CACHE_INVALIDATE_BIT;
 265    }
 266    if (has_color) {
 267       pass->subpass_flushes[pass->subpass_count] |=
 268          ANV_PIPE_RENDER_TARGET_CACHE_FLUSH_BIT;
 269    }
 270    if (has_depth) {
 271       pass->subpass_flushes[pass->subpass_count] |=
 272          ANV_PIPE_DEPTH_CACHE_FLUSH_BIT;
 273    }
 274
 275    vk_foreach_struct(ext, pCreateInfo->pNext) {
 276       switch (ext->sType) {
 277       case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX: {
 278          VkRenderPassMultiviewCreateInfoKHX *mv = (void *)ext;
 279
 280          for (uint32_t i = 0; i < mv->subpassCount; i++) {
 281             pass->subpasses[i].view_mask = mv->pViewMasks[i];
 282          }
 283          break;
 284       }
 285
 286       default:
 287          anv_debug_ignored_stype(ext->sType);
 288       }
 289    }
 290
 291    *pRenderPass = anv_render_pass_to_handle(pass);
 292
 293    return VK_SUCCESS;
 294 }
 295
 296 void anv_DestroyRenderPass(
 297     VkDevice                                    _device,
 298     VkRenderPass                                _pass,
 299     const VkAllocationCallbacks*                pAllocator)
 300 {
 301    ANV_FROM_HANDLE(anv_device, device, _device);
 302    ANV_FROM_HANDLE(anv_render_pass, pass, _pass);
 303
 304    vk_free2(&device->alloc, pAllocator, pass);
 305 }
 306
 307 void anv_GetRenderAreaGranularity(
 308     VkDevice                                    device,
 309     VkRenderPass                                renderPass,
 310     VkExtent2D*                                 pGranularity)
 311 {
 312    ANV_FROM_HANDLE(anv_render_pass, pass, renderPass);
 313
 314    /* This granularity satisfies HiZ fast clear alignment requirements
 315     * for all sample counts.
 316     */
 317    for (unsigned i = 0; i < pass->subpass_count; ++i) {
 318       if (pass->subpasses[i].depth_stencil_attachment.attachment !=
 319           VK_ATTACHMENT_UNUSED) {
 320          *pGranularity = (VkExtent2D) { .width = 8, .height = 4 };
 321          return;
 322       }
 323    }
 324
 325    *pGranularity = (VkExtent2D) { 1, 1 };
 326 }