Lines Matching refs:pool
352 struct anv_batch_bo *bbo = vk_zalloc(&cmd_buffer->vk.pool->alloc, sizeof(*bbo),
362 result = anv_reloc_list_init(&bbo->relocs, &cmd_buffer->vk.pool->alloc);
373 vk_free(&cmd_buffer->vk.pool->alloc, bbo);
385 struct anv_batch_bo *bbo = vk_alloc(&cmd_buffer->vk.pool->alloc, sizeof(*bbo),
395 result = anv_reloc_list_init_clone(&bbo->relocs, &cmd_buffer->vk.pool->alloc,
409 vk_free(&cmd_buffer->vk.pool->alloc, bbo);
511 anv_reloc_list_finish(&bbo->relocs, &cmd_buffer->vk.pool->alloc);
513 vk_free(&cmd_buffer->vk.pool->alloc, bbo);
562 struct anv_state_pool *pool = anv_binding_table_pool(cmd_buffer->device);
565 .bo = pool->block_pool.bo,
566 .offset = bt_block->offset - pool->start_offset,
642 .alloc = &cmd_buffer_from->vk.pool->alloc,
731 * on our hardware is that you have a big pool of surface state objects
733 * offsets into that pool. With the architecture we chose, we already
734 * have that pool and it's exactly the same pool that we use for regular
746 * like we do in GL, the ability to have a single surface state pool is
753 * chosen is to have a block pool with a maximum size of 2G that starts at
755 * the top of the pool (positive offsets) and we allocate blocks (< 64k) of
756 * binding tables from the bottom of the pool (negative offsets). Every time
761 * the bottom of our binding table block and zero of the block pool to the
863 cmd_buffer->batch.alloc = &cmd_buffer->vk.pool->alloc;
888 &cmd_buffer->vk.pool->alloc);
917 anv_reloc_list_finish(&cmd_buffer->surface_relocs, &cmd_buffer->vk.pool->alloc);
1178 anv_reloc_list_append(&primary->surface_relocs, &primary->vk.pool->alloc,
1398 adjust_relocations_from_state_pool(struct anv_state_pool *pool,
1402 assert(last_pool_center_bo_offset <= pool->block_pool.center_bo_offset);
1403 uint32_t delta = pool->block_pool.center_bo_offset - last_pool_center_bo_offset;
1406 /* All of the relocations from this block pool to other BO's should
1407 * have been emitted relative to the surface block pool center. We
1416 adjust_relocations_to_state_pool(struct anv_state_pool *pool,
1422 assert(last_pool_center_bo_offset <= pool->block_pool.center_bo_offset);
1423 uint32_t delta = pool->block_pool.center_bo_offset - last_pool_center_bo_offset;
1425 /* When we initially emit relocations into a block pool, we don't
1429 * relocations that point to the pool bo with the correct offset.
1432 if (relocs->reloc_bos[i] == pool->block_pool.bo) {
1446 write_reloc(pool->block_pool.device,
1721 * record the surface state pool center so future executions of the command
1776 struct anv_block_pool *pool;
1777 pool = &device->dynamic_state_pool.block_pool;
1778 anv_block_pool_foreach_bo(bo, pool) {
1784 pool = &device->general_state_pool.block_pool;
1785 anv_block_pool_foreach_bo(bo, pool) {
1791 pool = &device->instruction_state_pool.block_pool;
1792 anv_block_pool_foreach_bo(bo, pool) {
1798 pool = &device->binding_table_pool.block_pool;
1799 anv_block_pool_foreach_bo(bo, pool) {
2056 * 1) When a block pool is resized, we create a new gem handle with a
2075 * pool resize only rarely happen, this will almost never be contended so