VkResult
anv_block_pool_init(struct anv_block_pool *pool,
struct anv_device *device,
- uint32_t initial_size)
+ uint32_t initial_size,
+ uint64_t bo_flags)
{
VkResult result;
pool->device = device;
+ pool->bo_flags = bo_flags;
anv_bo_init(&pool->bo, 0, 0);
pool->fd = memfd_create("block pool", MFD_CLOEXEC);
* hard work for us.
*/
anv_bo_init(&pool->bo, gem_handle, size);
+ pool->bo.flags = pool->bo_flags;
pool->bo.map = map;
return VK_SUCCESS;
result = anv_block_pool_expand_range(pool, center_bo_offset, size);
- if (pool->device->instance->physicalDevice.has_exec_async)
- pool->bo.flags |= EXEC_OBJECT_ASYNC;
+ pool->bo.flags = pool->bo_flags;
done:
pthread_mutex_unlock(&pool->device->mutex);
VkResult
anv_state_pool_init(struct anv_state_pool *pool,
struct anv_device *device,
- uint32_t block_size)
+ uint32_t block_size,
+ uint64_t bo_flags)
{
VkResult result = anv_block_pool_init(&pool->block_pool, device,
- block_size * 16);
+ block_size * 16,
+ bo_flags);
if (result != VK_SUCCESS)
return result;
};
void
-anv_bo_pool_init(struct anv_bo_pool *pool, struct anv_device *device)
+anv_bo_pool_init(struct anv_bo_pool *pool, struct anv_device *device,
+ uint64_t bo_flags)
{
pool->device = device;
+ pool->bo_flags = bo_flags;
memset(pool->free_list, 0, sizeof(pool->free_list));
VG(VALGRIND_CREATE_MEMPOOL(pool, 0, false));
if (result != VK_SUCCESS)
return result;
- if (pool->device->instance->physicalDevice.supports_48bit_addresses)
- new_bo.flags |= EXEC_OBJECT_SUPPORTS_48B_ADDRESS;
-
- if (pool->device->instance->physicalDevice.has_exec_async)
- new_bo.flags |= EXEC_OBJECT_ASYNC;
+ new_bo.flags = pool->bo_flags;
assert(new_bo.size == pow2_size);
}
pthread_condattr_destroy(&condattr);
- anv_bo_pool_init(&device->batch_bo_pool, device);
+ uint64_t bo_flags =
+ (physical_device->supports_48bit_addresses ? EXEC_OBJECT_SUPPORTS_48B_ADDRESS : 0) |
+ (physical_device->has_exec_async ? EXEC_OBJECT_ASYNC : 0);
+
+ anv_bo_pool_init(&device->batch_bo_pool, device, bo_flags);
result = anv_bo_cache_init(&device->bo_cache);
if (result != VK_SUCCESS)
goto fail_batch_bo_pool;
- result = anv_state_pool_init(&device->dynamic_state_pool, device, 16384);
+ /* For the state pools we explicitly disable 48bit. */
+ bo_flags = physical_device->has_exec_async ? EXEC_OBJECT_ASYNC : 0;
+
+ result = anv_state_pool_init(&device->dynamic_state_pool, device, 16384,
+ bo_flags);
if (result != VK_SUCCESS)
goto fail_bo_cache;
- result = anv_state_pool_init(&device->instruction_state_pool, device, 16384);
+ result = anv_state_pool_init(&device->instruction_state_pool, device, 16384,
+ bo_flags);
if (result != VK_SUCCESS)
goto fail_dynamic_state_pool;
- result = anv_state_pool_init(&device->surface_state_pool, device, 4096);
+ result = anv_state_pool_init(&device->surface_state_pool, device, 4096,
+ bo_flags);
if (result != VK_SUCCESS)
goto fail_instruction_state_pool;
struct anv_block_pool {
struct anv_device *device;
+ uint64_t bo_flags;
+
struct anv_bo bo;
/* The offset from the start of the bo to the "center" of the block
*/
VkResult anv_block_pool_init(struct anv_block_pool *pool,
struct anv_device *device,
- uint32_t initial_size);
+ uint32_t initial_size,
+ uint64_t bo_flags);
void anv_block_pool_finish(struct anv_block_pool *pool);
int32_t anv_block_pool_alloc(struct anv_block_pool *pool,
uint32_t block_size);
VkResult anv_state_pool_init(struct anv_state_pool *pool,
struct anv_device *device,
- uint32_t block_size);
+ uint32_t block_size,
+ uint64_t bo_flags);
void anv_state_pool_finish(struct anv_state_pool *pool);
struct anv_state anv_state_pool_alloc(struct anv_state_pool *pool,
uint32_t state_size, uint32_t alignment);
struct anv_bo_pool {
struct anv_device *device;
+ uint64_t bo_flags;
+
void *free_list[16];
};
-void anv_bo_pool_init(struct anv_bo_pool *pool, struct anv_device *device);
+void anv_bo_pool_init(struct anv_bo_pool *pool, struct anv_device *device,
+ uint64_t bo_flags);
void anv_bo_pool_finish(struct anv_bo_pool *pool);
VkResult anv_bo_pool_alloc(struct anv_bo_pool *pool, struct anv_bo *bo,
uint32_t size);
struct anv_block_pool pool;
pthread_mutex_init(&device.mutex, NULL);
- anv_block_pool_init(&pool, &device, 4096);
+ anv_block_pool_init(&pool, &device, 4096, 0);
for (unsigned i = 0; i < NUM_THREADS; i++) {
jobs[i].pool = &pool;
pthread_mutex_init(&device.mutex, NULL);
for (unsigned i = 0; i < NUM_RUNS; i++) {
- anv_state_pool_init(&state_pool, &device, 256);
+ anv_state_pool_init(&state_pool, &device, 256, 0);
/* Grab one so a zero offset is impossible */
anv_state_pool_alloc(&state_pool, 16, 16);
struct anv_state_pool state_pool;
pthread_mutex_init(&device.mutex, NULL);
- anv_state_pool_init(&state_pool, &device, 4096);
+ anv_state_pool_init(&state_pool, &device, 4096, 0);
/* Grab one so a zero offset is impossible */
anv_state_pool_alloc(&state_pool, 16, 16);
struct anv_state_pool state_pool;
pthread_mutex_init(&device.mutex, NULL);
- anv_state_pool_init(&state_pool, &device, 64);
+ anv_state_pool_init(&state_pool, &device, 64, 0);
pthread_barrier_init(&barrier, NULL, NUM_THREADS);