src/intel/vulkan/genX_blorp_exec.c

   1 /*
   2  * Copyright © 2016 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 <assert.h>
  25
  26 #include "anv_private.h"
  27
  28 /* These are defined in anv_private.h and blorp_genX_exec.h */
  29 #undef __gen_address_type
  30 #undef __gen_user_data
  31 #undef __gen_combine_address
  32
  33 #include "common/gen_l3_config.h"
  34 #include "common/gen_sample_positions.h"
  35 #include "blorp/blorp_genX_exec.h"
  36
  37 static void *
  38 blorp_emit_dwords(struct blorp_batch *batch, unsigned n)
  39 {
  40    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
  41    return anv_batch_emit_dwords(&cmd_buffer->batch, n);
  42 }
  43
  44 static uint64_t
  45 blorp_emit_reloc(struct blorp_batch *batch,
  46                  void *location, struct blorp_address address, uint32_t delta)
  47 {
  48    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
  49    assert(cmd_buffer->batch.start <= location &&
  50           location < cmd_buffer->batch.end);
  51    return anv_batch_emit_reloc(&cmd_buffer->batch, location,
  52                                address.buffer, address.offset + delta);
  53 }
  54
  55 static void
  56 blorp_surface_reloc(struct blorp_batch *batch, uint32_t ss_offset,
  57                     struct blorp_address address, uint32_t delta)
  58 {
  59    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
  60    VkResult result =
  61       anv_reloc_list_add(&cmd_buffer->surface_relocs, &cmd_buffer->pool->alloc,
  62                          ss_offset, address.buffer, address.offset + delta);
  63    if (result != VK_SUCCESS)
  64       anv_batch_set_error(&cmd_buffer->batch, result);
  65 }
  66
  67 static void *
  68 blorp_alloc_dynamic_state(struct blorp_batch *batch,
  69                           enum aub_state_struct_type type,
  70                           uint32_t size,
  71                           uint32_t alignment,
  72                           uint32_t *offset)
  73 {
  74    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
  75
  76    struct anv_state state =
  77       anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, size, alignment);
  78
  79    *offset = state.offset;
  80    return state.map;
  81 }
  82
  83 static void
  84 blorp_alloc_binding_table(struct blorp_batch *batch, unsigned num_entries,
  85                           unsigned state_size, unsigned state_alignment,
  86                           uint32_t *bt_offset,
  87                           uint32_t *surface_offsets, void **surface_maps)
  88 {
  89    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
  90
  91    uint32_t state_offset;
  92    struct anv_state bt_state;
  93
  94    VkResult result =
  95       anv_cmd_buffer_alloc_blorp_binding_table(cmd_buffer, num_entries,
  96                                                &state_offset, &bt_state);
  97    if (result != VK_SUCCESS)
  98       return;
  99
 100    uint32_t *bt_map = bt_state.map;
 101    *bt_offset = bt_state.offset;
 102
 103    for (unsigned i = 0; i < num_entries; i++) {
 104       struct anv_state surface_state =
 105          anv_cmd_buffer_alloc_surface_state(cmd_buffer);
 106       bt_map[i] = surface_state.offset + state_offset;
 107       surface_offsets[i] = surface_state.offset;
 108       surface_maps[i] = surface_state.map;
 109    }
 110
 111    anv_state_flush(cmd_buffer->device, bt_state);
 112 }
 113
 114 static void *
 115 blorp_alloc_vertex_buffer(struct blorp_batch *batch, uint32_t size,
 116                           struct blorp_address *addr)
 117 {
 118    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
 119    struct anv_state vb_state =
 120       anv_cmd_buffer_alloc_dynamic_state(cmd_buffer, size, 16);
 121
 122    *addr = (struct blorp_address) {
 123       .buffer = &cmd_buffer->device->dynamic_state_block_pool.bo,
 124       .offset = vb_state.offset,
 125    };
 126
 127    return vb_state.map;
 128 }
 129
 130 static void
 131 blorp_flush_range(struct blorp_batch *batch, void *start, size_t size)
 132 {
 133    struct anv_device *device = batch->blorp->driver_ctx;
 134    if (!device->info.has_llc)
 135       anv_flush_range(start, size);
 136 }
 137
 138 static void
 139 blorp_emit_urb_config(struct blorp_batch *batch, unsigned vs_entry_size)
 140 {
 141    struct anv_device *device = batch->blorp->driver_ctx;
 142    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
 143
 144    const unsigned entry_size[4] = { vs_entry_size, 1, 1, 1 };
 145
 146    genX(emit_urb_setup)(device, &cmd_buffer->batch,
 147                         cmd_buffer->state.current_l3_config,
 148                         VK_SHADER_STAGE_VERTEX_BIT |
 149                         VK_SHADER_STAGE_FRAGMENT_BIT,
 150                         entry_size);
 151 }
 152
 153 void
 154 genX(blorp_exec)(struct blorp_batch *batch,
 155                  const struct blorp_params *params)
 156 {
 157    struct anv_cmd_buffer *cmd_buffer = batch->driver_batch;
 158
 159    if (!cmd_buffer->state.current_l3_config) {
 160       const struct gen_l3_config *cfg =
 161          gen_get_default_l3_config(&cmd_buffer->device->info);
 162       genX(cmd_buffer_config_l3)(cmd_buffer, cfg);
 163    }
 164
 165    genX(cmd_buffer_apply_pipe_flushes)(cmd_buffer);
 166
 167    genX(flush_pipeline_select_3d)(cmd_buffer);
 168
 169    genX(cmd_buffer_emit_gen7_depth_flush)(cmd_buffer);
 170
 171    /* BLORP doesn't do anything fancy with depth such as discards, so we want
 172     * the PMA fix off.  Also, off is always the safe option.
 173     */
 174    genX(cmd_buffer_enable_pma_fix)(cmd_buffer, false);
 175
 176    blorp_exec(batch, params);
 177
 178    cmd_buffer->state.vb_dirty = ~0;
 179    cmd_buffer->state.dirty = ~0;
 180    cmd_buffer->state.push_constants_dirty = ~0;
 181 }