anv/tests: Zero-initialize instances

[mesa.git] / src / intel / vulkan / tests / block_pool_no_free.c

diff --git a/src/intel/vulkan/tests/block_pool_no_free.c b/src/intel/vulkan/tests/block_pool_no_free.c
index 17006dd3bc7b3724c700f49012e54036e5fd2421..361336a8e8ee39b392eb26952de5ab2baf45e82b 100644 (file)
--- a/src/intel/vulkan/tests/block_pool_no_free.c
+++ b/src/intel/vulkan/tests/block_pool_no_free.c
@@ -21,6 +21,8 @@
  * IN THE SOFTWARE.
  */
 
+#undef NDEBUG
+
 #include <pthread.h>
 
 #include "anv_private.h"
@@ -33,8 +35,8 @@ struct job {
    pthread_t thread;
    unsigned id;
    struct anv_block_pool *pool;
-   uint32_t blocks[BLOCKS_PER_THREAD];
-   uint32_t back_blocks[BLOCKS_PER_THREAD];
+   int32_t blocks[BLOCKS_PER_THREAD];
+   int32_t back_blocks[BLOCKS_PER_THREAD];
 } jobs[NUM_THREADS];
 
 
@@ -46,14 +48,14 @@ static void *alloc_blocks(void *_job)
    int32_t block, *data;
 
    for (unsigned i = 0; i < BLOCKS_PER_THREAD; i++) {
-      block = anv_block_pool_alloc(job->pool, block_size);
-      data = job->pool->map + block;
+      block = anv_block_pool_alloc(job->pool, block_size, NULL);
+      data = anv_block_pool_map(job->pool, block);
       *data = block;
       assert(block >= 0);
       job->blocks[i] = block;
 
       block = anv_block_pool_alloc_back(job->pool, block_size);
-      data = job->pool->map + block;
+      data = anv_block_pool_map(job->pool, block);
       *data = block;
       assert(block < 0);
       job->back_blocks[i] = -block;
@@ -61,18 +63,18 @@ static void *alloc_blocks(void *_job)
 
    for (unsigned i = 0; i < BLOCKS_PER_THREAD; i++) {
       block = job->blocks[i];
-      data = job->pool->map + block;
+      data = anv_block_pool_map(job->pool, block);
       assert(*data == block);
 
       block = -job->back_blocks[i];
-      data = job->pool->map + block;
+      data = anv_block_pool_map(job->pool, block);
       assert(*data == block);
    }
 
    return NULL;
 }
 
-static void validate_monotonic(uint32_t **blocks)
+static void validate_monotonic(int32_t **blocks)
 {
    /* A list of indices, one per thread */
    unsigned next[NUM_THREADS];
@@ -80,43 +82,43 @@ static void validate_monotonic(uint32_t **blocks)
 
    int highest = -1;
    while (true) {
-      /* First, we find which thread has the highest next element */
-      int thread_max = -1;
-      int max_thread_idx = -1;
+      /* First, we find which thread has the lowest next element */
+      int32_t thread_min = INT32_MAX;
+      int min_thread_idx = -1;
       for (unsigned i = 0; i < NUM_THREADS; i++) {
          if (next[i] >= BLOCKS_PER_THREAD)
             continue;
 
-         if (thread_max < blocks[i][next[i]]) {
-            thread_max = blocks[i][next[i]];
-            max_thread_idx = i;
+         if (thread_min > blocks[i][next[i]]) {
+            thread_min = blocks[i][next[i]];
+            min_thread_idx = i;
          }
       }
 
       /* The only way this can happen is if all of the next[] values are at
        * BLOCKS_PER_THREAD, in which case, we're done.
        */
-      if (thread_max == -1)
+      if (thread_min == INT32_MAX)
          break;
 
       /* That next element had better be higher than the previous highest */
-      assert(blocks[max_thread_idx][next[max_thread_idx]] > highest);
+      assert(blocks[min_thread_idx][next[min_thread_idx]] > highest);
 
-      highest = blocks[max_thread_idx][next[max_thread_idx]];
-      next[max_thread_idx]++;
+      highest = blocks[min_thread_idx][next[min_thread_idx]];
+      next[min_thread_idx]++;
    }
 }
 
 static void run_test()
 {
-   struct anv_instance instance;
+   struct anv_instance instance = { };
    struct anv_device device = {
       .instance = &instance,
    };
    struct anv_block_pool pool;
 
    pthread_mutex_init(&device.mutex, NULL);
-   anv_block_pool_init(&pool, &device, 4096, 4096, 0);
+   anv_block_pool_init(&pool, &device, 4096, 4096);
 
    for (unsigned i = 0; i < NUM_THREADS; i++) {
       jobs[i].pool = &pool;
@@ -128,7 +130,7 @@ static void run_test()
       pthread_join(jobs[i].thread, NULL);
 
    /* Validate that the block allocations were monotonic */
-   uint32_t *block_ptrs[NUM_THREADS];
+   int32_t *block_ptrs[NUM_THREADS];
    for (unsigned i = 0; i < NUM_THREADS; i++)
       block_ptrs[i] = jobs[i].blocks;
    validate_monotonic(block_ptrs);