anv/tests: Fix block_pool_no_free test.

[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 0a61818e42cc1818ee8d53c626cfef3c0abf935d..787abf0582033c794fa1853b3200ed1427ebfeac 100644 (file)
--- a/src/intel/vulkan/tests/block_pool_no_free.c
+++ b/src/intel/vulkan/tests/block_pool_no_free.c
@@ -33,24 +33,26 @@ 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];
 
 
 static void *alloc_blocks(void *_job)
 {
    struct job *job = _job;
+   uint32_t job_id = job - jobs;
+   uint32_t block_size = 16 * ((job_id % 4) + 1);
    int32_t block, *data;
 
    for (unsigned i = 0; i < BLOCKS_PER_THREAD; i++) {
-      block = anv_block_pool_alloc(job->pool);
+      block = anv_block_pool_alloc(job->pool, block_size);
       data = job->pool->map + block;
       *data = block;
       assert(block >= 0);
       job->blocks[i] = block;
 
-      block = anv_block_pool_alloc_back(job->pool);
+      block = anv_block_pool_alloc_back(job->pool, block_size);
       data = job->pool->map + block;
       *data = block;
       assert(block < 0);
@@ -70,7 +72,7 @@ static void *alloc_blocks(void *_job)
    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];
@@ -78,30 +80,30 @@ 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]++;
    }
 }
 
@@ -114,7 +116,7 @@ static void run_test()
    struct anv_block_pool pool;
 
    pthread_mutex_init(&device.mutex, NULL);
-   anv_block_pool_init(&pool, &device, 16);
+   anv_block_pool_init(&pool, &device, 4096, 4096, 0);
 
    for (unsigned i = 0; i < NUM_THREADS; i++) {
       jobs[i].pool = &pool;
@@ -126,7 +128,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);