util: Change a codegenned switch statement to a nice little table.

[mesa.git] / src / util / register_allocate.c

diff --git a/src/util/register_allocate.c b/src/util/register_allocate.c
index 75f612480828565fc3fba59480fa473e95025b65..1d9a074174fc297b0ede8847b307efef9cb59dd9 100644 (file)
--- a/src/util/register_allocate.c
+++ b/src/util/register_allocate.c
@@ -73,6 +73,7 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
+#include "blob.h"
 #include "ralloc.h"
 #include "main/macros.h"
 #include "util/bitset.h"
@@ -82,9 +83,7 @@
 
 struct ra_reg {
    BITSET_WORD *conflicts;
-   unsigned int *conflict_list;
-   unsigned int conflict_list_size;
-   unsigned int num_conflicts;
+   struct util_dynarray conflict_list;
 };
 
 struct ra_regs {
@@ -225,16 +224,10 @@ ra_alloc_reg_set(void *mem_ctx, unsigned int count, bool need_conflict_lists)
                                               BITSET_WORDS(count));
       BITSET_SET(regs->regs[i].conflicts, i);
 
-      if (need_conflict_lists) {
-         regs->regs[i].conflict_list = ralloc_array(regs->regs,
-                                                    unsigned int, 4);
-         regs->regs[i].conflict_list_size = 4;
-         regs->regs[i].conflict_list[0] = i;
-      } else {
-         regs->regs[i].conflict_list = NULL;
-         regs->regs[i].conflict_list_size = 0;
-      }
-      regs->regs[i].num_conflicts = 1;
+      util_dynarray_init(&regs->regs[i].conflict_list,
+                         need_conflict_lists ? regs->regs : NULL);
+      if (need_conflict_lists)
+         util_dynarray_append(&regs->regs[i].conflict_list, unsigned int, i);
    }
 
    return regs;
@@ -261,13 +254,8 @@ ra_add_conflict_list(struct ra_regs *regs, unsigned int r1, unsigned int r2)
 {
    struct ra_reg *reg1 = &regs->regs[r1];
 
-   if (reg1->conflict_list) {
-      if (reg1->conflict_list_size == reg1->num_conflicts) {
-         reg1->conflict_list_size *= 2;
-         reg1->conflict_list = reralloc(regs->regs, reg1->conflict_list,
-                                        unsigned int, reg1->conflict_list_size);
-      }
-      reg1->conflict_list[reg1->num_conflicts++] = r2;
+   if (reg1->conflict_list.mem_ctx) {
+      util_dynarray_append(&reg1->conflict_list, unsigned int, r2);
    }
    BITSET_SET(reg1->conflicts, r2);
 }
@@ -293,12 +281,11 @@ void
 ra_add_transitive_reg_conflict(struct ra_regs *regs,
                                unsigned int base_reg, unsigned int reg)
 {
-   unsigned int i;
-
    ra_add_reg_conflict(regs, reg, base_reg);
 
-   for (i = 0; i < regs->regs[base_reg].num_conflicts; i++) {
-      ra_add_reg_conflict(regs, reg, regs->regs[base_reg].conflict_list[i]);
+   util_dynarray_foreach(&regs->regs[base_reg].conflict_list, unsigned int,
+                         r2p) {
+      ra_add_reg_conflict(regs, reg, *r2p);
    }
 }
 
@@ -313,17 +300,15 @@ void
 ra_add_transitive_reg_pair_conflict(struct ra_regs *regs,
                                     unsigned int base_reg, unsigned int reg0, unsigned int reg1)
 {
-   unsigned int i;
-
    ra_add_reg_conflict(regs, reg0, base_reg);
    ra_add_reg_conflict(regs, reg1, base_reg);
 
-   for (i = 0; i < regs->regs[base_reg].num_conflicts; i++) {
-      unsigned int conflict = regs->regs[base_reg].conflict_list[i];
+   util_dynarray_foreach(&regs->regs[base_reg].conflict_list, unsigned int, i) {
+      unsigned int conflict = *i;
       if (conflict != reg1)
-         ra_add_reg_conflict(regs, reg0, regs->regs[base_reg].conflict_list[i]);
+         ra_add_reg_conflict(regs, reg0, conflict);
       if (conflict != reg0)
-         ra_add_reg_conflict(regs, reg1, regs->regs[base_reg].conflict_list[i]);
+         ra_add_reg_conflict(regs, reg1, conflict);
    }
 }
 
@@ -416,15 +401,12 @@ ra_set_finalize(struct ra_regs *regs, unsigned int **q_values)
             unsigned int rc;
             int max_conflicts = 0;
 
-            for (rc = 0; rc < regs->count; rc++) {
+            BITSET_FOREACH_SET(rc, regs->classes[c]->regs, regs->count) {
                int conflicts = 0;
-               unsigned int i;
-
-               if (!reg_belongs_to_class(rc, regs->classes[c]))
-                  continue;
 
-               for (i = 0; i < regs->regs[rc].num_conflicts; i++) {
-                  unsigned int rb = regs->regs[rc].conflict_list[i];
+               util_dynarray_foreach(&regs->regs[rc].conflict_list,
+                                     unsigned int, rbp) {
+                  unsigned int rb = *rbp;
                   if (reg_belongs_to_class(rb, regs->classes[b]))
                      conflicts++;
                }
@@ -436,9 +418,70 @@ ra_set_finalize(struct ra_regs *regs, unsigned int **q_values)
    }
 
    for (b = 0; b < regs->count; b++) {
-      ralloc_free(regs->regs[b].conflict_list);
-      regs->regs[b].conflict_list = NULL;
+      util_dynarray_fini(&regs->regs[b].conflict_list);
+   }
+}
+
+void
+ra_set_serialize(const struct ra_regs *regs, struct blob *blob)
+{
+   blob_write_uint32(blob, regs->count);
+   blob_write_uint32(blob, regs->class_count);
+
+   for (unsigned int r = 0; r < regs->count; r++) {
+      struct ra_reg *reg = &regs->regs[r];
+      blob_write_bytes(blob, reg->conflicts, BITSET_WORDS(regs->count) *
+                                             sizeof(BITSET_WORD));
+      assert(util_dynarray_num_elements(&reg->conflict_list, unsigned int) == 0);
+   }
+
+   for (unsigned int c = 0; c < regs->class_count; c++) {
+      struct ra_class *class = regs->classes[c];
+      blob_write_bytes(blob, class->regs, BITSET_WORDS(regs->count) *
+                                          sizeof(BITSET_WORD));
+      blob_write_uint32(blob, class->p);
+      blob_write_bytes(blob, class->q, regs->class_count * sizeof(*class->q));
+   }
+
+   blob_write_uint32(blob, regs->round_robin);
+}
+
+struct ra_regs *
+ra_set_deserialize(void *mem_ctx, struct blob_reader *blob)
+{
+   unsigned int reg_count = blob_read_uint32(blob);
+   unsigned int class_count = blob_read_uint32(blob);
+
+   struct ra_regs *regs = ra_alloc_reg_set(mem_ctx, reg_count, false);
+   assert(regs->count == reg_count);
+
+   for (unsigned int r = 0; r < reg_count; r++) {
+      struct ra_reg *reg = &regs->regs[r];
+      blob_copy_bytes(blob, reg->conflicts, BITSET_WORDS(reg_count) *
+                                            sizeof(BITSET_WORD));
+   }
+
+   assert(regs->classes == NULL);
+   regs->classes = ralloc_array(regs->regs, struct ra_class *, class_count);
+   regs->class_count = class_count;
+
+   for (unsigned int c = 0; c < class_count; c++) {
+      struct ra_class *class = rzalloc(regs, struct ra_class);
+      regs->classes[c] = class;
+
+      class->regs = ralloc_array(class, BITSET_WORD, BITSET_WORDS(reg_count));
+      blob_copy_bytes(blob, class->regs, BITSET_WORDS(reg_count) *
+                                         sizeof(BITSET_WORD));
+
+      class->p = blob_read_uint32(blob);
+
+      class->q = ralloc_array(regs->classes[c], unsigned int, class_count);
+      blob_copy_bytes(blob, class->q, class_count * sizeof(*class->q));
    }
+
+   regs->round_robin = blob_read_uint32(blob);
+
+   return regs;
 }
 
 static void