src/broadcom/compiler/vir_lower_uniforms.c

   1 /*
   2  * Copyright © 2014 Broadcom
   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 /**
  25  * @file v3d_vir_lower_uniforms.c
  26  *
  27  * This is the pre-code-generation pass for fixing up instructions that try to
  28  * read from multiple uniform values.
  29  */
  30
  31 #include "v3d_compiler.h"
  32 #include "util/hash_table.h"
  33 #include "util/u_math.h"
  34
  35 static inline uint32_t
  36 index_hash(const void *key)
  37 {
  38         return (uintptr_t)key;
  39 }
  40
  41 static inline bool
  42 index_compare(const void *a, const void *b)
  43 {
  44         return a == b;
  45 }
  46
  47 static void
  48 add_uniform(struct hash_table *ht, struct qreg reg)
  49 {
  50         struct hash_entry *entry;
  51         void *key = (void *)(uintptr_t)(reg.index + 1);
  52
  53         entry = _mesa_hash_table_search(ht, key);
  54         if (entry) {
  55                 entry->data++;
  56         } else {
  57                 _mesa_hash_table_insert(ht, key, (void *)(uintptr_t)1);
  58         }
  59 }
  60
  61 static void
  62 remove_uniform(struct hash_table *ht, struct qreg reg)
  63 {
  64         struct hash_entry *entry;
  65         void *key = (void *)(uintptr_t)(reg.index + 1);
  66
  67         entry = _mesa_hash_table_search(ht, key);
  68         assert(entry);
  69         entry->data = (void *)(((uintptr_t) entry->data) - 1);
  70         if (entry->data == NULL)
  71                 _mesa_hash_table_remove(ht, entry);
  72 }
  73
  74 static bool
  75 is_lowerable_uniform(struct qinst *inst, int i)
  76 {
  77         if (inst->src[i].file != QFILE_UNIF)
  78                 return false;
  79         return i != vir_get_implicit_uniform_src(inst);
  80 }
  81
  82 /* Returns the number of different uniform values referenced by the
  83  * instruction.
  84  */
  85 static uint32_t
  86 vir_get_instruction_uniform_count(struct qinst *inst)
  87 {
  88         uint32_t count = 0;
  89
  90         for (int i = 0; i < vir_get_nsrc(inst); i++) {
  91                 if (inst->src[i].file != QFILE_UNIF)
  92                         continue;
  93
  94                 bool is_duplicate = false;
  95                 for (int j = 0; j < i; j++) {
  96                         if (inst->src[j].file == QFILE_UNIF &&
  97                             inst->src[j].index == inst->src[i].index) {
  98                                 is_duplicate = true;
  99                                 break;
 100                         }
 101                 }
 102                 if (!is_duplicate)
 103                         count++;
 104         }
 105
 106         return count;
 107 }
 108
 109 void
 110 vir_lower_uniforms(struct v3d_compile *c)
 111 {
 112         struct hash_table *ht =
 113                 _mesa_hash_table_create(c, index_hash, index_compare);
 114
 115         /* Walk the instruction list, finding which instructions have more
 116          * than one uniform referenced, and add those uniform values to the
 117          * ht.
 118          */
 119         vir_for_each_inst_inorder(inst, c) {
 120                 uint32_t nsrc = vir_get_nsrc(inst);
 121
 122                 if (vir_get_instruction_uniform_count(inst) <= 1)
 123                         continue;
 124
 125                 for (int i = 0; i < nsrc; i++) {
 126                         if (is_lowerable_uniform(inst, i))
 127                                 add_uniform(ht, inst->src[i]);
 128                 }
 129         }
 130
 131         while (ht->entries) {
 132                 /* Find the most commonly used uniform in instructions that
 133                  * need a uniform lowered.
 134                  */
 135                 uint32_t max_count = 0;
 136                 uint32_t max_index = 0;
 137                 struct hash_entry *entry;
 138                 hash_table_foreach(ht, entry) {
 139                         uint32_t count = (uintptr_t)entry->data;
 140                         uint32_t index = (uintptr_t)entry->key - 1;
 141                         if (count > max_count) {
 142                                 max_count = count;
 143                                 max_index = index;
 144                         }
 145                 }
 146
 147                 struct qreg unif = vir_reg(QFILE_UNIF, max_index);
 148
 149                 /* Now, find the instructions using this uniform and make them
 150                  * reference a temp instead.
 151                  */
 152                 vir_for_each_block(block, c) {
 153                         struct qreg temp = c->undef;
 154
 155                         vir_for_each_inst(inst, block) {
 156                                 uint32_t nsrc = vir_get_nsrc(inst);
 157
 158                                 uint32_t count = vir_get_instruction_uniform_count(inst);
 159
 160                                 if (count <= 1)
 161                                         continue;
 162
 163                                 bool removed = false;
 164                                 for (int i = 0; i < nsrc; i++) {
 165                                         if (is_lowerable_uniform(inst, i) &&
 166                                             inst->src[i].index == max_index) {
 167                                                 /* If the block doesn't have a
 168                                                  * load of the uniform yet,
 169                                                  * add it now.  We could
 170                                                  * potentially do better and
 171                                                  * CSE MOVs from multiple
 172                                                  * blocks into dominating
 173                                                  * blocks, except that may
 174                                                  * cause troubles for register
 175                                                  * allocation.
 176                                                  */
 177                                                 if (temp.file == QFILE_NULL) {
 178                                                         c->cursor =
 179                                                                 vir_before_inst(inst);
 180                                                         temp = vir_MOV(c, unif);
 181                                                 }
 182
 183                                                 inst->src[i] = temp;
 184                                                 remove_uniform(ht, unif);
 185                                                 removed = true;
 186                                         }
 187                                 }
 188                                 if (removed)
 189                                         count--;
 190
 191                                 /* If the instruction doesn't need lowering any more,
 192                                  * then drop it from the list.
 193                                  */
 194                                 if (count <= 1) {
 195                                         for (int i = 0; i < nsrc; i++) {
 196                                                 if (is_lowerable_uniform(inst, i))
 197                                                         remove_uniform(ht, inst->src[i]);
 198                                         }
 199                                 }
 200                         }
 201                 }
 202         }
 203
 204         _mesa_hash_table_destroy(ht, NULL);
 205 }