Introduce IGT allocator
Subsystems (2)
v31 cover Introduce IGT allocator
This series introduce intel-allocator inside IGT.
...
v24: address review comment:
- change gem_linear_blits to show the way we can use during rewriting other tests to use/not use relocations
v25: changes:
- fix bug introduced during last review refactor in gem_linear_blits
- remove api_intel_bb@last-page test to not to hang gpu, we can decide to get this test later
v26: resend for review (Jason)
v27: addressing review comments:
- fix calculation of size in simple allocator (Jason)
- check buffer size is enough to handle WxHxBPP in intel_buf (Jason)
- skip collecting relocations in intel-bb for non-reloc mode (Zbigniew)
v28: addressing review comments:
- replace igt_map with hash table taken from Eric Anholt and used in Mesa (Dominik)
- adopt new igt_map, requires some rework in intel_allocator (Zbigniew)
v29: - remove igt_hlist (current hashmap doesn't use it, Dominik)
- add non-asserting __intel_allocator_alloc() for future use (Zbigniew)
v30: - remove kill_children() which unfortunatelly also kills helpers what
is not we want
- add alloc_with_strategy() to support rewriting spinners
v31: - fix race which is encountered when multiprocess allocator start()/stop()
are called in different igt_fixtures in igt_subtest_groups. This bug was exposed during rewriting gem_exec_fence test (not included in this series due to not completing it yet)
Dominik Grzegorzek (5):
lib/igt_list: Add igt_list_for_each_entry_safe_reverse lib/igt_map: Adopt Mesa hash table lib/intel_allocator_simple: Add simple allocator tests/api_intel_allocator: Simple allocator test suite tests/gem_linear_blits: Use intel allocator
Zbigniew Kempczyński (35):
lib/igt_list: Add igt_list_del_init()
lib/igt_core: Track child process pid and tid lib/intel_allocator_reloc: Add reloc allocator lib/intel_allocator_random: Add random allocator lib/intel_allocator: Add intel_allocator core lib/intel_allocator: Try to stop smoothly instead of deinit lib/intel_allocator_msgchannel: Scale to 4k of parallel clients lib/intel_allocator: Separate allocator multiprocess start lib/intel_bufops: Change size from 32->64 bit lib/intel_bufops: Add init with handle and size function lib/intel_batchbuffer: Integrate intel_bb with allocator lib/intel_batchbuffer: Use relocations in intel-bb up to gen12 lib/intel_batchbuffer: Create bb with strategy / vm ranges lib/intel_batchbuffer: Add tracking intel_buf to intel_bb lib/intel_batchbuffer: Don't collect relocations for newer gens lib/igt_fb: Initialize intel_buf with same size as fb tests/api_intel_bb: Remove check-canonical test tests/api_intel_bb: Modify test to verify intel_bb with allocator tests/api_intel_bb: Add compressed->compressed copy tests/api_intel_bb: Add purge-bb test
tests/api_intel_bb: Add simple intel-bb which uses allocator tests/api_intel_bb: Use allocator in delta-check test tests/api_intel_bb: Check switching vm in intel-bb tests/api_intel_allocator: Add execbuf with allocator example tests/api_intel_allocator: Verify child can use its standalone
allocator
tests/gem_softpin: Verify allocator and execbuf pair work together tests/gem|kms: Remove intel_bb from fixture tests/gem_mmap_offset: Use intel_buf wrapper code instead direct tests/gem_ppgtt: Adopt test to use intel_bb with allocator tests/gem_render_copy_redux: Adopt to use with intel_bb and allocator tests/perf.c: Remove buffer from batch lib/intel_allocator: drop kill_children() lib/intel_allocator: Add alloc function which allows passing strategy
argument
tests/api_intel_allocator: Check alloc with strategy API lib/intel_allocator: Wait for allocator thread to be ready
.../igt-gpu-tools/igt-gpu-tools-docs.xml | 2 + lib/Makefile.sources | 8 + lib/igt_core.c | 20 + lib/igt_fb.c | 10 +- lib/igt_list.c | 6 + lib/igt_list.h | 7 + lib/igt_map.c | 502 ++++++ lib/igt_map.h | 174 ++ lib/intel_allocator.c | 1422 +++++++++++++++++ lib/intel_allocator.h | 231 +++ lib/intel_allocator_msgchannel.c | 195 +++ lib/intel_allocator_msgchannel.h | 157 ++ lib/intel_allocator_random.c | 190 +++ lib/intel_allocator_reloc.c | 192 +++ lib/intel_allocator_simple.c | 807 ++++++++++ lib/intel_aux_pgtable.c | 26 +- lib/intel_batchbuffer.c | 737 ++++++--- lib/intel_batchbuffer.h | 54 +- lib/intel_bufops.c | 64 +- lib/intel_bufops.h | 20 +- lib/media_spin.c | 2 - lib/meson.build | 6 + tests/i915/api_intel_allocator.c | 715 +++++++++ tests/i915/api_intel_bb.c | 741 +++++++-- tests/i915/gem_caching.c | 14 +- tests/i915/gem_linear_blits.c | 90 +- tests/i915/gem_mmap_offset.c | 4 +- tests/i915/gem_partial_pwrite_pread.c | 40 +- tests/i915/gem_ppgtt.c | 7 +- tests/i915/gem_render_copy.c | 31 +- tests/i915/gem_render_copy_redux.c | 24 +- tests/i915/gem_softpin.c | 194 +++ tests/i915/perf.c | 9 + tests/intel-ci/fast-feedback.testlist | 2 + tests/kms_big_fb.c | 12 +- tests/meson.build | 1 + 36 files changed, 6231 insertions(+), 485 deletions(-) create mode 100644 lib/igt_map.c create mode 100644 lib/igt_map.h create mode 100644 lib/intel_allocator.c create mode 100644 lib/intel_allocator.h create mode 100644 lib/intel_allocator_msgchannel.c create mode 100644 lib/intel_allocator_msgchannel.h create mode 100644 lib/intel_allocator_random.c create mode 100644 lib/intel_allocator_reloc.c create mode 100644 lib/intel_allocator_simple.c create mode 100644 tests/i915/api_intel_allocator.c
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 1/40 lib/igt_list: Add igt_list_del_init()
Add helper function for delete and reinitialize list element.
--- lib/igt_list.c | 6 ++++++ lib/igt_list.h | 1 + 2 files changed, 7 insertions(+)
lib/igt_list.c +6 -0
@@ -46,6 +46,12 @@ void igt_list_del(struct igt_list_head *elem) elem->prev =NULL ; } +void igt_list_del_init (struct igt_list_head *elem) +{ +igt_list_del (elem); +IGT_INIT_LIST_HEAD (elem); +} +void igt_list_move (struct igt_list_head *elem,struct igt_list_head *list) {igt_list_del (elem);
lib/igt_list.h +1 -0
@@ -75,6 +75,7 @@ struct igt_list_head {void IGT_INIT_LIST_HEAD (struct igt_list_head *head);void igt_list_add (struct igt_list_head *elem,struct igt_list_head *head);void igt_list_del (struct igt_list_head *elem); +void igt_list_del_init (struct igt_list_head *elem);void igt_list_move (struct igt_list_head *elem,struct igt_list_head *list);void igt_list_move_tail (struct igt_list_head *elem,struct igt_list_head *list);int igt_list_length (const struct igt_list_head *head);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 2/40 lib/igt_list: Add igt_list_for_each_entry_safe_reverse
In reply to Zbigniew KempczyńskiFrom: Dominik Grzegorzek <[email protected]>
Added safe version of reversed iteration over igt_list.
--- lib/igt_list.h | 6 ++++++ 1 file changed, 6 insertions(+)
lib/igt_list.h +6 -0
@@ -108,6 +108,12 @@ bool igt_list_empty(const struct igt_list_head *head); &pos->member != (head); \ pos = igt_container_of((pos)->member.prev, pos, member)) +#define igt_list_for_each_entry_safe_reverse (pos, tmp, head, member) \ + for (pos = igt_container_of((head)->prev, pos, member), \ + tmp = igt_container_of((pos)->member.prev, tmp, member); \ + &pos->member != (head); \ + pos = tmp, \ + tmp = igt_container_of((pos)->member.prev, tmp, member))/* IGT custom helpers */
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 3/40 lib/igt_map: Adopt Mesa hash table
In reply to Zbigniew KempczyńskiFrom: Dominik Grzegorzek <[email protected]>
The _search function has been changed to return a pointer to
the stored data instead of the entry struct. The _search_entry function, which acts as the original search has been added. Additionally _remove function has an optional delete_function param, to make it more usable.
For more information, see:
http://cgit.freedesktop.org/~anholt/hash_table/tree/README
--- .../igt-gpu-tools/igt-gpu-tools-docs.xml | 1 + lib/Makefile.sources | 2 + lib/igt_map.c | 502 ++++++++++++++++++ lib/igt_map.h | 174 ++++++ lib/meson.build | 1 + 5 files changed, 680 insertions(+) create mode 100644 lib/igt_map.c create mode 100644 lib/igt_map.h
docs/reference/igt-gpu-tools/igt-gpu-tools-docs.xml +1 -0
@@ -33,6 +33,7 @@ <xi:include href="xml/igt_kmod.xml"/> <xi:include href="xml/igt_kms.xml"/> <xi:include href="xml/igt_list.xml"/> + <xi:include href="xml/igt_map.xml"/> <xi:include href="xml/igt_pm.xml"/> <xi:include href="xml/igt_primes.xml"/> <xi:include href="xml/igt_rand.xml"/>
lib/Makefile.sources +2 -0
@@ -48,6 +48,8 @@ lib_source_list = \ igt_infoframe.h \ igt_list.c \ igt_list.h \ + igt_map.c \ + igt_map.h \ igt_matrix.c \ igt_matrix.h \ igt_params.c \
lib/igt_map.c new file +502 -0
502 lines not on this page · raw message
lib/igt_map.h new file +174 -0
174 lines not on this page · raw message
lib/meson.build +1 -0
@@ -61,6 +61,7 @@ lib_sources = [ 'igt_core.c', 'igt_draw.c', 'igt_list.c', + 'igt_map.c', 'igt_pm.c', 'igt_dummyload.c', 'uwildmat/uwildmat.c',
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 4/40 lib/igt_core: Track child process pid and tid
In reply to Zbigniew KempczyńskiIntroduce variables which can decrease number of getpid()/gettid() calls, especially for allocator which must be aware of method acquiring addresses.
When child is spawned using igt_fork() we can control its initialization and prepare child_pid implicitly. Tracking child_tid requires our intervention in the code and do something like this:
if (child_tid == -1)
child_tid = gettid()
Variable was created for using in TLS so each thread is created with variable set to -1. This will give each thread it's own "copy" and there's no risk to use other thread tid. For each forked child we reassign -1 to child_tid to avoid using already set variable.
--- lib/igt_core.c | 6 ++++++ 1 file changed, 6 insertions(+)
lib/igt_core.c +6 -0
@@ -306,6 +306,10 @@ int num_test_children;int test_children_sz;bool test_child; +/* For allocator purposes */ +pid_t child_pid =-1 ; +__threadpid_t child_tid =-1 ; +enum {/* * Let the first values be used by individual tests so options don't
@@ -2302,6 +2306,8 @@ bool __igt_fork(void)case 0 : test_child = true;pthread_mutex_init (&print_mutex,NULL ); + child_pid =getpid (); + child_tid =-1 ; exit_handler_count =0 ;reset_helper_process_list ();oom_adjust_for_doom ();
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 5/40 lib/intel_allocator_simple: Add simple allocator
In reply to Zbigniew KempczyńskiFrom: Dominik Grzegorzek <[email protected]>
Simple allocator borrowed from Mesa adopted for IGT use.
From default we prefer an allocation from the top of vm address space (we can catch addressing issues pro-actively). When function intel_allocator_simple_create() is used we exclude last page as HW tends to hang on the render engine when full 3D pipeline is executed from the last page. For more control of vm range user can specify range using intel_allocator_simple_create_full() (with the respect of the gtt size).
v2: fix size calculation (don't allow to subtract number which can be
negative - as we got for canonical addresses with 47 bit set - Jason)
v3: change to new igt_map implementation, add refcounts in allocator
(according to Jason review comments)
v4: return ALLOC_INVALID_ADDRESS instead of assert for failed allocation
--- lib/intel_allocator_simple.c | 804 +++++++++++++++++++++++++++++++++++ 1 file changed, 804 insertions(+) create mode 100644 lib/intel_allocator_simple.c
lib/intel_allocator_simple.c new file +804 -0
@@ -0,0 +1,804 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2021 Intel Corporation +*/ + +#include <sys/ioctl.h> +#include <stdlib.h> +#include "igt.h" +#include "igt_x86.h" +#include "intel_allocator.h" +#include "intel_bufops.h" +#include "igt_map.h" + +/* +* We limit allocator space to avoid hang when batch would be +* pinned in the last page. +*/ +#define RESERVED 4096 + +/* Avoid compilation warning */ +struct intel_allocator *intel_allocator_simple_create (int fd); +struct intel_allocator * +intel_allocator_simple_create_full (int fd,uint64_t start,uint64_t end, +enum allocator_strategy strategy); + +struct simple_vma_heap { +struct igt_list_head holes; + +/* If true, simple_vma_heap_alloc will prefer high addresses +* +* Default is true. +*/ +bool alloc_high; +}; + +struct simple_vma_hole { +struct igt_list_head link; +uint64_t offset; +uint64_t size; +}; + +struct intel_allocator_simple { +struct igt_map *objects; +struct igt_map *reserved; +struct simple_vma_heap heap; + +uint64_t start; +uint64_t end; + +/* statistics */ +uint64_t total_size; +uint64_t allocated_size; +uint64_t allocated_objects; +uint64_t reserved_size; +uint64_t reserved_areas; +}; + +struct intel_allocator_record { +uint32_t handle; +uint64_t offset; +uint64_t size; +}; + +#define simple_vma_foreach_hole (_hole, _heap) \ + igt_list_for_each_entry(_hole, &(_heap)->holes, link) + +#define simple_vma_foreach_hole_safe (_hole, _heap, _tmp) \ + igt_list_for_each_entry_safe(_hole, _tmp, &(_heap)->holes, link) + +#define simple_vma_foreach_hole_safe_rev (_hole, _heap, _tmp) \ + igt_list_for_each_entry_safe_reverse(_hole, _tmp, &(_heap)->holes, link) + +/* 2^31 + 2^29 - 2^25 + 2^22 - 2^19 - 2^16 + 1 */ +#define GOLDEN_RATIO_PRIME_32 0x9e370001UL + +/* 2^63 + 2^61 - 2^57 + 2^54 - 2^51 - 2^18 + 1 */ +#define GOLDEN_RATIO_PRIME_64 0x9e37fffffffc0001ULL + +static inline uint32_t hash_handles (const void *val) +{ +uint32_t hash = *(uint32_t *) val; + + hash = hash *GOLDEN_RATIO_PRIME_32 ; +return hash; +} + +static int equal_handles (const void *a,const void *b) +{ +uint32_t *key1 = (uint32_t *) a, *key2 = (uint32_t *) b; + +return *key1 == *key2; +} + +static inline uint32_t hash_offsets (const void *val) +{ +uint64_t hash = *(uint64_t *) val; + + hash = hash *GOLDEN_RATIO_PRIME_64 ; +/* High bits are more random, so use them. */ +return hash >>32 ; +} + +static int equal_offsets (const void *a,const void *b) +{ +uint64_t *key1 = (uint64_t *) a, *key2 = (uint64_t *) b; + +return *key1 == *key2; +} + +static void map_entry_free_func (struct igt_map_entry *entry) +{ +free (entry->data); +} + +#define GEN8_GTT_ADDRESS_WIDTH 48 +#define DECANONICAL (offset) (offset & ((1ull << GEN8_GTT_ADDRESS_WIDTH) - 1)) + +static void simple_vma_heap_validate (struct simple_vma_heap *heap) +{ +uint64_t prev_offset =0 ; +struct simple_vma_hole *hole; + + simple_vma_foreach_hole(hole, heap) { +igt_assert (hole->size >0 ); + +if (&hole->link == heap->holes.next) { +/* +* This must be the top-most hole. Assert that, +* if it overflows, it overflows to 0, i.e. 2^64. +*/ +igt_assert (hole->size + hole->offset ==0 || + hole->size + hole->offset > hole->offset); + }else { +/* +* This is not the top-most hole so it must not overflow and, +* in fact, must be strictly lower than the top-most hole. If +* hole->size + hole->offset == prev_offset, then we failed to +* join holes during a simple_vma_heap_free. +*/ +igt_assert (hole->size + hole->offset > hole->offset && + hole->size + hole->offset < prev_offset); + } + prev_offset = hole->offset; + } +} + + +static void simple_vma_heap_free (struct simple_vma_heap *heap, +uint64_t offset,uint64_t size) +{ +struct simple_vma_hole *high_hole =NULL , *low_hole =NULL , *hole; +bool high_adjacent, low_adjacent; + +/* Freeing something with a size of 0 is not valid. */ +igt_assert (size >0 ); + +/* +* It's possible for offset + size to wrap around if we touch the top of +* the 64-bit address space, but we cannot go any higher than 2^64. +*/ +igt_assert (offset + size ==0 || offset + size > offset); + +simple_vma_heap_validate (heap); + +/* Find immediately higher and lower holes if they exist. */ + simple_vma_foreach_hole(hole, heap) { +if (hole->offset <= offset) { + low_hole = hole; +break ; + } + high_hole = hole; + } + +if (high_hole) +igt_assert (offset + size <= high_hole->offset); + high_adjacent = high_hole && offset + size == high_hole->offset; + +if (low_hole) { +igt_assert (low_hole->offset + low_hole->size > low_hole->offset); +igt_assert (low_hole->offset + low_hole->size <= offset); + } + low_adjacent = low_hole && low_hole->offset + low_hole->size == offset; + +if (low_adjacent && high_adjacent) { +/* Merge the two holes */ + low_hole->size += size + high_hole->size; +igt_list_del (&high_hole->link); +free (high_hole); + }else if (low_adjacent) { +/* Merge into the low hole */ + low_hole->size += size; + }else if (high_adjacent) { +/* Merge into the high hole */ + high_hole->offset = offset; + high_hole->size += size; + }else { +/* Neither hole is adjacent; make a new one */ + hole =calloc (1 ,sizeof (*hole)); +igt_assert (hole); + + hole->offset = offset; + hole->size = size; +/* +* Add it after the high hole so we maintain high-to-low +* ordering +*/ +if (high_hole) +igt_list_add (&hole->link, &high_hole->link); +else +igt_list_add (&hole->link, &heap->holes); + } + +simple_vma_heap_validate (heap); +} + +static void simple_vma_heap_init (struct simple_vma_heap *heap, +uint64_t start,uint64_t size, +enum allocator_strategy strategy) +{ +IGT_INIT_LIST_HEAD (&heap->holes); +simple_vma_heap_free (heap, start, size); + +switch (strategy) { +case ALLOC_STRATEGY_LOW_TO_HIGH : + heap->alloc_high = false; +break ; +case ALLOC_STRATEGY_HIGH_TO_LOW : +default : + heap->alloc_high = true; + } +} + +static void simple_vma_heap_finish (struct simple_vma_heap *heap) +{ +struct simple_vma_hole *hole, *tmp; + + simple_vma_foreach_hole_safe(hole, heap, tmp) +free (hole); +} + +static void simple_vma_hole_alloc (struct simple_vma_hole *hole, +uint64_t offset,uint64_t size) +{ +struct simple_vma_hole *high_hole; +uint64_t waste; + +igt_assert (hole->offset <= offset); +igt_assert (hole->size >= offset - hole->offset + size); + +if (offset == hole->offset && size == hole->size) { +/* Just get rid of the hole. */ +igt_list_del (&hole->link); +free (hole); +return ; + } + +igt_assert (offset - hole->offset <= hole->size - size); + waste = (hole->size - size) - (offset - hole->offset); +if (waste ==0 ) { +/* We allocated at the top-> Shrink the hole down. */ + hole->size -= size; +return ; + } + +if (offset == hole->offset) { +/* We allocated at the bottom. Shrink the hole up-> */ + hole->offset += size; + hole->size -= size; +return ; + } + +/* +* We allocated in the middle. We need to split the old hole into two +* holes, one high and one low. +*/ + high_hole =calloc (1 ,sizeof (*hole)); +igt_assert (high_hole); + + high_hole->offset = offset + size; + high_hole->size = waste; + +/* +* Adjust the hole to be the amount of space left at he bottom of the +* original hole. +*/ + hole->size = offset - hole->offset; + +/* +* Place the new hole before the old hole so that the list is in order +* from high to low. +*/ +igt_list_add_tail (&high_hole->link, &hole->link); +} + +static bool simple_vma_heap_alloc (struct simple_vma_heap *heap, +uint64_t *offset,uint64_t size, +uint64_t alignment) +{ +struct simple_vma_hole *hole, *tmp; +uint64_t misalign; + +/* The caller is expected to reject zero-size allocations */ +igt_assert (size >0 ); +igt_assert (alignment >0 ); + +simple_vma_heap_validate (heap); + +if (heap->alloc_high) { + simple_vma_foreach_hole_safe(hole, heap, tmp) { +if (size > hole->size) +continue ; +/* +* Compute the offset as the highest address where a chunk of the +* given size can be without going over the top of the hole. +* +* This calculation is known to not overflow because we know that +* hole->size + hole->offset can only overflow to 0 and size > 0. +*/ + *offset = (hole->size - size) + hole->offset; + +/* +* Align the offset. We align down and not up because we are +* +* allocating from the top of the hole and not the bottom. +*/ + *offset = (*offset / alignment) * alignment; + +if (*offset < hole->offset) +continue ; + +simple_vma_hole_alloc (hole, *offset, size); +simple_vma_heap_validate (heap); +return true; + } + }else { + simple_vma_foreach_hole_safe_rev(hole, heap, tmp) { +if (size > hole->size) +continue ; + + *offset = hole->offset; + +/* Align the offset */ + misalign = *offset % alignment; +if (misalign) { +uint64_t pad = alignment - misalign; + +if (pad > hole->size - size) +continue ; + + *offset += pad; + } + +simple_vma_hole_alloc (hole, *offset, size); +simple_vma_heap_validate (heap); +return true; + } + } + +/* Failed to allocate */ +return false; +} + +static void intel_allocator_simple_get_address_range (struct intel_allocator *ial, +uint64_t *startp, +uint64_t *endp) +{ +struct intel_allocator_simple *ials = ial->priv; + +if (startp) + *startp = ials->start; + +if (endp) + *endp = ials->end; +} + +static bool simple_vma_heap_alloc_addr (struct intel_allocator_simple *ials, +uint64_t offset,uint64_t size) +{ +struct simple_vma_heap *heap = &ials->heap; +struct simple_vma_hole *hole, *tmp; + +/* Allocating something with a size of 0 is not valid. */ +igt_assert (size >0 ); + +/* +* It's possible for offset + size to wrap around if we touch the top of +* the 64-bit address space, but we cannot go any higher than 2^64. +*/ +igt_assert (offset + size ==0 || offset + size > offset); + +/* Find the hole if one exists. */ + simple_vma_foreach_hole_safe(hole, heap, tmp) { +if (hole->offset > offset) +continue ; + +/* +* Holes are ordered high-to-low so the first hole we find with +* hole->offset <= is our hole. If it's not big enough to contain the +* requested range, then the allocation fails. +*/ +igt_assert (hole->offset <= offset); +if (hole->size < offset - hole->offset + size) +return false; + +simple_vma_hole_alloc (hole, offset, size); +return true; + } + +/* We didn't find a suitable hole */ +return false; +} + +static uint64_t intel_allocator_simple_alloc (struct intel_allocator *ial, +uint32_t handle,uint64_t size, +uint64_t alignment) +{ +struct intel_allocator_record *rec; +struct intel_allocator_simple *ials; +uint64_t offset; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +igt_assert (ials); +igt_assert (handle); + alignment = alignment >0 ? alignment :1 ; + + rec =igt_map_search (ials->objects, &handle); +if (rec) { + offset = rec->offset; +igt_assert (rec->size == size); + }else { +if (!simple_vma_heap_alloc (&ials->heap, &offset, + size, alignment)) +return ALLOC_INVALID_ADDRESS ; + + rec =malloc (sizeof (*rec)); + rec->handle = handle; + rec->offset = offset; + rec->size = size; + +igt_map_insert (ials->objects, &rec->handle, rec); + ials->allocated_objects++; + ials->allocated_size += size; + } + +return offset; +} + +static bool intel_allocator_simple_free (struct intel_allocator *ial,uint32_t handle) +{ +struct intel_allocator_record *rec =NULL ; +struct intel_allocator_simple *ials; +struct igt_map_entry *entry; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +igt_assert (ials); + + entry =igt_map_search_entry (ials->objects, &handle); +if (entry) { +igt_map_remove_entry (ials->objects, entry); +if (entry->data) { + rec = (struct intel_allocator_record *) entry->data; +simple_vma_heap_free (&ials->heap, rec->offset, rec->size); + ials->allocated_objects--; + ials->allocated_size -= rec->size; +free (rec); + +return true; + } + } + +return false; +} + +static inline bool __same (const struct intel_allocator_record *rec, +uint32_t handle,uint64_t size,uint64_t offset) +{ +return rec->handle == handle && rec->size == size && +DECANONICAL (rec->offset) ==DECANONICAL (offset); +} + +static bool intel_allocator_simple_is_allocated (struct intel_allocator *ial, +uint32_t handle,uint64_t size, +uint64_t offset) +{ +struct intel_allocator_record *rec; +struct intel_allocator_simple *ials; +bool same = false; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +igt_assert (ials); +igt_assert (handle); + + rec =igt_map_search (ials->objects, &handle); +if (rec &&__same (rec, handle, size, offset)) + same = true; + +return same; +} + +static uint64_t get_size (uint64_t start,uint64_t end) +{ + end = end ? end :1ull <<GEN8_GTT_ADDRESS_WIDTH ; + +return end - start; +} + +static bool intel_allocator_simple_reserve (struct intel_allocator *ial, +uint32_t handle, +uint64_t start,uint64_t end) +{ +uint64_t size; +struct intel_allocator_record *rec =NULL ; +struct intel_allocator_simple *ials; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +igt_assert (ials); + +/* don't allow end equal to 0 before decanonical */ +igt_assert (end); + +/* clear [63:48] bits to get rid of canonical form */ + start =DECANONICAL (start); + end =DECANONICAL (end); +igt_assert (end > start || end ==0 ); + size =get_size (start, end); + +if (simple_vma_heap_alloc_addr (ials, start, size)) { + rec =malloc (sizeof (*rec)); + rec->handle = handle; + rec->offset = start; + rec->size = size; + +igt_map_insert (ials->reserved, &rec->offset, rec); + + ials->reserved_areas++; + ials->reserved_size += rec->size; +return true; + } + +igt_debug ("Failed to reserve %llx + %llx\n" , (long long )start, (long long )size); +return false; +} + +static bool intel_allocator_simple_unreserve (struct intel_allocator *ial, +uint32_t handle, +uint64_t start,uint64_t end) +{ +uint64_t size; +struct intel_allocator_record *rec =NULL ; +struct intel_allocator_simple *ials; +struct igt_map_entry *entry; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +igt_assert (ials); + +/* don't allow end equal to 0 before decanonical */ +igt_assert (end); + +/* clear [63:48] bits to get rid of canonical form */ + start =DECANONICAL (start); + end =DECANONICAL (end); +igt_assert (end > start || end ==0 ); + size =get_size (start, end); + + entry =igt_map_search_entry (ials->reserved, &start); + +if (!entry || !entry->data) { +igt_debug ("Only reserved blocks can be unreserved\n" ); +return false; + } + rec = entry->data; + +if (rec->size != size) { +igt_debug ("Only the whole block unreservation allowed\n" ); +return false; + } + +if (rec->handle != handle) { +igt_debug ("Handle %u doesn't match reservation handle: %u\n" , + rec->handle, handle); +return false; + } + +igt_map_remove_entry (ials->reserved, entry); + ials->reserved_areas--; + ials->reserved_size -= rec->size; +free (rec); +simple_vma_heap_free (&ials->heap, start, size); + +return true; +} + +static bool intel_allocator_simple_is_reserved (struct intel_allocator *ial, +uint64_t start,uint64_t end) +{ +uint64_t size; +struct intel_allocator_record *rec =NULL ; +struct intel_allocator_simple *ials; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +igt_assert (ials); + +/* don't allow end equal to 0 before decanonical */ +igt_assert (end); + +/* clear [63:48] bits to get rid of canonical form */ + start =DECANONICAL (start); + end =DECANONICAL (end); +igt_assert (end > start || end ==0 ); + size =get_size (start, end); + + rec =igt_map_search (ials->reserved, &start); + +if (!rec) +return false; + +if (rec->offset == start && rec->size == size) +return true; + +return false; +} + +static void intel_allocator_simple_destroy (struct intel_allocator *ial) +{ +struct intel_allocator_simple *ials; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +simple_vma_heap_finish (&ials->heap); + +igt_map_destroy (ials->objects, map_entry_free_func); + +igt_map_destroy (ials->reserved, map_entry_free_func); + +free (ial->priv); +free (ial); +} + +static bool intel_allocator_simple_is_empty (struct intel_allocator *ial) +{ +struct intel_allocator_simple *ials = ial->priv; + +igt_debug ("<ial: %p, fd: %d> objects: %" PRId64 +", reserved_areas: %" PRId64"\n" , + ial, ial->fd, + ials->allocated_objects, ials->reserved_areas); + +return !ials->allocated_objects && !ials->reserved_areas; +} + +static void intel_allocator_simple_print (struct intel_allocator *ial,bool full) +{ +struct intel_allocator_simple *ials; +struct simple_vma_hole *hole; +struct simple_vma_heap *heap; +struct igt_map_entry *pos; +uint64_t total_free =0 , allocated_size =0 , allocated_objects =0 ; +uint64_t reserved_size =0 , reserved_areas =0 ; + +igt_assert (ial); + ials = (struct intel_allocator_simple *) ial->priv; +igt_assert (ials); + heap = &ials->heap; + +igt_info ("intel_allocator_simple <ial: %p, fd: %d> on " +"[0x%" PRIx64" : 0x%" PRIx64"]:\n" , ial, ial->fd, + ials->start, ials->end); + +if (full) { +igt_info ("holes:\n" ); + simple_vma_foreach_hole(hole, heap) { +igt_info ("offset = %" PRIu64" (0x%" PRIx64", " +"size = %" PRIu64" (0x%" PRIx64")\n" , + hole->offset, hole->offset, hole->size, + hole->size); + total_free += hole->size; + } +igt_assert (total_free <= ials->total_size); +igt_info ("total_free: %" PRIx64 +", total_size: %" PRIx64 +", allocated_size: %" PRIx64 +", reserved_size: %" PRIx64"\n" , + total_free, ials->total_size, ials->allocated_size, + ials->reserved_size); +igt_assert (total_free == + ials->total_size - ials->allocated_size - ials->reserved_size); + +igt_info ("objects:\n" ); + igt_map_foreach(ials->objects, pos) { +struct intel_allocator_record *rec = pos->data; + +igt_info ("handle = %d, offset = %" PRIu64" " +"(0x%" PRIx64", size = %" PRIu64" (0x%" PRIx64")\n" , + rec->handle, rec->offset, rec->offset, + rec->size, rec->size); + allocated_objects++; + allocated_size += rec->size; + } +igt_assert (ials->allocated_size == allocated_size); +igt_assert (ials->allocated_objects == allocated_objects); + +igt_info ("reserved areas:\n" ); + igt_map_foreach(ials->reserved, pos) { +struct intel_allocator_record *rec = pos->data; + +igt_info ("offset = %" PRIu64" (0x%" PRIx64", " +"size = %" PRIu64" (0x%" PRIx64")\n" , + rec->offset, rec->offset, + rec->size, rec->size); + reserved_areas++; + reserved_size += rec->size; + } +igt_assert (ials->reserved_areas == reserved_areas); +igt_assert (ials->reserved_size == reserved_size); + }else { + simple_vma_foreach_hole(hole, heap) + total_free += hole->size; + } + +igt_info ("free space: %" PRIu64"B (0x%" PRIx64") (%.2f%% full)\n" +"allocated objects: %" PRIu64", reserved areas: %" PRIu64"\n" , + total_free, total_free, + ((double ) (ials->total_size - total_free) / + (double ) ials->total_size) *100 , + ials->allocated_objects, ials->reserved_areas); +} + +static struct intel_allocator * +__intel_allocator_simple_create (int fd,uint64_t start,uint64_t end, +enum allocator_strategy strategy) +{ +struct intel_allocator *ial; +struct intel_allocator_simple *ials; + +igt_debug ("Using simple allocator\n" ); + + ial =calloc (1 ,sizeof (*ial)); +igt_assert (ial); + + ial->fd = fd; + ial->get_address_range = intel_allocator_simple_get_address_range; + ial->alloc = intel_allocator_simple_alloc; + ial->free = intel_allocator_simple_free; + ial->is_allocated = intel_allocator_simple_is_allocated; + ial->reserve = intel_allocator_simple_reserve; + ial->unreserve = intel_allocator_simple_unreserve; + ial->is_reserved = intel_allocator_simple_is_reserved; + ial->destroy = intel_allocator_simple_destroy; + ial->is_empty = intel_allocator_simple_is_empty; + ial->print = intel_allocator_simple_print; + ials = ial->priv =malloc (sizeof (struct intel_allocator_simple )); +igt_assert (ials); + + ials->objects =igt_map_create (hash_handles, equal_handles); + ials->reserved =igt_map_create (hash_offsets, equal_offsets); +igt_assert (ials->objects && ials->reserved); + + ials->start = start; + ials->end = end; + ials->total_size = end - start; +simple_vma_heap_init (&ials->heap, ials->start, ials->total_size, + strategy); + + ials->allocated_size =0 ; + ials->allocated_objects =0 ; + ials->reserved_size =0 ; + ials->reserved_areas =0 ; + +return ial; +} + +struct intel_allocator * +intel_allocator_simple_create (int fd) +{ +uint64_t gtt_size =gem_aperture_size (fd); + +if (!gem_uses_full_ppgtt (fd)) + gtt_size /=2 ; +else + gtt_size -=RESERVED ; + +return __intel_allocator_simple_create (fd,0 , gtt_size, +ALLOC_STRATEGY_HIGH_TO_LOW ); +} + +struct intel_allocator * +intel_allocator_simple_create_full (int fd,uint64_t start,uint64_t end, +enum allocator_strategy strategy) +{ +uint64_t gtt_size =gem_aperture_size (fd); + +igt_assert (end <= gtt_size); +if (!gem_uses_full_ppgtt (fd)) + gtt_size /=2 ; +igt_assert (end - start <= gtt_size); + +return __intel_allocator_simple_create (fd, start, end, strategy); +}
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 6/40 lib/intel_allocator_reloc: Add reloc allocator
In reply to Zbigniew KempczyńskiAs relocations won't be accessible on discrete we need to support IGT with an allocator. So tests which have to cover all generations have to diverge the code and use conditional constructs. On the long term this can be cumbersome and confusing. So we can try to avoid such and use pseudo-reloc allocator which main task is to return incremented offsets. This way we can skip mentioned conditionals and just acquire offsets from an allocator.
--- lib/intel_allocator_reloc.c | 190 ++++++++++++++++++++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 lib/intel_allocator_reloc.c
lib/intel_allocator_reloc.c new file +190 -0
@@ -0,0 +1,190 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2021 Intel Corporation +*/ + +#include <sys/ioctl.h> +#include <stdlib.h> +#include "igt.h" +#include "igt_x86.h" +#include "igt_rand.h" +#include "intel_allocator.h" + +struct intel_allocator *intel_allocator_reloc_create (int fd); + +struct intel_allocator_reloc { +uint64_t bias; +uint32_t prng; +uint64_t gtt_size; +uint64_t start; +uint64_t end; +uint64_t offset; + +/* statistics */ +uint64_t allocated_objects; +}; + +static uint64_t get_bias (int fd) +{ + (void ) fd; + +return 256 <<10 ; +} + +static void intel_allocator_reloc_get_address_range (struct intel_allocator *ial, +uint64_t *startp, +uint64_t *endp) +{ +struct intel_allocator_reloc *ialr = ial->priv; + +if (startp) + *startp = ialr->start; + +if (endp) + *endp = ialr->end; +} + +static uint64_t intel_allocator_reloc_alloc (struct intel_allocator *ial, +uint32_t handle,uint64_t size, +uint64_t alignment) +{ +struct intel_allocator_reloc *ialr = ial->priv; +uint64_t offset, aligned_offset; + + (void ) handle; + + alignment =max (alignment,4096 ); + aligned_offset =ALIGN (ialr->offset, alignment); + +/* Check we won't exceed end */ +if (aligned_offset + size > ialr->end) + aligned_offset =ALIGN (ialr->start, alignment); + + offset = aligned_offset; + ialr->offset = offset + size; + ialr->allocated_objects++; + +return offset; +} + +static bool intel_allocator_reloc_free (struct intel_allocator *ial, +uint32_t handle) +{ +struct intel_allocator_reloc *ialr = ial->priv; + + (void ) handle; + + ialr->allocated_objects--; + +return false; +} + +static bool intel_allocator_reloc_is_allocated (struct intel_allocator *ial, +uint32_t handle,uint64_t size, +uint64_t offset) +{ + (void ) ial; + (void ) handle; + (void ) size; + (void ) offset; + +return false; +} + +static void intel_allocator_reloc_destroy (struct intel_allocator *ial) +{ +igt_assert (ial); + +free (ial->priv); +free (ial); +} + +static bool intel_allocator_reloc_reserve (struct intel_allocator *ial, +uint32_t handle, +uint64_t start,uint64_t end) +{ + (void ) ial; + (void ) handle; + (void ) start; + (void ) end; + +return false; +} + +static bool intel_allocator_reloc_unreserve (struct intel_allocator *ial, +uint32_t handle, +uint64_t start,uint64_t end) +{ + (void ) ial; + (void ) handle; + (void ) start; + (void ) end; + +return false; +} + +static bool intel_allocator_reloc_is_reserved (struct intel_allocator *ial, +uint64_t start,uint64_t end) +{ + (void ) ial; + (void ) start; + (void ) end; + +return false; +} + +static void intel_allocator_reloc_print (struct intel_allocator *ial,bool full) +{ +struct intel_allocator_reloc *ialr = ial->priv; + + (void ) full; + +igt_info ("<ial: %p, fd: %d> allocated objects: %" PRIx64"\n" , + ial, ial->fd, ialr->allocated_objects); +} + +static bool intel_allocator_reloc_is_empty (struct intel_allocator *ial) +{ +struct intel_allocator_reloc *ialr = ial->priv; + +return !ialr->allocated_objects; +} + +#define RESERVED 4096 +struct intel_allocator *intel_allocator_reloc_create (int fd) +{ +struct intel_allocator *ial; +struct intel_allocator_reloc *ialr; + +igt_debug ("Using reloc allocator\n" ); + ial =calloc (1 ,sizeof (*ial)); +igt_assert (ial); + + ial->fd = fd; + ial->get_address_range = intel_allocator_reloc_get_address_range; + ial->alloc = intel_allocator_reloc_alloc; + ial->free = intel_allocator_reloc_free; + ial->is_allocated = intel_allocator_reloc_is_allocated; + ial->reserve = intel_allocator_reloc_reserve; + ial->unreserve = intel_allocator_reloc_unreserve; + ial->is_reserved = intel_allocator_reloc_is_reserved; + ial->destroy = intel_allocator_reloc_destroy; + ial->print = intel_allocator_reloc_print; + ial->is_empty = intel_allocator_reloc_is_empty; + + ialr = ial->priv =calloc (1 ,sizeof (*ialr)); +igt_assert (ial->priv); + ialr->prng = (uint32_t )to_user_pointer (ial); + ialr->gtt_size =gem_aperture_size (fd); +igt_debug ("Gtt size: %" PRId64"\n" , ialr->gtt_size); +if (!gem_uses_full_ppgtt (fd)) + ialr->gtt_size /=2 ; + + ialr->bias = ialr->offset =get_bias (fd); + ialr->start = ialr->bias; + ialr->end = ialr->gtt_size -RESERVED ; + + ialr->allocated_objects =0 ; + +return ial; +}
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 7/40 lib/intel_allocator_random: Add random allocator
In reply to Zbigniew KempczyńskiSometimes we want to experiment with addresses so randomizing can help us a little.
--- lib/intel_allocator_random.c | 188 +++++++++++++++++++++++++++++++++++ 1 file changed, 188 insertions(+) create mode 100644 lib/intel_allocator_random.c
lib/intel_allocator_random.c new file +188 -0
@@ -0,0 +1,188 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2021 Intel Corporation +*/ + +#include <sys/ioctl.h> +#include <stdlib.h> +#include "igt.h" +#include "igt_x86.h" +#include "igt_rand.h" +#include "intel_allocator.h" + +struct intel_allocator *intel_allocator_random_create (int fd); + +struct intel_allocator_random { +uint64_t bias; +uint32_t prng; +uint64_t gtt_size; +uint64_t start; +uint64_t end; + +/* statistics */ +uint64_t allocated_objects; +}; + +static uint64_t get_bias (int fd) +{ + (void ) fd; + +return 256 <<10 ; +} + +static void intel_allocator_random_get_address_range (struct intel_allocator *ial, +uint64_t *startp, +uint64_t *endp) +{ +struct intel_allocator_random *ialr = ial->priv; + +if (startp) + *startp = ialr->start; + +if (endp) + *endp = ialr->end; +} + +static uint64_t intel_allocator_random_alloc (struct intel_allocator *ial, +uint32_t handle,uint64_t size, +uint64_t alignment) +{ +struct intel_allocator_random *ialr = ial->priv; +uint64_t offset; + + (void ) handle; + +/* randomize the address, we try to avoid relocations */ +do { + offset =hars_petruska_f54_1_random64 (&ialr->prng); + offset += ialr->bias;/* Keep the low 256k clear, for negative deltas */ + offset &= ialr->gtt_size -1 ; + offset &= ~(alignment -1 ); + }while (offset + size > ialr->end); + + ialr->allocated_objects++; + +return offset; +} + +static bool intel_allocator_random_free (struct intel_allocator *ial, +uint32_t handle) +{ +struct intel_allocator_random *ialr = ial->priv; + + (void ) handle; + + ialr->allocated_objects--; + +return false; +} + +static bool intel_allocator_random_is_allocated (struct intel_allocator *ial, +uint32_t handle,uint64_t size, +uint64_t offset) +{ + (void ) ial; + (void ) handle; + (void ) size; + (void ) offset; + +return false; +} + +static void intel_allocator_random_destroy (struct intel_allocator *ial) +{ +igt_assert (ial); + +free (ial->priv); +free (ial); +} + +static bool intel_allocator_random_reserve (struct intel_allocator *ial, +uint32_t handle, +uint64_t start,uint64_t end) +{ + (void ) ial; + (void ) handle; + (void ) start; + (void ) end; + +return false; +} + +static bool intel_allocator_random_unreserve (struct intel_allocator *ial, +uint32_t handle, +uint64_t start,uint64_t end) +{ + (void ) ial; + (void ) handle; + (void ) start; + (void ) end; + +return false; +} + +static bool intel_allocator_random_is_reserved (struct intel_allocator *ial, +uint64_t start,uint64_t end) +{ + (void ) ial; + (void ) start; + (void ) end; + +return false; +} + +static void intel_allocator_random_print (struct intel_allocator *ial,bool full) +{ +struct intel_allocator_random *ialr = ial->priv; + + (void ) full; + +igt_info ("<ial: %p, fd: %d> allocated objects: %" PRIx64"\n" , + ial, ial->fd, ialr->allocated_objects); +} + +static bool intel_allocator_random_is_empty (struct intel_allocator *ial) +{ +struct intel_allocator_random *ialr = ial->priv; + +return !ialr->allocated_objects; +} + +#define RESERVED 4096 +struct intel_allocator *intel_allocator_random_create (int fd) +{ +struct intel_allocator *ial; +struct intel_allocator_random *ialr; + +igt_debug ("Using random allocator\n" ); + ial =calloc (1 ,sizeof (*ial)); +igt_assert (ial); + + ial->fd = fd; + ial->get_address_range = intel_allocator_random_get_address_range; + ial->alloc = intel_allocator_random_alloc; + ial->free = intel_allocator_random_free; + ial->is_allocated = intel_allocator_random_is_allocated; + ial->reserve = intel_allocator_random_reserve; + ial->unreserve = intel_allocator_random_unreserve; + ial->is_reserved = intel_allocator_random_is_reserved; + ial->destroy = intel_allocator_random_destroy; + ial->print = intel_allocator_random_print; + ial->is_empty = intel_allocator_random_is_empty; + + ialr = ial->priv =calloc (1 ,sizeof (*ialr)); +igt_assert (ial->priv); + ialr->prng = (uint32_t )to_user_pointer (ial); + ialr->gtt_size =gem_aperture_size (fd); +igt_debug ("Gtt size: %" PRId64"\n" , ialr->gtt_size); +if (!gem_uses_full_ppgtt (fd)) + ialr->gtt_size /=2 ; + + ialr->bias =get_bias (fd); + ialr->start = ialr->bias; + ialr->end = ialr->gtt_size -RESERVED ; + + ialr->allocated_objects =0 ; + +return ial; +}
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 8/40 lib/intel_allocator: Add intel_allocator core
In reply to Zbigniew KempczyńskiFor discrete gens we have to cease of using relocations when batch buffers are submitted to GPU. On cards which have ppgtt we can use softpin establishing addresses on our own.
We added simple allocator (taken from Mesa; works on lists) and random allocator to exercise batches with different addresses. All of that works for single VM (context) so we have to add additional layer (intel_allocator) to support multiprocessing / multithreading.
For main IGT process (also for threads created in it) intel_allocator resolves addresses "locally", just by mutexing access to global allocator data (ctx/vm map). When fork() is in use children cannot establish addresses on they own and have to contact to the thread spawned within main IGT process. Currently SysV IPC message queue was chosen as a communication channel between children and allocator thread. Child calls same functions as main IGT process, only communication path will be chosen instead of acquiring addresses locally.
v2:
Add intel_allocator_open_full() to allow user pass vm range. Add strategy: NONE, LOW_TO_HIGH, HIGH_TO_LOW passed to allocator backend.
v3:
Child is now able to use allocator directly as standalone. It only need to call intel_allocator_init() to reinitialize appropriate structures.
v4:
Add pseudo allocator - INTEL_ALLOCATOR_RELOC which just increments offsets to avoid unnecessary conditional code.
v5:
Alter allocator core according to igt_map changes.
v6:
Add internal version __intel_allocator_alloc() to return ALLOC_INVALID_ADDRESS without assertion.
--- .../igt-gpu-tools/igt-gpu-tools-docs.xml | 1 + lib/Makefile.sources | 6 + lib/igt_core.c | 14 + lib/intel_allocator.c | 1352 +++++++++++++++++ lib/intel_allocator.h | 223 +++ lib/intel_allocator_msgchannel.c | 187 +++ lib/intel_allocator_msgchannel.h | 156 ++ lib/meson.build | 5 + 8 files changed, 1944 insertions(+) create mode 100644 lib/intel_allocator.c create mode 100644 lib/intel_allocator.h create mode 100644 lib/intel_allocator_msgchannel.c create mode 100644 lib/intel_allocator_msgchannel.h
docs/reference/igt-gpu-tools/igt-gpu-tools-docs.xml +1 -0
@@ -43,6 +43,7 @@ <xi:include href="xml/igt_vc4.xml"/> <xi:include href="xml/igt_vgem.xml"/> <xi:include href="xml/igt_x86.xml"/> + <xi:include href="xml/intel_allocator.xml"/> <xi:include href="xml/intel_batchbuffer.xml"/> <xi:include href="xml/intel_bufops.xml"/> <xi:include href="xml/intel_chipset.xml"/>
lib/Makefile.sources +6 -0
@@ -121,6 +121,12 @@ lib_source_list = \ surfaceformat.h \ sw_sync.c \ sw_sync.h \ + intel_allocator.c \ + intel_allocator.h \ + intel_allocator_random.c \ + intel_allocator_simple.c \ + intel_allocator_msgchannel.c \ + intel_allocator_msgchannel.h \ intel_aux_pgtable.c \ intel_reg_map.c \ intel_iosf.c \
lib/igt_core.c +14 -0
@@ -58,6 +58,7 @@#include <glib.h> #include "drmtest.h" +#include "intel_allocator.h" #include "intel_chipset.h" #include "intel_io.h" #include "igt_debugfs.h"
@@ -1412,6 +1413,19 @@ __noreturn static void exit_subtest(const char *result) } num_test_children =0 ; +/* +* When test completes - mostly in fail state it can leave allocated +* objects. An allocator is not an exception as it is global IGT +* entity and when test will allocate some ranges and then it will +* fail no free/close likely will be called (controling potential +* fails and clearing before assertions in IGT is not common). +* +* We call intel_allocator_init() then to prepare the allocator +* infrastructure from scratch for each test. Init also removes +* remnants from previous allocator run (if any). +*/ +intel_allocator_init (); +if (!in_dynamic_subtest) _igt_dynamic_tests_executed =-1 ;
lib/intel_allocator.c new file +1352 -0
1,352 lines not on this page · raw message
lib/intel_allocator.h new file +223 -0
223 lines not on this page · raw message
lib/intel_allocator_msgchannel.c new file +187 -0
187 lines not on this page · raw message
lib/intel_allocator_msgchannel.h new file +156 -0
156 lines not on this page · raw message
lib/meson.build +5 -0
@@ -34,6 +34,11 @@ lib_sources = [ 'igt_vgem.c', 'igt_x86.c', 'instdone.c', + 'intel_allocator.c', + 'intel_allocator_msgchannel.c', + 'intel_allocator_random.c', + 'intel_allocator_reloc.c', + 'intel_allocator_simple.c', 'intel_batchbuffer.c', 'intel_bufops.c', 'intel_chipset.c',
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 9/40 lib/intel_allocator: Try to stop smoothly instead of deinit
In reply to Zbigniew KempczyńskiAvoid race when stop was send to allocator thread. We wait around 100 ms to give thread chance to stop smoothly instead of removing queue and enforcing exiting all blocked message syscalls.
--- lib/intel_allocator.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
lib/intel_allocator.c +14 -0
@@ -106,6 +106,7 @@ static pthread_mutex_t map_mutex = PTHREAD_MUTEX_INITIALIZER;static bool multiprocess;static pthread_t allocator_thread; +static bool allocator_thread_running;static bool warn_if_not_empty;
@@ -735,6 +736,8 @@ static void *allocator_thread_loop(void *data) (long) allocator_pid, (long) gettid());alloc_info ("Entering allocator loop\n" ); +WRITE_ONCE (allocator_thread_running, true); +while (1 ) { ret =recv_req (channel, &req);
@@ -768,6 +771,8 @@ static void *allocator_thread_loop(void *data) } } +WRITE_ONCE (allocator_thread_running, false); +return NULL ; }
@@ -807,15 +812,24 @@ void intel_allocator_multiprocess_start(void)* Function turns off intel_allocator multiprocess mode what means * stopping allocator thread and deinitializing its data. */ +#define STOP_TIMEOUT_MS 100void intel_allocator_multiprocess_stop (void ) { +int time_left =STOP_TIMEOUT_MS ; +alloc_info ("allocator multiprocess stop\n" );if (multiprocess) {send_alloc_stop (channel); + +/* Give allocator thread time to complete */ +while (time_left-- >0 &&READ_ONCE (allocator_thread_running)) +usleep (1000 );/* coarse calculation */ +/* Deinit, this should stop all blocked syscalls, if any */ channel->deinit (channel);pthread_join (allocator_thread,NULL ); +/* But we're not sure does child will stuck */ kill_children (SIGINT );igt_waitchildren_timeout (5 ,"Stopping children" );
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 10/40 lib/intel_allocator_msgchannel: Scale to 4k of parallel clients
In reply to Zbigniew KempczyńskiWhen playing with multiprocess mode in allocator we're currently using sysvipc message queues in blocking mode (request/response). We can calculate then what is maximum depth for the queue for requested number of children. Change alters kernel queue depth to cover 4k users (1 is main thread and 4095 are children).
We're still prone to unlimited wait in allocator thread (more than 4095 children successfully send the messages) but we're going to address this later.
--- lib/intel_allocator_msgchannel.c | 8 ++++++++ 1 file changed, 8 insertions(+)
lib/intel_allocator_msgchannel.c +8 -0
@@ -17,6 +17,7 @@ extern __thread pid_t child_tid;#define FTOK_IGT_ALLOCATOR_KEY "/tmp/igt.allocator.key"#define FTOK_IGT_ALLOCATOR_PROJID 2020 +#define MAXQLEN 4096#define ALLOCATOR_REQUEST 1
@@ -62,6 +63,13 @@ static void msgqueue_init(struct msg_channel *channel) queue =msgget (key,IPC_CREAT );igt_debug ("msg queue: %d\n" , queue); +igt_assert (msgctl (queue,IPC_STAT , &qstat) ==0 ); +igt_debug ("msg size in bytes: %lu\n" , qstat.msg_qbytes); + qstat.msg_qbytes =MAXQLEN *sizeof (struct msgqueue_buf ); +igt_debug ("resizing queue to support %d requests\n" ,MAXQLEN ); +igt_assert_f (msgctl (queue,IPC_SET , &qstat) ==0 , +"Couldn't change queue size to %lu\n" , qstat.msg_qbytes); + msgdata =calloc (1 ,sizeof (*msgdata));igt_assert (msgdata); msgdata->key = key;
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 11/40 lib/intel_allocator: Separate allocator multiprocess start
In reply to Zbigniew KempczyńskiValidating allocator code (leaks and memory overwriting) can be done with address sanitizer. When allocator is not working in multiprocess mode it is easy, problems start when fork is in the game. In this situation we need to separate preparation and starting allocator thread.
--- lib/intel_allocator.c | 41 ++++++++++++++++++++++++++++++++++------- lib/intel_allocator.h | 2 ++ 2 files changed, 36 insertions(+), 7 deletions(-)
lib/intel_allocator.c +34 -7
@@ -776,6 +776,38 @@ static void *allocator_thread_loop(void *data)return NULL ; } + +/** +* __intel_allocator_multiprocess_prepare: +* +* Prepares allocator infrastructure to work in multiprocess mode. +* +* Some description is required why prepare/start steps are separated. +* When we write the code and we don't use address sanitizer simple +* intel_allocator_multiprocess_start() call is enough. With address +* sanitizer and using forking we can encounter situation where one +* forked child called allocator alloc() (so parent has some poisoned +* memory in shadow map), then second fork occurs. Second child will +* get poisoned shadow map from parent (there allocator thread reside). +* Checking shadow map in this child will report memory leak. +* +* How to separate initialization steps take a look into api_intel_allocator.c +* fork_simple_stress() function. +*/ +void __intel_allocator_multiprocess_prepare (void ) +{ +intel_allocator_init (); + + multiprocess = true; + channel->init (channel); +} + +void __intel_allocator_multiprocess_start (void ) +{ +pthread_create (&allocator_thread,NULL , + allocator_thread_loop,NULL ); +} +/** * intel_allocator_multiprocess_start: *
@@ -797,13 +829,8 @@ void intel_allocator_multiprocess_start(void)igt_assert_f (child_pid ==-1 ,"Allocator thread can be spawned only in main IGT process\n" ); -intel_allocator_init (); - - multiprocess = true; - channel->init (channel); - -pthread_create (&allocator_thread,NULL , - allocator_thread_loop,NULL ); +__intel_allocator_multiprocess_prepare (); +__intel_allocator_multiprocess_start (); }/**
lib/intel_allocator.h +2 -0
@@ -160,6 +160,8 @@ struct intel_allocator { };void intel_allocator_init (void ); +void __intel_allocator_multiprocess_prepare (void ); +void __intel_allocator_multiprocess_start (void );void intel_allocator_multiprocess_start (void );void intel_allocator_multiprocess_stop (void );
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 12/40 lib/intel_bufops: Change size from 32->64 bit
In reply to Zbigniew Kempczyński1. Buffer size from 32 -> 64 bit was changed to be consistent with drm code.
2. Remember buffer creation size to avoid recalculation.
--- lib/intel_bufops.c | 17 ++++++++--------- lib/intel_bufops.h | 7 +++++-- tests/i915/api_intel_bb.c | 6 +++--- 3 files changed, 16 insertions(+), 14 deletions(-)
lib/intel_bufops.c +8 -9
@@ -711,7 +711,7 @@ static void __intel_buf_init(struct buf_ops *bops, uint32_t req_tiling, uint32_t compression) {uint32_t tiling = req_tiling; -uint32_t size; +uint64_t size;uint32_t devid;int tile_width;int align_h =1 ;
@@ -776,6 +776,9 @@ static void __intel_buf_init(struct buf_ops *bops, size = buf->surface[0 ].stride *ALIGN (height, align_h); } +/* Store real bo size to avoid mistakes in calculating it again */ + buf->size = size; +if (handle) buf->handle = handle;else
@@ -1001,8 +1004,8 @@ void intel_buf_flush_and_unmap(struct intel_buf *buf)void intel_buf_print (const struct intel_buf *buf) {igt_info ("[name: %s]\n" , buf->name); - igt_info("[%u]: w: %u, h: %u, stride: %u, size: %u, bo-size: %u, " - "bpp: %u, tiling: %u, compress: %u\n", + igt_info("[%u]: w: %u, h: %u, stride: %u, size: %" PRIx64 + ", bo-size: %" PRIx64 ", bpp: %u, tiling: %u, compress: %u\n", buf->handle, intel_buf_width(buf), intel_buf_height(buf), buf->surface[0].stride, buf->surface[0].size, intel_buf_bo_size(buf), buf->bpp,
@@ -1208,13 +1211,9 @@ static void idempotency_selftest(struct buf_ops *bops, uint32_t tiling)buf_ops_set_software_tiling (bops, tiling, false); } -uint32_t intel_buf_bo_size (const struct intel_buf *buf) +uint64_t intel_buf_bo_size (const struct intel_buf *buf) { -int offset =CCS_OFFSET (buf) ?: buf->surface[0 ].size; -int ccs_size = - buf->compression ?CCS_SIZE (buf->bops->intel_gen, buf) :0 ; - -return offset + ccs_size; +return buf->size; }static struct buf_ops *__buf_ops_create (int fd,bool check_idempotency)
lib/intel_bufops.h +5 -2
@@ -9,10 +9,13 @@ struct buf_ops;#define INTEL_BUF_INVALID_ADDRESS (-1ull)#define INTEL_BUF_NAME_MAXSIZE 32 +#define INVALID_ADDR (x) ((x) == INTEL_BUF_INVALID_ADDRESS) +struct intel_buf {struct buf_ops *bops;bool is_owner;uint32_t handle; +uint64_t size;uint32_t tiling;uint32_t bpp;uint32_t compression;
@@ -23,7 +26,7 @@ struct intel_buf {struct {uint32_t offset;uint32_t stride; -uint32_t size; +uint64_t size; } surface[2 ];struct {uint32_t offset;
@@ -88,7 +91,7 @@ intel_buf_ccs_height(int gen, const struct intel_buf *buf)return DIV_ROUND_UP (intel_buf_height (buf),512 ) *32 ; } -uint32_t intel_buf_bo_size (const struct intel_buf *buf); +uint64_t intel_buf_bo_size (const struct intel_buf *buf);struct buf_ops *buf_ops_create (int fd);struct buf_ops *buf_ops_create_with_selftest (int fd);
tests/i915/api_intel_bb.c +3 -3
@@ -123,9 +123,9 @@ static void print_buf(struct intel_buf *buf, const char *name) ptr =gem_mmap__device_coherent (i915, buf->handle,0 , buf->surface[0 ].size,PROT_READ ); -igt_debug ("[%s] Buf handle: %d, size: %d, v: 0x%02x, presumed_addr: %p\n" , +igt_debug ("[%s] Buf handle: %d, size: %" PRIx64", v: 0x%02x, presumed_addr: %p\n" , name, buf->handle, buf->surface[0 ].size, ptr[0 ], -from_user_pointer (buf->addr.offset)); +from_user_pointer (buf->addr.offset));munmap (ptr, buf->surface[0 ].size); }
@@ -677,7 +677,7 @@ static int dump_base64(const char *name, struct intel_buf *buf)if (ret !=Z_OK ) {igt_warn ("error compressing, ret: %d\n" , ret); }else { -igt_info ("compressed %u -> %lu\n" , +igt_info ("compressed %" PRIx64" -> %lu\n" , buf->surface[0 ].size, outsize);igt_info ("--- %s ---\n" , name);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 13/40 lib/intel_bufops: Add init with handle and size function
In reply to Zbigniew KempczyńskiFor some cases (fb with compression) fb size is bigger than calculated intel_buf what lead to execbuf failure when allocator is used along with EXEC_OBJECT_PINNED flag set for all objects.
We need to create intel_buf with size equal to fb so new function in which we pass handle and size is required.
v2: add bo_size check to better protect input size (Jason)
--- lib/intel_bufops.c | 34 +++++++++++++++++++++++++++++++--- lib/intel_bufops.h | 7 +++++++ 2 files changed, 38 insertions(+), 3 deletions(-)
lib/intel_bufops.c +31 -3
@@ -708,7 +708,8 @@ static void __intel_buf_init(struct buf_ops *bops,uint32_t handle, struct intel_buf *buf, int width, int height, int bpp, int alignment, - uint32_t req_tiling, uint32_t compression) + uint32_t req_tiling, uint32_t compression, + uint64_t bo_size) { uint32_t tiling = req_tiling;uint64_t size;
@@ -776,6 +777,11 @@ static void __intel_buf_init(struct buf_ops *bops, size = buf->surface[0 ].stride *ALIGN (height, align_h); } +if (bo_size >0 ) { +igt_assert (bo_size >= size); + size = bo_size; + } +/* Store real bo size to avoid mistakes in calculating it again */ buf->size = size;
@@ -809,7 +815,7 @@ void intel_buf_init(struct buf_ops *bops, uint32_t tiling, uint32_t compression) { __intel_buf_init(bops, 0, buf, width, height, bpp, alignment, -tiling ,compression ); + tiling, compression, 0);intel_buf_set_ownership (buf, true); }
@@ -858,7 +864,7 @@ void intel_buf_init_using_handle(struct buf_ops *bops, uint32_t req_tiling, uint32_t compression) {__intel_buf_init (bops ,handle ,buf ,width ,height ,bpp ,alignment , -req_tiling ,compression ); + req_tiling, compression, 0); }/**
@@ -927,6 +933,28 @@ struct intel_buf *intel_buf_create_using_handle(struct buf_ops *bops,return buf; } +struct intel_buf *intel_buf_create_using_handle_and_size (struct buf_ops *bops, +uint32_t handle, +int width,int height, +int bpp,int alignment, +uint32_t req_tiling, +uint32_t compression, +uint64_t size) +{ +struct intel_buf *buf; + +igt_assert (bops); + + buf =calloc (1 ,sizeof (*buf)); +igt_assert (buf); + +__intel_buf_init (bops, handle, buf, width, height, bpp, alignment, + req_tiling, compression, size); + +return buf; +} + +/** * intel_buf_destroy * @buf: intel_buf
lib/intel_bufops.h +7 -0
@@ -139,6 +139,13 @@ struct intel_buf *intel_buf_create_using_handle(struct buf_ops *bops,uint32_t req_tiling, uint32_t compression); +struct intel_buf *intel_buf_create_using_handle_and_size (struct buf_ops *bops, +uint32_t handle, +int width,int height, +int bpp,int alignment, +uint32_t req_tiling, +uint32_t compression, +uint64_t size);void intel_buf_destroy (struct intel_buf *buf);void *intel_buf_cpu_map (struct intel_buf *buf,bool write);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 14/40 lib/intel_batchbuffer: Integrate intel_bb with allocator
In reply to Zbigniew KempczyńskiRefactor the intel-bb interface to introduce the IGT allocator for specifying the position of objects within the ppGTT.
--- lib/intel_aux_pgtable.c | 26 +- lib/intel_batchbuffer.c | 511 +++++++++++++++++++++++++---------- lib/intel_batchbuffer.h | 23 +- tests/i915/api_intel_bb.c | 16 +- tests/i915/gem_mmap_offset.c | 4 +- 5 files changed, 403 insertions(+), 177 deletions(-)
lib/intel_aux_pgtable.c +11 -15
@@ -94,9 +94,9 @@ pgt_table_count(int address_bits, struct intel_buf **bufs, int buf_count)/* We require bufs to be sorted. */ igt_assert (i ==0 || buf->addr.offset >= bufs[i -1 ]->addr.offset + -intel_buf_bo_size (bufs[i -1 ])); - +intel_buf_bo_size (bufs[i -1 ])); start =ALIGN_DOWN (buf->addr.offset,1UL << address_bits); +/* Avoid double counting for overlapping aligned bufs. */ start =max (start, end);
@@ -346,10 +346,8 @@ pgt_populate_entries_for_buf(struct pgtable *pgt,uint64_t top_table, int surface_idx) { - uint64_t surface_addr = buf->addr.offset + - buf->surface[surface_idx].offset; -uint64_t surface_end = surface_addr + - buf->surface[surface_idx].size; + uint64_t surface_addr = buf->addr.offset + buf->surface[surface_idx].offset; +uint64_t surface_end = surface_addr + buf->surface[surface_idx].size;uint64_t aux_addr = buf->addr.offset + buf->ccs[surface_idx].offset;uint64_t l1_flags =pgt_get_l1_flags (buf, surface_idx);uint64_t lx_flags =pgt_get_lx_flags ();
@@ -441,7 +439,6 @@ struct intel_buf * intel_aux_pgtable_create(struct intel_bb *ibb, struct intel_buf **bufs, int buf_count) { - struct drm_i915_gem_exec_object2 *obj; static const struct pgtable_level_desc level_desc[] = { { .idx_shift = 16,
@@ -465,7 +462,6 @@ intel_aux_pgtable_create(struct intel_bb *ibb,struct pgtable *pgt;struct buf_ops *bops;struct intel_buf *buf; -uint64_t prev_alignment;igt_assert (buf_count); bops = bufs[0 ]->bops;
@@ -476,11 +472,8 @@ intel_aux_pgtable_create(struct intel_bb *ibb, I915_COMPRESSION_NONE);/* We need to use pgt->max_align for aux table */ - prev_alignment =intel_bb_set_default_object_alignment (ibb, - pgt->max_align); - obj =intel_bb_add_intel_buf (ibb, pgt->buf, false); -intel_bb_set_default_object_alignment (ibb, prev_alignment); - obj->alignment = pgt->max_align; +intel_bb_add_intel_buf_with_alignment (ibb, pgt->buf, + pgt->max_align, false);pgt_map (ibb->i915, pgt);pgt_populate_entries (pgt, bufs, buf_count);
@@ -498,9 +491,10 @@ aux_pgtable_reserve_buf_slot(struct intel_buf **bufs, int buf_count, {int i; -for (i =0 ; i < buf_count; i++) +for (i =0 ; i < buf_count; i++) {if (bufs[i]->addr.offset > new_buf->addr.offset)break ; + }memmove (&bufs[i +1 ], &bufs[i],sizeof (bufs[0 ]) * (buf_count - i));
@@ -606,8 +600,10 @@ gen12_aux_pgtable_cleanup(struct intel_bb *ibb, struct aux_pgtable_info *info)igt_assert_eq_u64 (addr, info->buf_pin_offsets[i]); } -if (info->pgtable_buf) +if (info->pgtable_buf) { +intel_bb_remove_intel_buf (ibb, info->pgtable_buf);intel_buf_destroy (info->pgtable_buf); + } }uint32_t
lib/intel_batchbuffer.c +363 -148
764 lines not on this page · raw message
lib/intel_batchbuffer.h +19 -4
@@ -8,6 +8,7 @@#include "igt_core.h" #include "intel_reg.h" #include "drmtest.h" +#include "intel_allocator.h" #define BATCH_SZ 4096#define BATCH_RESERVED 16
@@ -441,6 +442,9 @@ igt_media_spinfunc_t igt_get_media_spinfunc(int devid);* Batchbuffer without libdrm dependency */ struct intel_bb { +uint64_t allocator_handle; +uint8_t allocator_type; +int i915;unsigned int gen;bool debug;
@@ -454,9 +458,9 @@ struct intel_bb {uint64_t alignment;int fence; -uint32_t prng;uint64_t gtt_size;bool supports_48b_address; +bool uses_full_ppgtt;uint32_t ctx;
@@ -484,6 +488,8 @@ struct intel_bb {int32_t refcount; }; +struct intel_bb *intel_bb_create_full (int i915,uint32_t ctx,uint32_t size, +uint8_t allocator_type);struct intel_bb *intel_bb_create (int i915,uint32_t size);struct intel_bb *intel_bb_create_with_context (int i915,uint32_t ctx,uint32_t size);
@@ -510,6 +516,7 @@ void intel_bb_dump(struct intel_bb *ibb, const char *filename);void intel_bb_set_debug (struct intel_bb *ibb,bool debug);void intel_bb_set_dump_base64 (struct intel_bb *ibb,bool dump); +/* static inline uint64_t intel_bb_set_default_object_alignment(struct intel_bb *ibb, uint64_t alignment) {
@@ -525,6 +532,7 @@ intel_bb_get_default_object_alignment(struct intel_bb *ibb){ return ibb->alignment; } +*/ static inline uint32_t intel_bb_offset (struct intel_bb *ibb) {
@@ -574,11 +582,16 @@ static inline void intel_bb_out(struct intel_bb *ibb, uint32_t dword) }struct drm_i915_gem_exec_object2 * -intel_bb_add_object (struct intel_bb *ibb,uint32_t handle,uint32_t size, -uint64_t offset,bool write); +intel_bb_add_object (struct intel_bb *ibb,uint32_t handle,uint64_t size, +uint64_t offset,uint64_t alignment,bool write); +bool intel_bb_remove_object (struct intel_bb *ibb,uint32_t handle, +uint64_t offset,uint64_t size);struct drm_i915_gem_exec_object2 *intel_bb_add_intel_buf (struct intel_bb *ibb,struct intel_buf *buf,bool write); - +struct drm_i915_gem_exec_object2 * +intel_bb_add_intel_buf_with_alignment (struct intel_bb *ibb,struct intel_buf *buf, +uint64_t alignment,bool write); +bool intel_bb_remove_intel_buf (struct intel_bb *ibb,struct intel_buf *buf);struct drm_i915_gem_exec_object2 *intel_bb_find_object (struct intel_bb *ibb,uint32_t handle);
@@ -625,6 +638,8 @@ uint64_t intel_bb_offset_reloc_to_object(struct intel_bb *ibb,uint32_t offset, uint64_t presumed_offset); +void intel_bb_dump_cache (struct intel_bb *ibb); +void intel_bb_exec (struct intel_bb *ibb,uint32_t end_offset,uint64_t flags,bool sync);
tests/i915/api_intel_bb.c +8 -8
@@ -810,11 +810,11 @@ static void offset_control(struct buf_ops *bops) dst2 =create_buf (bops,WIDTH ,HEIGHT ,COLOR_77 );intel_bb_add_object (ibb, src->handle,intel_buf_bo_size (src), - src->addr.offset, false); + src->addr.offset,0 , false);intel_bb_add_object (ibb, dst1->handle,intel_buf_bo_size (dst1), - dst1->addr.offset, true); + dst1->addr.offset,0 , true);intel_bb_add_object (ibb, dst2->handle,intel_buf_bo_size (dst2), - dst2->addr.offset, true); + dst2->addr.offset,0 , true);intel_bb_out (ibb,MI_BATCH_BUFFER_END );intel_bb_ptr_align (ibb,8 );
@@ -838,13 +838,13 @@ static void offset_control(struct buf_ops *bops) dst3 =create_buf (bops,WIDTH ,HEIGHT ,COLOR_33 );intel_bb_add_object (ibb, dst3->handle,intel_buf_bo_size (dst3), - dst3->addr.offset, true); + dst3->addr.offset,0 , true);intel_bb_add_object (ibb, src->handle,intel_buf_bo_size (src), - src->addr.offset, false); + src->addr.offset,0 , false);intel_bb_add_object (ibb, dst1->handle,intel_buf_bo_size (dst1), - dst1->addr.offset, true); + dst1->addr.offset,0 , true);intel_bb_add_object (ibb, dst2->handle,intel_buf_bo_size (dst2), - dst2->addr.offset, true); + dst2->addr.offset,0 , true);intel_bb_out (ibb,MI_BATCH_BUFFER_END );intel_bb_ptr_align (ibb,8 );
@@ -901,7 +901,7 @@ static void delta_check(struct buf_ops *bops) buf =create_buf (bops,0x1000 ,0x10 ,COLOR_CC ); buf->addr.offset =0xfffff000 ;intel_bb_add_object (ibb, buf->handle,intel_buf_bo_size (buf), - buf->addr.offset, false); + buf->addr.offset,0 , false);intel_bb_out (ibb,MI_STORE_DWORD_IMM ); intel_bb_emit_reloc(ibb, buf->handle,
tests/i915/gem_mmap_offset.c +2 -2
@@ -614,8 +614,8 @@ static void blt_coherency(int i915) dst =create_bo (bops,1 , width, height); size = src->surface[0 ].size; -intel_bb_add_object (ibb, src->handle, size, src->addr.offset, false); -intel_bb_add_object (ibb, dst->handle, size, dst->addr.offset, true); +intel_bb_add_object (ibb, src->handle, size, src->addr.offset,0 , false); +intel_bb_add_object (ibb, dst->handle, size, dst->addr.offset,0 , true); intel_bb_blt_copy(ibb, src, 0, 0, src->surface[0].stride,
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 15/40 lib/intel_batchbuffer: Use relocations in intel-bb up to gen12
In reply to Zbigniew KempczyńskiWe want to use relocations as long as we can so change intel-bb strategy to use it as default up to gen12. For gen12 we have to use softpinning in ccs aux tables so there we enforce using allocator instead of relocations.
--- lib/intel_batchbuffer.c | 39 ++++++++++++++++++++++++++++----------- 1 file changed, 28 insertions(+), 11 deletions(-)
lib/intel_batchbuffer.c +28 -11
@@ -1275,25 +1275,25 @@ __intel_bb_create(int i915, uint32_t ctx, uint32_t size, bool do_relocs,igt_assert (ibb); ibb->uses_full_ppgtt =gem_uses_full_ppgtt (i915); + ibb->devid =intel_get_drm_devid (i915); + ibb->gen =intel_gen (ibb->devid);/* * If we don't have full ppgtt driver can change our addresses * so allocator is useless in this case. Just enforce relocations * for such gens and don't use allocator at all. */ -if (!ibb->uses_full_ppgtt) { +if (!ibb->uses_full_ppgtt) do_relocs = true; - allocator_type =INTEL_ALLOCATOR_NONE ; - } -if (!do_relocs) - ibb->allocator_handle =intel_allocator_open (i915, ctx, allocator_type); +/* if relocs are set we won't use an allocator */ +if (do_relocs) + allocator_type =INTEL_ALLOCATOR_NONE ;else -igt_assert (allocator_type ==INTEL_ALLOCATOR_NONE ); + ibb->allocator_handle =intel_allocator_open (i915, ctx, allocator_type); + ibb->allocator_type = allocator_type; ibb->i915 = i915; - ibb->devid =intel_get_drm_devid (i915); - ibb->gen =intel_gen (ibb->devid); ibb->enforce_relocs = do_relocs; ibb->handle =gem_create (i915, size); ibb->size = size;
@@ -1327,7 +1327,7 @@ __intel_bb_create(int i915, uint32_t ctx, uint32_t size, bool do_relocs,* * Creates bb with context passed in @ctx, size in @size and allocator type * in @allocator_type. Relocations are set to false because IGT allocator -* is not used in that case. +* is used in that case. * * Returns: *
@@ -1339,6 +1339,11 @@ struct intel_bb *intel_bb_create_full(int i915, uint32_t ctx, uint32_t size,return __intel_bb_create (i915, ctx, size, false, allocator_type); } +static bool aux_needs_softpin (int i915) +{ +return intel_gen (intel_get_drm_devid (i915)) >=12 ; +} +/** * intel_bb_create: * @i915: drm fd
@@ -1361,7 +1366,11 @@ struct intel_bb *intel_bb_create_full(int i915, uint32_t ctx, uint32_t size,*/ struct intel_bb *intel_bb_create (int i915,uint32_t size) { -return __intel_bb_create (i915,0 , size, false,INTEL_ALLOCATOR_SIMPLE ); +bool relocs =gem_has_relocations (i915); + +return __intel_bb_create (i915,0 , size, + relocs && !aux_needs_softpin (i915), +INTEL_ALLOCATOR_SIMPLE ); }/**
@@ -1379,7 +1388,11 @@ struct intel_bb *intel_bb_create(int i915, uint32_t size)struct intel_bb *intel_bb_create_with_context (int i915,uint32_t ctx,uint32_t size) { -return __intel_bb_create (i915, ctx, size, false,INTEL_ALLOCATOR_SIMPLE ); +bool relocs =gem_has_relocations (i915); + +return __intel_bb_create (i915, ctx, size, + relocs && !aux_needs_softpin (i915), +INTEL_ALLOCATOR_SIMPLE ); }/**
@@ -1396,6 +1409,8 @@ intel_bb_create_with_context(int i915, uint32_t ctx, uint32_t size)*/ struct intel_bb *intel_bb_create_with_relocs (int i915,uint32_t size) { +igt_require (gem_has_relocations (i915)); +return __intel_bb_create (i915,0 , size, true,INTEL_ALLOCATOR_NONE ); }
@@ -1415,6 +1430,8 @@ struct intel_bb *intel_bb_create_with_relocs(int i915, uint32_t size)struct intel_bb *intel_bb_create_with_relocs_and_context (int i915,uint32_t ctx,uint32_t size) { +igt_require (gem_has_relocations (i915)); +return __intel_bb_create (i915, ctx, size, true,INTEL_ALLOCATOR_NONE ); }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 16/40 lib/intel_batchbuffer: Create bb with strategy / vm ranges
In reply to Zbigniew KempczyńskiPreviously intel-bb just used default allocator settings (safe, chosen for work from the box). But limitation is not good if we want to exercise non-standard cases (vm ranges for example). As allocator provides passing full settings lets intel-bb also allows to use them.
--- lib/intel_batchbuffer.c | 63 +++++++++++++++++++++++++++++++++-------- lib/intel_batchbuffer.h | 10 +++++-- 2 files changed, 59 insertions(+), 14 deletions(-)
lib/intel_batchbuffer.c +51 -12
@@ -1267,7 +1267,8 @@ static inline uint64_t __intel_bb_get_offset(struct intel_bb *ibb,*/ static struct intel_bb *__intel_bb_create (int i915,uint32_t ctx,uint32_t size,bool do_relocs, -uint8_t allocator_type) +uint64_t start,uint64_t end, +uint8_t allocator_type,enum allocator_strategy strategy) {struct drm_i915_gem_exec_object2 *object;struct intel_bb *ibb =calloc (1 ,sizeof (*ibb));
@@ -1290,9 +1291,12 @@ __intel_bb_create(int i915, uint32_t ctx, uint32_t size, bool do_relocs,if (do_relocs) allocator_type =INTEL_ALLOCATOR_NONE ;else - ibb->allocator_handle =intel_allocator_open (i915, ctx, allocator_type); - + ibb->allocator_handle =intel_allocator_open_full (i915, ctx, + start, end, + allocator_type, + strategy); ibb->allocator_type = allocator_type; + ibb->allocator_strategy = strategy; ibb->i915 = i915; ibb->enforce_relocs = do_relocs; ibb->handle =gem_create (i915, size);
@@ -1323,20 +1327,51 @@ __intel_bb_create(int i915, uint32_t ctx, uint32_t size, bool do_relocs,* @i915: drm fd * @ctx: context * @size: size of the batchbuffer +* @start: allocator vm start address +* @end: allocator vm start address * @allocator_type: allocator type, SIMPLE, RANDOM, ... +* @strategy: allocation strategy * * Creates bb with context passed in @ctx, size in @size and allocator type * in @allocator_type. Relocations are set to false because IGT allocator -* is used in that case. +* is used in that case. VM range is passed to allocator (@start and @end) +* and allocation @strategy (suggestion to allocator about address allocation +* preferences). * * Returns: * * Pointer the intel_bb, asserts on failure. */ struct intel_bb *intel_bb_create_full (int i915,uint32_t ctx,uint32_t size, -uint8_t allocator_type) +uint64_t start,uint64_t end, +uint8_t allocator_type, +enum allocator_strategy strategy) +{ +return __intel_bb_create (i915, ctx, size, false, start, end, + allocator_type, strategy); +} + +/** +* intel_bb_create_with_allocator: +* @i915: drm fd +* @ctx: context +* @size: size of the batchbuffer +* @allocator_type: allocator type, SIMPLE, RANDOM, ... +* +* Creates bb with context passed in @ctx, size in @size and allocator type +* in @allocator_type. Relocations are set to false because IGT allocator +* is used in that case. +* +* Returns: +* +* Pointer the intel_bb, asserts on failure. +*/ +struct intel_bb *intel_bb_create_with_allocator (int i915,uint32_t ctx, +uint32_t size, +uint8_t allocator_type) { -return __intel_bb_create (i915, ctx, size, false, allocator_type); +return __intel_bb_create (i915, ctx, size, false,0 ,0 , + allocator_type,ALLOC_STRATEGY_HIGH_TO_LOW ); }static bool aux_needs_softpin (int i915)
@@ -1369,8 +1404,9 @@ struct intel_bb *intel_bb_create(int i915, uint32_t size)bool relocs =gem_has_relocations (i915);return __intel_bb_create (i915,0 , size, - relocs && !aux_needs_softpin (i915), -INTEL_ALLOCATOR_SIMPLE ); + relocs && !aux_needs_softpin (i915),0 ,0 , +INTEL_ALLOCATOR_SIMPLE , +ALLOC_STRATEGY_HIGH_TO_LOW ); }/**
@@ -1391,8 +1427,9 @@ intel_bb_create_with_context(int i915, uint32_t ctx, uint32_t size)bool relocs =gem_has_relocations (i915);return __intel_bb_create (i915, ctx, size, - relocs && !aux_needs_softpin (i915), -INTEL_ALLOCATOR_SIMPLE ); + relocs && !aux_needs_softpin (i915),0 ,0 , +INTEL_ALLOCATOR_SIMPLE , +ALLOC_STRATEGY_HIGH_TO_LOW ); }/**
@@ -1411,7 +1448,8 @@ struct intel_bb *intel_bb_create_with_relocs(int i915, uint32_t size) {igt_require (gem_has_relocations (i915)); -return __intel_bb_create (i915,0 , size, true,INTEL_ALLOCATOR_NONE ); +return __intel_bb_create (i915,0 , size, true,0 ,0 , +INTEL_ALLOCATOR_NONE ,ALLOC_STRATEGY_NONE ); }/**
@@ -1432,7 +1470,8 @@ intel_bb_create_with_relocs_and_context(int i915, uint32_t ctx, uint32_t size) {igt_require (gem_has_relocations (i915)); -return __intel_bb_create (i915, ctx, size, true,INTEL_ALLOCATOR_NONE ); +return __intel_bb_create (i915, ctx, size, true,0 ,0 , +INTEL_ALLOCATOR_NONE ,ALLOC_STRATEGY_NONE ); }static void __intel_bb_destroy_relocations (struct intel_bb *ibb)
lib/intel_batchbuffer.h +8 -2
@@ -444,6 +444,7 @@ igt_media_spinfunc_t igt_get_media_spinfunc(int devid);struct intel_bb {uint64_t allocator_handle;uint8_t allocator_type; +enum allocator_strategy allocator_strategy;int i915;unsigned int gen;
@@ -488,8 +489,13 @@ struct intel_bb {int32_t refcount; }; -struct intel_bb *intel_bb_create_full (int i915,uint32_t ctx,uint32_t size, -uint8_t allocator_type); +struct intel_bb * +intel_bb_create_full (int i915,uint32_t ctx,uint32_t size, +uint64_t start,uint64_t end, +uint8_t allocator_type,enum allocator_strategy strategy); +struct intel_bb * +intel_bb_create_with_allocator (int i915,uint32_t ctx, +uint32_t size,uint8_t allocator_type);struct intel_bb *intel_bb_create (int i915,uint32_t size);struct intel_bb *intel_bb_create_with_context (int i915,uint32_t ctx,uint32_t size);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 17/40 lib/intel_batchbuffer: Add tracking intel_buf to intel_bb
In reply to Zbigniew KempczyńskiFrom now on intel_bb starts tracking added/removed intel_bufs. We're safe now regardless order of intel_buf close/destroy or intel_bb destroy paths.
When intel_buf is closed/destroyed first and it was previously added to intel_bb it calls the code which removes itself from intel_bb. In destroy path we go over all tracked intel_bufs and clear tracking information and buffer offset (it is set to INTEL_BUF_INVALID_ADDRESS).
Reset path is handled as follows:
- intel_bb_reset(ibb, false) - just clean objects array leaving cache / allocator state intact.
- intel_bb_reset(ibb, true) - purge cache as well as detach intel_bufs from intel_bb (release offsets from allocator).
Remove intel_bb_object_offset_to_buf() function as tracking intel_buf updates (checks for allocator) their offsets after execbuf.
Alter api_intel_bb according to intel-bb changes.
--- lib/intel_batchbuffer.c | 186 ++++++++++++++++++++++++++++---------- lib/intel_batchbuffer.h | 29 +++--- lib/intel_bufops.c | 13 ++- lib/intel_bufops.h | 6 ++ lib/media_spin.c | 2 - tests/i915/api_intel_bb.c | 7 -- 6 files changed, 169 insertions(+), 74 deletions(-)
lib/intel_batchbuffer.c +140 -46
@@ -1261,6 +1261,8 @@ static inline uint64_t __intel_bb_get_offset(struct intel_bb *ibb,* If we do reset without purging caches we use addresses from intel-bb cache * during execbuf objects construction. * +* If we do reset with purging caches allocator entries are freed as well. +* * Returns: * * Pointer the intel_bb, asserts on failure.
@@ -1303,6 +1305,7 @@ __intel_bb_create(int i915, uint32_t ctx, uint32_t size, bool do_relocs, ibb->size = size; ibb->alignment =4096 ; ibb->ctx = ctx; + ibb->vm_id =0 ; ibb->batch =calloc (1 , size);igt_assert (ibb->batch); ibb->ptr = ibb->batch;
@@ -1317,6 +1320,8 @@ __intel_bb_create(int i915, uint32_t ctx, uint32_t size, bool do_relocs, false); ibb->batch_offset = object->offset; +IGT_INIT_LIST_HEAD (&ibb->intel_bufs); + ibb->refcount =1 ;return ibb;
@@ -1508,6 +1513,22 @@ static void __intel_bb_destroy_cache(struct intel_bb *ibb) ibb->root =NULL ; } +static void __intel_bb_detach_intel_bufs (struct intel_bb *ibb) +{ +struct intel_buf *entry, *tmp; + +igt_list_for_each_entry_safe (entry, tmp, &ibb->intel_bufs, link) +intel_bb_detach_intel_buf (ibb, entry); +} + +static void __intel_bb_remove_intel_bufs (struct intel_bb *ibb) +{ +struct intel_buf *entry, *tmp; + +igt_list_for_each_entry_safe (entry, tmp, &ibb->intel_bufs, link) +intel_bb_remove_intel_buf (ibb, entry); +} +/** * intel_bb_destroy: * @ibb: pointer to intel_bb
@@ -1521,6 +1542,7 @@ void intel_bb_destroy(struct intel_bb *ibb) ibb->refcount--;igt_assert_f (ibb->refcount ==0 ,"Trying to destroy referenced bb!" ); +__intel_bb_remove_intel_bufs (ibb);__intel_bb_destroy_relocations (ibb);__intel_bb_destroy_objects (ibb);__intel_bb_destroy_cache (ibb);
@@ -1544,6 +1566,10 @@ void intel_bb_destroy(struct intel_bb *ibb)* @purge_objects_cache: if true destroy internal execobj and relocs + cache * * Recreate batch bo when there's no additional reference. +* +* When purge_object_cache == true we destroy cache as well as remove intel_buf +* from intel-bb tracking list. Removing intel_bufs releases their addresses +* in the allocator. */ void intel_bb_reset (struct intel_bb *ibb,bool purge_objects_cache)
@@ -1569,8 +1595,10 @@ void intel_bb_reset(struct intel_bb *ibb, bool purge_objects_cache)__intel_bb_destroy_objects (ibb);__reallocate_objects (ibb); -if (purge_objects_cache) +if (purge_objects_cache) { +__intel_bb_remove_intel_bufs (ibb);__intel_bb_destroy_cache (ibb); + }/* * When we use allocators we're in no-reloc mode so we have to free
@@ -1621,6 +1649,50 @@ int intel_bb_sync(struct intel_bb *ibb)return ret; } +uint64_t intel_bb_assign_vm (struct intel_bb *ibb,uint64_t allocator, +uint32_t vm_id) +{ +struct drm_i915_gem_context_param arg = { + .param =I915_CONTEXT_PARAM_VM , + }; +uint64_t prev_allocator = ibb->allocator_handle; +bool closed = false; + +if (ibb->vm_id == vm_id) { +igt_debug ("Skipping to assign same vm_id: %u\n" , vm_id); +return 0 ; + } + +/* Cannot switch if someone keeps bb refcount */ +igt_assert (ibb->refcount ==1 ); + +/* Detach intel_bufs and remove bb handle */ +__intel_bb_detach_intel_bufs (ibb); +intel_bb_remove_object (ibb, ibb->handle, ibb->batch_offset, ibb->size); + +/* Cache + objects are not valid after change anymore */ +__intel_bb_destroy_objects (ibb); +__intel_bb_destroy_cache (ibb); + +/* Attach new allocator */ + ibb->allocator_handle = allocator; + +/* Setparam */ + ibb->vm_id = vm_id; + +/* Skip set param, we likely return to default vm */ +if (vm_id) { + arg.ctx_id = ibb->ctx; + arg.value = vm_id; +gem_context_set_param (ibb->i915, &arg); + } + +/* Recreate bb */ +intel_bb_reset (ibb, false); + +return closed ?0 : prev_allocator; +} +/* * intel_bb_print: * @ibb: pointer to intel_bb
@@ -1875,22 +1947,13 @@ intel_bb_add_object(struct intel_bb *ibb, uint32_t handle, uint64_t size, object->offset = offset; -/* Limit current offset to gtt size */ -if (offset !=INTEL_BUF_INVALID_ADDRESS ) { - object->offset =CANONICAL (offset & (ibb->gtt_size -1 )); - }else { - object->offset =__intel_bb_get_offset (ibb, - handle, size, - object->alignment); - } -if (write) object->flags |=EXEC_OBJECT_WRITE ;if (ibb->supports_48b_address) object->flags |=EXEC_OBJECT_SUPPORTS_48B_ADDRESS ; -if (ibb->uses_full_ppgtt && ibb->allocator_type ==INTEL_ALLOCATOR_SIMPLE ) +if (ibb->uses_full_ppgtt && !ibb->enforce_relocs) object->flags |=EXEC_OBJECT_PINNED ;return object;
@@ -1927,6 +1990,9 @@ __intel_bb_add_intel_buf(struct intel_bb *ibb, struct intel_buf *buf, {struct drm_i915_gem_exec_object2 *obj; +igt_assert (ibb); +igt_assert (buf); +igt_assert (!buf->ibb || buf->ibb == ibb);igt_assert (ALIGN (alignment,4096 ) == alignment);if (!alignment) {
@@ -1951,6 +2017,13 @@ __intel_bb_add_intel_buf(struct intel_bb *ibb, struct intel_buf *buf,if (!ibb->enforce_relocs) obj->alignment = alignment; +if (igt_list_empty (&buf->link)) { +igt_list_add_tail (&buf->link, &ibb->intel_bufs); + buf->ibb = ibb; + }else { +igt_assert (buf->ibb == ibb); + } +return obj; }
@@ -1967,18 +2040,53 @@ intel_bb_add_intel_buf_with_alignment(struct intel_bb *ibb, struct intel_buf *bureturn __intel_bb_add_intel_buf (ibb, buf, alignment, write); } +void intel_bb_detach_intel_buf (struct intel_bb *ibb,struct intel_buf *buf) +{ +igt_assert (ibb); +igt_assert (buf); +igt_assert (!buf->ibb || buf->ibb == ibb); + +if (!igt_list_empty (&buf->link)) { + buf->addr.offset =INTEL_BUF_INVALID_ADDRESS ; + buf->ibb =NULL ; +igt_list_del_init (&buf->link); + } +} +bool intel_bb_remove_intel_buf (struct intel_bb *ibb,struct intel_buf *buf) { -bool removed =intel_bb_remove_object (ibb, buf->handle, - buf->addr.offset, -intel_buf_bo_size (buf)); +bool removed; -if (removed) +igt_assert (ibb); +igt_assert (buf); +igt_assert (!buf->ibb || buf->ibb == ibb); + +if (igt_list_empty (&buf->link)) +return false; + + removed =intel_bb_remove_object (ibb, buf->handle, + buf->addr.offset, +intel_buf_bo_size (buf)); +if (removed) { buf->addr.offset =INTEL_BUF_INVALID_ADDRESS ; + buf->ibb =NULL ; +igt_list_del_init (&buf->link); + }return removed; } +void intel_bb_print_intel_bufs (struct intel_bb *ibb) +{ +struct intel_buf *entry; + +igt_list_for_each_entry (entry, &ibb->intel_bufs, link) { +igt_info ("handle: %u, ibb: %p, offset: %lx\n" , + entry->handle, entry->ibb, + (long ) entry->addr.offset); + } +} +struct drm_i915_gem_exec_object2 *intel_bb_find_object (struct intel_bb *ibb,uint32_t handle) {
@@ -2361,6 +2469,7 @@ static void update_offsets(struct intel_bb *ibb, struct drm_i915_gem_exec_object2 *objects) {struct drm_i915_gem_exec_object2 *object; +struct intel_buf *entry;uint32_t i;for (i =0 ; i < ibb->num_objects; i++) {
@@ -2372,11 +2481,23 @@ static void update_offsets(struct intel_bb *ibb,if (i ==0 ) ibb->batch_offset = object->offset; } + +igt_list_for_each_entry (entry, &ibb->intel_bufs, link) { + object =intel_bb_find_object (ibb, entry->handle); +igt_assert (object); + +if (ibb->allocator_type ==INTEL_ALLOCATOR_SIMPLE ) +igt_assert (object->offset == entry->addr.offset); +else + entry->addr.offset = object->offset; + + entry->addr.ctx = ibb->ctx; + } }#define LINELEN 76/* -* @__intel_bb_exec: +* __intel_bb_exec: * @ibb: pointer to intel_bb * @end_offset: offset of the last instruction in the bb * @flags: flags passed directly to execbuf
@@ -2416,6 +2537,9 @@ static int __intel_bb_exec(struct intel_bb *ibb, uint32_t end_offset,if (ibb->dump_base64)intel_bb_dump_base64 (ibb,LINELEN ); +/* For debugging on CI, remove in final series */ +intel_bb_dump_execbuf (ibb, &execbuf); + ret =__gem_execbuf_wr (ibb->i915, &execbuf);if (ret) {intel_bb_dump_execbuf (ibb, &execbuf);
@@ -2493,36 +2617,6 @@ uint64_t intel_bb_get_object_offset(struct intel_bb *ibb, uint32_t handle)return (*found)->offset; } -/** -* intel_bb_object_offset_to_buf: -* @ibb: pointer to intel_bb -* @buf: buffer we want to store last exec offset and context id -* -* Copy object offset used in the batch to intel_buf to allow caller prepare -* other batch likely without relocations. -*/ -bool intel_bb_object_offset_to_buf (struct intel_bb *ibb,struct intel_buf *buf) -{ -struct drm_i915_gem_exec_object2 object = { .handle = buf->handle }; -struct drm_i915_gem_exec_object2 **found; - -igt_assert (ibb); -igt_assert (buf); - - found =tfind ((void *)&object, &ibb->root, __compare_objects); -if (!found) { - buf->addr.offset =0 ; - buf->addr.ctx = ibb->ctx; - -return false; - } - - buf->addr.offset = (*found)->offset & (ibb->gtt_size -1 ); - buf->addr.ctx = ibb->ctx; - -return true; -} -/* * intel_bb_emit_bbe: * @ibb: batchbuffer
lib/intel_batchbuffer.h +11 -18
@@ -6,6 +6,7 @@#include <i915_drm.h> #include "igt_core.h" +#include "igt_list.h" #include "intel_reg.h" #include "drmtest.h" #include "intel_allocator.h"
@@ -464,6 +465,7 @@ struct intel_bb {bool uses_full_ppgtt;uint32_t ctx; +uint32_t vm_id;/* Cache */ void *root;
@@ -481,6 +483,9 @@ struct intel_bb {uint32_t num_relocs;uint32_t allocated_relocs; +/* Tracked intel_bufs */ +struct igt_list_head intel_bufs; +/* * BO recreate in reset path only when refcount == 0 * Currently we don't need to use atomics because intel_bb
@@ -517,29 +522,15 @@ static inline void intel_bb_unref(struct intel_bb *ibb)void intel_bb_reset (struct intel_bb *ibb,bool purge_objects_cache);int intel_bb_sync (struct intel_bb *ibb); + +uint64_t intel_bb_assign_vm (struct intel_bb *ibb,uint64_t allocator, +uint32_t vm_id); +void intel_bb_print (struct intel_bb *ibb);void intel_bb_dump (struct intel_bb *ibb,const char *filename);void intel_bb_set_debug (struct intel_bb *ibb,bool debug);void intel_bb_set_dump_base64 (struct intel_bb *ibb,bool dump); -/* -static inline uint64_t -intel_bb_set_default_object_alignment(struct intel_bb *ibb, uint64_t alignment) -{ -uint64_t old = ibb->alignment; - -ibb->alignment = alignment; - -return old; -} - -static inline uint64_t -intel_bb_get_default_object_alignment(struct intel_bb *ibb) -{ -return ibb->alignment; -} -*/ -static inline uint32_t intel_bb_offset (struct intel_bb *ibb) {return (uint32_t ) ((uint8_t *) ibb->ptr - (uint8_t *) ibb->batch);
@@ -597,7 +588,9 @@ intel_bb_add_intel_buf(struct intel_bb *ibb, struct intel_buf *buf, bool write);struct drm_i915_gem_exec_object2 *intel_bb_add_intel_buf_with_alignment (struct intel_bb *ibb,struct intel_buf *buf,uint64_t alignment,bool write); +void intel_bb_detach_intel_buf (struct intel_bb *ibb,struct intel_buf *buf);bool intel_bb_remove_intel_buf (struct intel_bb *ibb,struct intel_buf *buf); +void intel_bb_print_intel_bufs (struct intel_bb *ibb);struct drm_i915_gem_exec_object2 *intel_bb_find_object (struct intel_bb *ibb,uint32_t handle);
lib/intel_bufops.c +12 -1
@@ -727,6 +727,7 @@ static void __intel_buf_init(struct buf_ops *bops, buf->bops = bops; buf->addr.offset =INTEL_BUF_INVALID_ADDRESS ; +IGT_INIT_LIST_HEAD (&buf->link);if (compression) {int aux_width, aux_height;
@@ -827,13 +828,23 @@ void intel_buf_init(struct buf_ops *bops,* * Function closes gem BO inside intel_buf if bo is owned by intel_buf. * For handle passed from the caller intel_buf doesn't take ownership and -* doesn't close it in close()/destroy() paths. +* doesn't close it in close()/destroy() paths. When intel_buf was previously +* added to intel_bb (intel_bb_add_intel_buf() call) it is tracked there and +* must be removed from its internal structures. */ void intel_buf_close (struct buf_ops *bops,struct intel_buf *buf) {igt_assert (bops);igt_assert (buf); +/* If buf is tracked by some intel_bb ensure it will be removed there */ +if (buf->ibb) { +intel_bb_remove_intel_buf (buf->ibb, buf); + buf->addr.offset =INTEL_BUF_INVALID_ADDRESS ; + buf->ibb =NULL ; +IGT_INIT_LIST_HEAD (&buf->link); + } +if (buf->is_owner)gem_close (bops->fd, buf->handle); }
lib/intel_bufops.h +6 -0
@@ -2,6 +2,7 @@#define __INTEL_BUFOPS_H__#include <stdint.h> +#include "igt_list.h" #include "igt_aux.h" #include "intel_batchbuffer.h"
@@ -13,6 +14,7 @@ struct buf_ops;struct intel_buf {struct buf_ops *bops; +bool is_owner;uint32_t handle;uint64_t size;
@@ -40,6 +42,10 @@ struct intel_buf {uint32_t ctx; } addr; +/* Tracking */ +struct intel_bb *ibb; +struct igt_list_head link; +/* CPU mapping */ uint32_t *ptr;bool cpu_write;
lib/media_spin.c +0 -2
@@ -132,7 +132,6 @@ gen8_media_spinfunc(int i915, struct intel_buf *buf, uint32_t spins)intel_bb_exec (ibb,intel_bb_offset (ibb),I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , false); -intel_bb_object_offset_to_buf (ibb, buf);intel_bb_destroy (ibb); }
@@ -186,6 +185,5 @@ gen9_media_spinfunc(int i915, struct intel_buf *buf, uint32_t spins)intel_bb_exec (ibb,intel_bb_offset (ibb),I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , false); -intel_bb_object_offset_to_buf (ibb, buf);intel_bb_destroy (ibb); }
tests/i915/api_intel_bb.c +0 -7
@@ -828,9 +828,6 @@ static void offset_control(struct buf_ops *bops)print_buf (dst2,"dst2" ); } -igt_assert (intel_bb_object_offset_to_buf (ibb, src) == true); -igt_assert (intel_bb_object_offset_to_buf (ibb, dst1) == true); -igt_assert (intel_bb_object_offset_to_buf (ibb, dst2) == true); poff_src = src->addr.offset; poff_dst1 = dst1->addr.offset; poff_dst2 = dst2->addr.offset;
@@ -853,10 +850,6 @@ static void offset_control(struct buf_ops *bops) I915_EXEC_DEFAULT | I915_EXEC_NO_RELOC, false);intel_bb_sync (ibb); -igt_assert (intel_bb_object_offset_to_buf (ibb, src) == true); -igt_assert (intel_bb_object_offset_to_buf (ibb, dst1) == true); -igt_assert (intel_bb_object_offset_to_buf (ibb, dst2) == true); -igt_assert (intel_bb_object_offset_to_buf (ibb, dst3) == true);igt_assert (poff_src == src->addr.offset);igt_assert (poff_dst1 == dst1->addr.offset);igt_assert (poff_dst2 == dst2->addr.offset);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 18/40 lib/intel_batchbuffer: Don't collect relocations for newer gens
In reply to Zbigniew KempczyńskiPreparing universal batches for rendercopy, gpgpu fill and media fill must take into account does kernel support relocations for specified gen or not.
In intel-bb we assume relocations are supported so user is calling intel_bb_emit_reloc() like functions to emit address in the batch what collects relocation required for execbuf call in intel-bb. For newer gens kernel will reject such relocations returning -EINVAL so we should just provide an offset (returned from allocator) and skip adding relocation entry to intel-bb.
--- lib/intel_batchbuffer.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
lib/intel_batchbuffer.c +7 -1
@@ -2148,7 +2148,8 @@ intel_bb_object_clear_flag(struct intel_bb *ibb, uint32_t handle, uint64_t flag)* @delta: delta value to add to @buffer's gpu address * @offset: offset within bb to be patched * -* Function allocates additional relocation slot in reloc array for a handle. +* When relocations are requested function allocates additional relocation slot +* in reloc array for a handle. * Object must be previously added to bb. */ static uint64_t intel_bb_add_reloc(struct intel_bb *ibb,
@@ -2167,6 +2168,10 @@ static uint64_t intel_bb_add_reloc(struct intel_bb *ibb, object =intel_bb_find_object (ibb, handle);igt_assert (object); +/* In no-reloc mode we just return the previously assigned address */ +if (!ibb->enforce_relocs) + goto out; +/* For ibb we have relocs allocated in chunks */ if (to_handle == ibb->handle) { relocs = ibb->relocs;
@@ -2207,6 +2212,7 @@ static uint64_t intel_bb_add_reloc(struct intel_bb *ibb, delta, offset, from_user_pointer(relocs[i].presumed_offset)); +out:return object->offset; }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 19/40 lib/igt_fb: Initialize intel_buf with same size as fb
In reply to Zbigniew KempczyńskiWe need to have same size when intel_buf is initialized over fb (with compression) because allocator could be called with smaller size what could lead to relocation.
Use new intel_buf function which allows initialize with handle and size.
--- lib/igt_fb.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
lib/igt_fb.c +5 -5
@@ -2197,11 +2197,11 @@ igt_fb_create_intel_buf(int fd, struct buf_ops *bops, bo_name =gem_flink (fd, fb->gem_handle); handle =gem_open (fd, bo_name); - buf =intel_buf_create_using_handle (bops, handle, - fb->width, fb->height, - fb->plane_bpp[0 ],0 , -igt_fb_mod_to_tiling (fb->modifier), - compression); + buf =intel_buf_create_using_handle_and_size (bops, handle, + fb->width, fb->height, + fb->plane_bpp[0 ],0 , +igt_fb_mod_to_tiling (fb->modifier), + compression, fb->size);intel_buf_set_name (buf, name);/* Make sure we close handle on destroy path */
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 20/40 tests/api_intel_bb: Remove check-canonical test
In reply to Zbigniew KempczyńskiAs intel-bb uses internally decanonical address for objects/intel_bufs checking canonical bits makes no sense anymore.
--- tests/i915/api_intel_bb.c | 44 --------------------------------------- 1 file changed, 44 deletions(-)
tests/i915/api_intel_bb.c +0 -44
@@ -206,47 +206,6 @@ static void lot_of_buffers(struct buf_ops *bops)intel_buf_destroy (buf[i]); } -/* -* Make sure intel-bb space allocator currently doesn't enter 47-48 bit -* gtt sizes. -*/ -static void check_canonical (struct buf_ops *bops) -{ -int i915 =buf_ops_get_fd (bops); -struct intel_bb *ibb; -struct intel_buf *buf; -uint32_t offset; -uint64_t address; -bool supports_48bit; - - ibb =intel_bb_create (i915,PAGE_SIZE ); - supports_48bit = ibb->supports_48b_address; -if (!supports_48bit) -intel_bb_destroy (ibb); -igt_require_f (supports_48bit,"We need 48bit ppgtt for testing\n" ); - - address =0xc00000000000 ; -if (debug_bb) -intel_bb_set_debug (ibb, true); - - offset =intel_bb_emit_bbe (ibb); - - buf =intel_buf_create (bops,512 ,512 ,32 ,0 , -I915_TILING_NONE ,I915_COMPRESSION_NONE ); - - buf->addr.offset = address; -intel_bb_add_intel_buf (ibb, buf, true); -intel_bb_object_set_flag (ibb, buf->handle,EXEC_OBJECT_PINNED ); - -igt_assert (buf->addr.offset ==0 ); - -intel_bb_exec (ibb, offset, -I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , true); - -intel_buf_destroy (buf); -intel_bb_destroy (ibb); -} -/* * Check flags are cleared after intel_bb_reset(ibb, false); */
@@ -1192,9 +1151,6 @@ igt_main_args("dpib", NULL, help_str, opt_handler, NULL) igt_subtest("lot-of-buffers")lot_of_buffers (bops); - igt_subtest("check-canonical") -check_canonical (bops); - igt_subtest("reset-flags")reset_flags (bops);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 21/40 tests/api_intel_bb: Modify test to verify intel_bb with allocator
In reply to Zbigniew Kempczyńskiintel_bb was adopted to use allocator. Change the test to verify addresses in different scenarios - with relocations and with softpin.
v2: adding intel-buf to intel-bb inserts addresses so they should
be same even if intel-bb cache purge was called
--- tests/i915/api_intel_bb.c | 492 +++++++++++++++++++++++++++++--------- 1 file changed, 377 insertions(+), 115 deletions(-)
tests/i915/api_intel_bb.c +377 -115
@@ -22,6 +22,7 @@*/ #include "igt.h" +#include "i915/gem.h" #include <unistd.h> #include <stdlib.h> #include <stdio.h>
@@ -94,6 +95,7 @@ static void check_buf(struct intel_buf *buf, uint8_t color) ptr =gem_mmap__device_coherent (i915, buf->handle,0 , buf->surface[0 ].size,PROT_READ ); +gem_set_domain (i915, buf->handle,I915_GEM_DOMAIN_WC ,0 );for (i =0 ; i < buf->surface[0 ].size; i++)igt_assert (ptr[i] == color);
@@ -123,24 +125,34 @@ static void print_buf(struct intel_buf *buf, const char *name) ptr =gem_mmap__device_coherent (i915, buf->handle,0 , buf->surface[0 ].size,PROT_READ ); -igt_debug ("[%s] Buf handle: %d, size: %" PRIx64", v: 0x%02x, presumed_addr: %p\n" , +igt_debug ("[%s] Buf handle: %d, size: %" PRIu64 +", v: 0x%02x, presumed_addr: %p\n" , name, buf->handle, buf->surface[0 ].size, ptr[0 ],from_user_pointer (buf->addr.offset));munmap (ptr, buf->surface[0 ].size); } +static void reset_bb (struct buf_ops *bops) +{ +int i915 =buf_ops_get_fd (bops); +struct intel_bb *ibb; + + ibb =intel_bb_create (i915,PAGE_SIZE ); +intel_bb_reset (ibb, false); +intel_bb_destroy (ibb); +} +static void simple_bb (struct buf_ops *bops,bool use_context) {int i915 =buf_ops_get_fd (bops);struct intel_bb *ibb; -uint32_t ctx; +uint32_t ctx =0 ; -if (use_context) { +if (use_context)gem_require_contexts (i915); - ctx =gem_context_create (i915); - } - ibb =intel_bb_create (i915,PAGE_SIZE ); + ibb =intel_bb_create_with_allocator (i915, ctx,PAGE_SIZE , +INTEL_ALLOCATOR_SIMPLE );if (debug_bb)intel_bb_set_debug (ibb, true);
@@ -155,10 +167,8 @@ static void simple_bb(struct buf_ops *bops, bool use_context)intel_bb_reset (ibb, false);intel_bb_reset (ibb, true); -intel_bb_out (ibb,MI_BATCH_BUFFER_END ); -intel_bb_ptr_align (ibb,8 ); -if (use_context) { + ctx =gem_context_create (i915);intel_bb_destroy (ibb); ibb =intel_bb_create_with_context (i915, ctx,PAGE_SIZE );intel_bb_out (ibb,MI_BATCH_BUFFER_END );
@@ -166,11 +176,10 @@ static void simple_bb(struct buf_ops *bops, bool use_context)intel_bb_exec (ibb,intel_bb_offset (ibb),I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , true); +gem_context_destroy (i915, ctx); }intel_bb_destroy (ibb); -if (use_context) -gem_context_destroy (i915, ctx); }/*
@@ -194,16 +203,20 @@ static void lot_of_buffers(struct buf_ops *bops)for (i =0 ; i <NUM_BUFS ; i++) { buf[i] =intel_buf_create (bops,4096 ,1 ,8 ,0 ,I915_TILING_NONE ,I915_COMPRESSION_NONE ); -intel_bb_add_intel_buf (ibb, buf[i], false); +if (i %2 ) +intel_bb_add_intel_buf (ibb, buf[i], false); +else +intel_bb_add_intel_buf_with_alignment (ibb, buf[i], +0x4000 , false); }intel_bb_exec (ibb,intel_bb_offset (ibb),I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , true); -intel_bb_destroy (ibb); -for (i =0 ; i <NUM_BUFS ; i++)intel_buf_destroy (buf[i]); + +intel_bb_destroy (ibb); }/*
@@ -298,70 +311,287 @@ static void reset_flags(struct buf_ops *bops)intel_bb_destroy (ibb); } +static void add_remove_objects (struct buf_ops *bops) +{ +int i915 =buf_ops_get_fd (bops); +struct intel_bb *ibb; +struct intel_buf *src, *mid, *dst; +uint32_t offset; +const uint32_t width =512 ; +const uint32_t height =512 ; + + ibb =intel_bb_create (i915,PAGE_SIZE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); -#define MI_FLUSH_DW (0x26<<23) -#define BCS_SWCTRL 0x22200 -#define BCS_SRC_Y (1 << 0) -#define BCS_DST_Y (1 << 1) -static void __emit_blit (struct intel_bb *ibb, -struct intel_buf *src,struct intel_buf *dst) + src =intel_buf_create (bops, width, height,32 ,0 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); + mid =intel_buf_create (bops, width, height,32 ,0 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); + dst =intel_buf_create (bops, width, height,32 ,0 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); + +intel_bb_add_intel_buf (ibb, src, false); +intel_bb_add_intel_buf (ibb, mid, true); +intel_bb_remove_intel_buf (ibb, mid); +intel_bb_remove_intel_buf (ibb, mid); +intel_bb_remove_intel_buf (ibb, mid); +intel_bb_add_intel_buf (ibb, dst, true); + + offset =intel_bb_emit_bbe (ibb); +intel_bb_exec (ibb, offset, +I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , true); + +intel_buf_destroy (src); +intel_buf_destroy (mid); +intel_buf_destroy (dst); +intel_bb_destroy (ibb); +} + +static void destroy_bb (struct buf_ops *bops) +{ +int i915 =buf_ops_get_fd (bops); +struct intel_bb *ibb; +struct intel_buf *src, *mid, *dst; +uint32_t offset; +const uint32_t width =512 ; +const uint32_t height =512 ; + + ibb =intel_bb_create (i915,PAGE_SIZE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); + + src =intel_buf_create (bops, width, height,32 ,0 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); + mid =intel_buf_create (bops, width, height,32 ,0 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); + dst =intel_buf_create (bops, width, height,32 ,0 , +I915_TILING_NONE ,I915_COMPRESSION_NONE ); + +intel_bb_add_intel_buf (ibb, src, false); +intel_bb_add_intel_buf (ibb, mid, true); +intel_bb_add_intel_buf (ibb, dst, true); + + offset =intel_bb_emit_bbe (ibb); +intel_bb_exec (ibb, offset, +I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , true); + +/* Check destroy will detach intel_bufs */ +intel_bb_destroy (ibb); +igt_assert (src->addr.offset ==INTEL_BUF_INVALID_ADDRESS ); +igt_assert (src->ibb ==NULL ); +igt_assert (mid->addr.offset ==INTEL_BUF_INVALID_ADDRESS ); +igt_assert (mid->ibb ==NULL ); +igt_assert (dst->addr.offset ==INTEL_BUF_INVALID_ADDRESS ); +igt_assert (dst->ibb ==NULL ); + + ibb =intel_bb_create (i915,PAGE_SIZE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); + +intel_bb_add_intel_buf (ibb, src, false); + offset =intel_bb_emit_bbe (ibb); +intel_bb_exec (ibb, offset, +I915_EXEC_DEFAULT |I915_EXEC_NO_RELOC , true); + +intel_bb_destroy (ibb); +intel_buf_destroy (src); +intel_buf_destroy (mid); +intel_buf_destroy (dst); +} + +static void object_reloc (struct buf_ops *bops,enum obj_cache_ops cache_op) { -uint32_t mask; -bool has_64b_reloc; -uint64_t address; - - has_64b_reloc = ibb->gen >=8 ; - -if ((src->tiling | dst->tiling) >=I915_TILING_Y ) { -intel_bb_out (ibb,MI_LOAD_REGISTER_IMM ); -intel_bb_out (ibb,BCS_SWCTRL ); - - mask = (BCS_SRC_Y |BCS_DST_Y ) <<16 ; -if (src->tiling ==I915_TILING_Y ) - mask |=BCS_SRC_Y ; -if (dst->tiling ==I915_TILING_Y ) - mask |=BCS_DST_Y ; -intel_bb_out (ibb, mask); +int i915 =buf_ops_get_fd (bops); +struct intel_bb *ibb; +uint32_t h1, h2; +uint64_t poff_bb, poff_h1, poff_h2; +uint64_t poff2_bb, poff2_h1, poff2_h2; +uint64_t flags =0 ; +uint64_t shift = cache_op ==PURGE_CACHE ?0x2000 :0x0 ; +bool purge_cache = cache_op ==PURGE_CACHE ? true : false; + + ibb =intel_bb_create_with_relocs (i915,PAGE_SIZE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); + + h1 =gem_create (i915,PAGE_SIZE ); + h2 =gem_create (i915,PAGE_SIZE ); + +/* intel_bb_create adds bb handle so it has 0 for relocs */ + poff_bb =intel_bb_get_object_offset (ibb, ibb->handle); +igt_assert (poff_bb ==0 ); + +/* Before adding to intel_bb it should return INVALID_ADDRESS */ + poff_h1 =intel_bb_get_object_offset (ibb, h1); + poff_h2 =intel_bb_get_object_offset (ibb, h2); +igt_debug ("[1] poff_h1: %lx\n" , (long ) poff_h1); +igt_debug ("[1] poff_h2: %lx\n" , (long ) poff_h2); +igt_assert (poff_h1 ==INTEL_BUF_INVALID_ADDRESS ); +igt_assert (poff_h2 ==INTEL_BUF_INVALID_ADDRESS ); + +intel_bb_add_object (ibb, h1,PAGE_SIZE , poff_h1,0 , true); +intel_bb_add_object (ibb, h2,PAGE_SIZE , poff_h2,0x2000 , true); + +/* +* Objects were added to bb, we expect initial addresses are zeroed +* for relocs. +*/ + poff_h1 =intel_bb_get_object_offset (ibb, h1); + poff_h2 =intel_bb_get_object_offset (ibb, h2); +igt_assert (poff_h1 ==0 ); +igt_assert (poff_h2 ==0 ); + +intel_bb_emit_bbe (ibb); +intel_bb_exec (ibb,intel_bb_offset (ibb), flags, false); + + poff2_bb =intel_bb_get_object_offset (ibb, ibb->handle); + poff2_h1 =intel_bb_get_object_offset (ibb, h1); + poff2_h2 =intel_bb_get_object_offset (ibb, h2); +igt_debug ("[2] poff2_h1: %lx\n" , (long ) poff2_h1); +igt_debug ("[2] poff2_h2: %lx\n" , (long ) poff2_h2); +/* Some addresses won't be 0 */ +igt_assert (poff2_bb | poff2_h1 | poff2_h2); + +intel_bb_reset (ibb, purge_cache); + +if (purge_cache) { +intel_bb_add_object (ibb, h1,PAGE_SIZE , poff2_h1,0 , true); +intel_bb_add_object (ibb, h2,PAGE_SIZE , poff2_h2 + shift,0x2000 , true); } -intel_bb_out (ibb, -XY_SRC_COPY_BLT_CMD | -XY_SRC_COPY_BLT_WRITE_ALPHA | -XY_SRC_COPY_BLT_WRITE_RGB | - (6 +2 * has_64b_reloc)); -intel_bb_out (ibb,3 <<24 |0xcc <<16 | dst->surface[0 ].stride); -intel_bb_out (ibb,0 ); -intel_bb_out (ibb,intel_buf_height (dst) <<16 |intel_buf_width (dst)); + poff_bb =intel_bb_get_object_offset (ibb, ibb->handle); + poff_h1 =intel_bb_get_object_offset (ibb, h1); + poff_h2 =intel_bb_get_object_offset (ibb, h2); +igt_debug ("[3] poff_h1: %lx\n" , (long ) poff_h1); +igt_debug ("[3] poff_h2: %lx\n" , (long ) poff_h2); +igt_debug ("[3] poff2_h1: %lx\n" , (long ) poff2_h1); +igt_debug ("[3] poff2_h2: %lx + shift (%lx)\n" , (long ) poff2_h2, + (long ) shift); +igt_assert (poff_h1 == poff2_h1); +igt_assert (poff_h2 == poff2_h2 + shift); +intel_bb_emit_bbe (ibb); +intel_bb_exec (ibb,intel_bb_offset (ibb), flags, false); - address =intel_bb_get_object_offset (ibb, dst->handle); -intel_bb_emit_reloc_fenced (ibb, dst->handle, -I915_GEM_DOMAIN_RENDER , -I915_GEM_DOMAIN_RENDER , -0 , address); -intel_bb_out (ibb,0 ); -intel_bb_out (ibb, src->surface[0 ].stride); +gem_close (i915, h1); +gem_close (i915, h2); +intel_bb_destroy (ibb); +} - address =intel_bb_get_object_offset (ibb, src->handle); -intel_bb_emit_reloc_fenced (ibb, src->handle, -I915_GEM_DOMAIN_RENDER ,0 , -0 , address); +#define WITHIN_RANGE (offset, start, end) \ + (DECANONICAL(offset) >= start && DECANONICAL(offset) <= end) +static void object_noreloc (struct buf_ops *bops,enum obj_cache_ops cache_op, +uint8_t allocator_type) +{ +int i915 =buf_ops_get_fd (bops); +struct intel_bb *ibb; +uint32_t h1, h2; +uint64_t start, end; +uint64_t poff_bb, poff_h1, poff_h2; +uint64_t poff2_bb, poff2_h1, poff2_h2; +uint64_t flags =0 ; +bool purge_cache = cache_op ==PURGE_CACHE ? true : false; -if ((src->tiling | dst->tiling) >=I915_TILING_Y ) { -igt_assert (ibb->gen >=6 ); -intel_bb_out (ibb,MI_FLUSH_DW |2 ); -intel_bb_out (ibb,0 ); -intel_bb_out (ibb,0 ); -intel_bb_out (ibb,0 ); +igt_require (gem_uses_full_ppgtt (i915)); + + ibb =intel_bb_create_with_allocator (i915,0 ,PAGE_SIZE , allocator_type); +if (debug_bb) +intel_bb_set_debug (ibb, true); + + h1 =gem_create (i915,PAGE_SIZE ); + h2 =gem_create (i915,PAGE_SIZE ); + +intel_allocator_get_address_range (ibb->allocator_handle, + &start, &end); + poff_bb =intel_bb_get_object_offset (ibb, ibb->handle); +igt_debug ("[1] bb presumed offset: 0x%" PRIx64 +", start: %" PRIx64", end: %" PRIx64"\n" , + poff_bb, start, end); +igt_assert (WITHIN_RANGE (poff_bb, start, end)); + +/* Before adding to intel_bb it should return INVALID_ADDRESS */ + poff_h1 =intel_bb_get_object_offset (ibb, h1); + poff_h2 =intel_bb_get_object_offset (ibb, h2); +igt_debug ("[1] h1 presumed offset: 0x%" PRIx64"\n" , poff_h1); +igt_debug ("[1] h2 presumed offset: 0x%" PRIx64"\n" , poff_h2); +igt_assert (poff_h1 ==INTEL_BUF_INVALID_ADDRESS ); +igt_assert (poff_h2 ==INTEL_BUF_INVALID_ADDRESS ); + +intel_bb_add_object (ibb, h1,PAGE_SIZE , poff_h1,0 , true); +intel_bb_add_object (ibb, h2,PAGE_SIZE , poff_h2,0 , true); + + poff_h1 =intel_bb_get_object_offset (ibb, h1); + poff_h2 =intel_bb_get_object_offset (ibb, h2); +igt_debug ("[2] bb presumed offset: 0x%" PRIx64"\n" , poff_bb); +igt_debug ("[2] h1 presumed offset: 0x%" PRIx64"\n" , poff_h1); +igt_debug ("[2] h2 presumed offset: 0x%" PRIx64"\n" , poff_h2); +igt_assert (WITHIN_RANGE (poff_bb, start, end)); +igt_assert (WITHIN_RANGE (poff_h1, start, end)); +igt_assert (WITHIN_RANGE (poff_h2, start, end)); + +intel_bb_emit_bbe (ibb); +igt_debug ("exec flags: %" PRIX64 "\n" , flags); +intel_bb_exec (ibb,intel_bb_offset (ibb), flags, false); + + poff2_bb =intel_bb_get_object_offset (ibb, ibb->handle); + poff2_h1 =intel_bb_get_object_offset (ibb, h1); + poff2_h2 =intel_bb_get_object_offset (ibb, h2); +igt_debug ("[3] bb presumed offset: 0x%" PRIx64"\n" , poff2_bb); +igt_debug ("[3] h1 presumed offset: 0x%" PRIx64"\n" , poff2_h1); +igt_debug ("[3] h2 presumed offset: 0x%" PRIx64"\n" , poff2_h2); +igt_assert (poff_h1 == poff2_h1); +igt_assert (poff_h2 == poff2_h2); + +igt_debug ("purge: %d\n" , purge_cache); +intel_bb_reset (ibb, purge_cache); -intel_bb_out (ibb,MI_LOAD_REGISTER_IMM ); -intel_bb_out (ibb,BCS_SWCTRL ); -intel_bb_out (ibb, (BCS_SRC_Y |BCS_DST_Y ) <<16 ); +/* +* Check if intel-bb cache was purged: +* a) retrieve same address from allocator (works for simple, not random) +* b) passing previous address enters allocator <-> intel_bb cache +* consistency check path. +*/ +if (purge_cache) { +intel_bb_add_object (ibb, h1,PAGE_SIZE , +INTEL_BUF_INVALID_ADDRESS ,0 , true); +intel_bb_add_object (ibb, h2,PAGE_SIZE , poff2_h2,0 , true); + }else { +/* See consistency check will not fail */ +intel_bb_add_object (ibb, h1,PAGE_SIZE , poff2_h1,0 , true); +intel_bb_add_object (ibb, h2,PAGE_SIZE , poff2_h2,0 , true); } + + poff_h1 =intel_bb_get_object_offset (ibb, h1); + poff_h2 =intel_bb_get_object_offset (ibb, h2); +igt_debug ("[4] bb presumed offset: 0x%" PRIx64"\n" , poff_bb); +igt_debug ("[4] h1 presumed offset: 0x%" PRIx64"\n" , poff_h1); +igt_debug ("[4] h2 presumed offset: 0x%" PRIx64"\n" , poff_h2); + +/* For simple allocator and purge=cache we must have same addresses */ +if (allocator_type ==INTEL_ALLOCATOR_SIMPLE || !purge_cache) { +igt_assert (poff_h1 == poff2_h1); +igt_assert (poff_h2 == poff2_h2); + } + +gem_close (i915, h1); +gem_close (i915, h2); +intel_bb_destroy (ibb); +} +static void __emit_blit (struct intel_bb *ibb, +struct intel_buf *src,struct intel_buf *dst) +{ +intel_bb_emit_blt_copy (ibb, + src,0 ,0 , src->surface[0 ].stride, + dst,0 ,0 , dst->surface[0 ].stride, +intel_buf_width (dst), +intel_buf_height (dst), + dst->bpp); }static void blit (struct buf_ops *bops,enum reloc_objects reloc_obj, -enum obj_cache_ops cache_op) +enum obj_cache_ops cache_op, +uint8_t allocator_type) {int i915 =buf_ops_get_fd (bops);struct intel_bb *ibb;
@@ -372,49 +602,45 @@ static void blit(struct buf_ops *bops,bool purge_cache = cache_op ==PURGE_CACHE ? true : false;bool do_relocs = reloc_obj ==RELOC ? true : false; - src =create_buf (bops,WIDTH ,HEIGHT ,COLOR_CC ); - dst =create_buf (bops,WIDTH ,HEIGHT ,COLOR_00 ); - -if (buf_info) { -print_buf (src,"src" ); -print_buf (dst,"dst" ); - } +if (!do_relocs) +igt_require (gem_uses_full_ppgtt (i915));if (do_relocs) { ibb =intel_bb_create_with_relocs (i915,PAGE_SIZE ); }else { - ibb =intel_bb_create (i915,PAGE_SIZE ); + ibb =intel_bb_create_with_allocator (i915,0 ,PAGE_SIZE , + allocator_type); flags |=I915_EXEC_NO_RELOC ; } -if (ibb->gen >=6 ) - flags |=I915_EXEC_BLT ; + src =create_buf (bops,WIDTH ,HEIGHT ,COLOR_CC ); + dst =create_buf (bops,WIDTH ,HEIGHT ,COLOR_00 ); + +if (buf_info) { +print_buf (src,"src" ); +print_buf (dst,"dst" ); + }if (debug_bb)intel_bb_set_debug (ibb, true); - -intel_bb_add_intel_buf (ibb, src, false); -intel_bb_add_intel_buf (ibb, dst, true); -__emit_blit (ibb, src, dst);/* We expect initial addresses are zeroed for relocs */ - poff_bb =intel_bb_get_object_offset (ibb, ibb->handle); - poff_src =intel_bb_get_object_offset (ibb, src->handle); - poff_dst =intel_bb_get_object_offset (ibb, dst->handle); -igt_debug ("bb presumed offset: 0x%" PRIx64"\n" , poff_bb); -igt_debug ("src presumed offset: 0x%" PRIx64"\n" , poff_src); -igt_debug ("dst presumed offset: 0x%" PRIx64"\n" , poff_dst);if (reloc_obj ==RELOC ) { + poff_bb =intel_bb_get_object_offset (ibb, ibb->handle); + poff_src =intel_bb_get_object_offset (ibb, src->handle); + poff_dst =intel_bb_get_object_offset (ibb, dst->handle); +igt_debug ("bb presumed offset: 0x%" PRIx64"\n" , poff_bb); +igt_debug ("src presumed offset: 0x%" PRIx64"\n" , poff_src); +igt_debug ("dst presumed offset: 0x%" PRIx64"\n" , poff_dst);igt_assert (poff_bb ==0 );igt_assert (poff_src ==0 );igt_assert (poff_dst ==0 ); }intel_bb_emit_bbe (ibb); -igt_debug ("exec flags: %" PRIX64 "\n" , flags); -intel_bb_exec (ibb,intel_bb_offset (ibb), flags, true); +intel_bb_flush_blit (ibb);check_buf (dst,COLOR_CC ); poff_bb =intel_bb_get_object_offset (ibb, ibb->handle);
@@ -423,15 +649,29 @@ static void blit(struct buf_ops *bops,intel_bb_reset (ibb, purge_cache); +/* For purge we lost offsets and bufs were removed from tracking list */ +if (purge_cache) { + src->addr.offset = poff_src; + dst->addr.offset = poff_dst; + } + +/* Add buffers again, should work both for purge and keep cache */ +intel_bb_add_intel_buf (ibb, src, false); +intel_bb_add_intel_buf (ibb, dst, true); + +igt_assert_f (poff_src == src->addr.offset, +"prev src addr: %" PRIx64" <> src addr %" PRIx64"\n" , + poff_src, src->addr.offset); +igt_assert_f (poff_dst == dst->addr.offset, +"prev dst addr: %" PRIx64" <> dst addr %" PRIx64"\n" , + poff_dst, dst->addr.offset); +fill_buf (src,COLOR_77 );fill_buf (dst,COLOR_00 ); -if (purge_cache && !do_relocs) { -intel_bb_add_intel_buf (ibb, src, false); -intel_bb_add_intel_buf (ibb, dst, true); - } -__emit_blit (ibb, src, dst); +intel_bb_flush_blit (ibb); +check_buf (dst,COLOR_77 ); poff2_bb =intel_bb_get_object_offset (ibb, ibb->handle); poff2_src =intel_bb_get_object_offset (ibb, src->handle);
@@ -455,21 +695,9 @@ static void blit(struct buf_ops *bops,* we are in full control of our own GTT. */ if (gem_uses_full_ppgtt (i915)) { -if (purge_cache) { -if (do_relocs) { -igt_assert_eq_u64 (poff2_bb,0 ); -igt_assert_eq_u64 (poff2_src,0 ); -igt_assert_eq_u64 (poff2_dst,0 ); - }else { -igt_assert_neq_u64 (poff_bb, poff2_bb); -igt_assert_eq_u64 (poff_src, poff2_src); -igt_assert_eq_u64 (poff_dst, poff2_dst); - } - }else { -igt_assert_eq_u64 (poff_bb, poff2_bb); -igt_assert_eq_u64 (poff_src, poff2_src); -igt_assert_eq_u64 (poff_dst, poff2_dst); - } +igt_assert_eq_u64 (poff_bb, poff2_bb); +igt_assert_eq_u64 (poff_src, poff2_src); +igt_assert_eq_u64 (poff_dst, poff2_dst); }intel_bb_emit_bbe (ibb);
@@ -636,7 +864,7 @@ static int dump_base64(const char *name, struct intel_buf *buf)if (ret !=Z_OK ) {igt_warn ("error compressing, ret: %d\n" , ret); }else { -igt_info ("compressed %" PRIx64" -> %lu\n" , +igt_info ("compressed %" PRIu64" -> %lu\n" , buf->surface[0 ].size, outsize);igt_info ("--- %s ---\n" , name);
@@ -1142,6 +1370,10 @@ igt_main_args("dpib", NULL, help_str, opt_handler, NULL) gen =intel_gen (intel_get_drm_devid (i915)); } +igt_describe ("Ensure reset is possible on fresh bb" ); + igt_subtest("reset-bb") +reset_bb (bops); + igt_subtest("simple-bb")simple_bb (bops, false);
@@ -1154,17 +1386,47 @@ igt_main_args("dpib", NULL, help_str, opt_handler, NULL) igt_subtest("reset-flags")reset_flags (bops); - igt_subtest("blit-noreloc-keep-cache") -blit (bops,NORELOC ,KEEP_CACHE ); + igt_subtest("add-remove-objects") +add_remove_objects (bops); - igt_subtest("blit-reloc-purge-cache") -blit (bops,RELOC ,PURGE_CACHE ); + igt_subtest("destroy-bb") +destroy_bb (bops); - igt_subtest("blit-noreloc-purge-cache") -blit (bops,NORELOC ,PURGE_CACHE ); + igt_subtest("object-reloc-purge-cache") +object_reloc (bops,PURGE_CACHE ); + + igt_subtest("object-reloc-keep-cache") +object_reloc (bops,KEEP_CACHE ); + + igt_subtest("object-noreloc-purge-cache-simple") +object_noreloc (bops,PURGE_CACHE ,INTEL_ALLOCATOR_SIMPLE ); + + igt_subtest("object-noreloc-keep-cache-simple") +object_noreloc (bops,KEEP_CACHE ,INTEL_ALLOCATOR_SIMPLE ); + + igt_subtest("object-noreloc-purge-cache-random") +object_noreloc (bops,PURGE_CACHE ,INTEL_ALLOCATOR_RANDOM ); + + igt_subtest("object-noreloc-keep-cache-random") +object_noreloc (bops,KEEP_CACHE ,INTEL_ALLOCATOR_RANDOM ); + + igt_subtest("blit-reloc-purge-cache") +blit (bops,RELOC ,PURGE_CACHE ,INTEL_ALLOCATOR_SIMPLE ); igt_subtest("blit-reloc-keep-cache") -blit (bops,RELOC ,KEEP_CACHE ); +blit (bops,RELOC ,KEEP_CACHE ,INTEL_ALLOCATOR_SIMPLE ); + + igt_subtest("blit-noreloc-keep-cache-random") +blit (bops,NORELOC ,KEEP_CACHE ,INTEL_ALLOCATOR_RANDOM ); + + igt_subtest("blit-noreloc-purge-cache-random") +blit (bops,NORELOC ,PURGE_CACHE ,INTEL_ALLOCATOR_RANDOM ); + + igt_subtest("blit-noreloc-keep-cache") +blit (bops,NORELOC ,KEEP_CACHE ,INTEL_ALLOCATOR_SIMPLE ); + + igt_subtest("blit-noreloc-purge-cache") +blit (bops,NORELOC ,PURGE_CACHE ,INTEL_ALLOCATOR_SIMPLE ); igt_subtest("intel-bb-blit-none")do_intel_bb_blit (bops,10 ,I915_TILING_NONE );
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 22/40 tests/api_intel_bb: Add compressed->compressed copy
In reply to Zbigniew KempczyńskiCheck aux pagetables are working when more than one compressed buffers are added.
--- tests/i915/api_intel_bb.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-)
tests/i915/api_intel_bb.c +12 -1
@@ -1260,7 +1260,7 @@ static void render_ccs(struct buf_ops *bops)struct intel_bb *ibb;const int width =1024 ;const int height =1024 ; -struct intel_buf src, dst, final; +struct intel_buf src, dst, dst2, final;int i915 =buf_ops_get_fd (bops);uint32_t fails =0 ;uint32_t compressed =0 ;
@@ -1275,6 +1275,8 @@ static void render_ccs(struct buf_ops *bops) I915_COMPRESSION_NONE);scratch_buf_init (bops, &dst, width, height,I915_TILING_Y ,I915_COMPRESSION_RENDER ); +scratch_buf_init (bops, &dst2, width, height,I915_TILING_Y , +I915_COMPRESSION_RENDER );scratch_buf_init (bops, &final, width, height,I915_TILING_NONE ,I915_COMPRESSION_NONE );
@@ -1294,6 +1296,12 @@ static void render_ccs(struct buf_ops *bops)render_copy (ibb, &dst,0 ,0 , width, height, + &dst2, +0 ,0 ); + +render_copy (ibb, + &dst2, +0 ,0 , width, height, &final,0 ,0 );
@@ -1309,12 +1317,15 @@ static void render_ccs(struct buf_ops *bops)if (write_png) {intel_buf_write_to_png (&src,"render-ccs-src.png" );intel_buf_write_to_png (&dst,"render-ccs-dst.png" ); +intel_buf_write_to_png (&dst2,"render-ccs-dst2.png" );intel_buf_write_aux_to_png (&dst,"render-ccs-dst-aux.png" ); +intel_buf_write_aux_to_png (&dst2,"render-ccs-dst2-aux.png" );intel_buf_write_to_png (&final,"render-ccs-final.png" ); }intel_buf_close (bops, &src);intel_buf_close (bops, &dst); +intel_buf_close (bops, &dst2);intel_buf_close (bops, &final);igt_assert_f (fails ==0 ,"render-ccs fails: %d\n" , fails);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 23/40 tests/api_intel_bb: Add purge-bb test
In reply to Zbigniew KempczyńskiCheck address acquired is same after purging bb. For relocations we expect 0 twice, for allocator release and alloc same address.
--- tests/i915/api_intel_bb.c | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+)
tests/i915/api_intel_bb.c +30 -0
@@ -142,6 +142,33 @@ static void reset_bb(struct buf_ops *bops)intel_bb_destroy (ibb); } +static void purge_bb (struct buf_ops *bops) +{ +int i915 =buf_ops_get_fd (bops); +struct intel_buf *buf; +struct intel_bb *ibb; +uint64_t offset0, offset1; + + buf =intel_buf_create (bops,512 ,512 ,32 ,0 ,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + ibb =intel_bb_create (i915,4096 ); +intel_bb_set_debug (ibb, true); + +intel_bb_add_intel_buf (ibb, buf, false); + offset0 = buf->addr.offset; + +intel_bb_reset (ibb, true); + buf->addr.offset =INTEL_BUF_INVALID_ADDRESS ; + +intel_bb_add_intel_buf (ibb, buf, false); + offset1 = buf->addr.offset; + +igt_assert (offset0 == offset1); + +intel_buf_destroy (buf); +intel_bb_destroy (ibb); +} +static void simple_bb (struct buf_ops *bops,bool use_context) {int i915 =buf_ops_get_fd (bops);
@@ -1385,6 +1412,9 @@ igt_main_args("dpib", NULL, help_str, opt_handler, NULL) igt_subtest("reset-bb")reset_bb (bops); + igt_subtest_f("purge-bb") +purge_bb (bops); + igt_subtest("simple-bb")simple_bb (bops, false);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 24/40 tests/api_intel_bb: Add simple intel-bb which uses allocator
In reply to Zbigniew KempczyńskiA simple test which uses allocator and can be easily copy-paste when intel-bb is used for batchbuffer creation.
--- tests/i915/api_intel_bb.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
tests/i915/api_intel_bb.c +33 -0
@@ -209,6 +209,36 @@ static void simple_bb(struct buf_ops *bops, bool use_context)intel_bb_destroy (ibb); } +static void bb_with_allocator (struct buf_ops *bops) +{ +int i915 =buf_ops_get_fd (bops); +struct intel_bb *ibb; +struct intel_buf *src, *dst; +uint32_t ctx =0 ; + +igt_require (gem_uses_full_ppgtt (i915)); + + ibb =intel_bb_create_with_allocator (i915, ctx,PAGE_SIZE , +INTEL_ALLOCATOR_SIMPLE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); + + src =intel_buf_create (bops,4096 /32 ,32 ,8 ,0 ,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + dst =intel_buf_create (bops,4096 /32 ,32 ,8 ,0 ,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + +intel_bb_add_intel_buf (ibb, src, false); +intel_bb_add_intel_buf (ibb, dst, true); +intel_bb_copy_intel_buf (ibb, dst, src,4096 ); +intel_bb_remove_intel_buf (ibb, src); +intel_bb_remove_intel_buf (ibb, dst); + +intel_buf_destroy (src); +intel_buf_destroy (dst); +intel_bb_destroy (ibb); +} +/* * Make sure we lead to realloc in the intel_bb. */
@@ -1421,6 +1451,9 @@ igt_main_args("dpib", NULL, help_str, opt_handler, NULL) igt_subtest("simple-bb-ctx")simple_bb (bops, true); + igt_subtest("bb-with-allocator") +bb_with_allocator (bops); + igt_subtest("lot-of-buffers")lot_of_buffers (bops);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 25/40 tests/api_intel_bb: Use allocator in delta-check test
In reply to Zbigniew KempczyńskiWe want to use address returned from emit_reloc() but do not call kernel relocation path. Change intel-bb to use allocator to fully control addresses passed in execbuf.
--- tests/i915/api_intel_bb.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
tests/i915/api_intel_bb.c +2 -1
@@ -1126,7 +1126,8 @@ static void delta_check(struct buf_ops *bops)uint64_t offset;bool supports_48bit; - ibb =intel_bb_create (i915,PAGE_SIZE ); + ibb =intel_bb_create_with_allocator (i915,0 ,PAGE_SIZE , +INTEL_ALLOCATOR_SIMPLE ); supports_48bit = ibb->supports_48b_address;if (!supports_48bit)intel_bb_destroy (ibb);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 26/40 tests/api_intel_bb: Check switching vm in intel-bb
In reply to Zbigniew KempczyńskiFor more vm-controlled scenarios we have to support changing vm in the intel-bb. Test verifies allocator is able to provide two vm's which can be assigned to used within intel-bb context.
--- tests/i915/api_intel_bb.c | 105 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 105 insertions(+)
tests/i915/api_intel_bb.c +105 -0
@@ -36,6 +36,7 @@#include <glib.h> #include <zlib.h> #include "intel_bufops.h" +#include "i915/gem_vm.h" #define PAGE_SIZE 4096
@@ -239,6 +240,107 @@ static void bb_with_allocator(struct buf_ops *bops)intel_bb_destroy (ibb); } +static void bb_with_vm (struct buf_ops *bops) +{ +int i915 =buf_ops_get_fd (bops); +struct drm_i915_gem_context_param arg = { + .param =I915_CONTEXT_PARAM_VM , + }; +struct intel_bb *ibb; +struct intel_buf *src, *dst, *gap; +uint32_t ctx =0 , vm_id1, vm_id2; +uint64_t prev_vm, vm; +uint64_t src_addr[5 ], dst_addr[5 ]; + +igt_require (gem_uses_full_ppgtt (i915)); + + ibb =intel_bb_create_with_allocator (i915, ctx,PAGE_SIZE , +INTEL_ALLOCATOR_SIMPLE ); +if (debug_bb) +intel_bb_set_debug (ibb, true); + + src =intel_buf_create (bops,4096 /32 ,32 ,8 ,0 ,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + dst =intel_buf_create (bops,4096 /32 ,32 ,8 ,0 ,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + gap =intel_buf_create (bops,4096 ,128 ,8 ,0 ,I915_TILING_NONE , +I915_COMPRESSION_NONE ); + +/* vm for second blit */ + vm_id1 =gem_vm_create (i915); + +/* Get vm_id for default vm */ + arg.ctx_id = ctx; +gem_context_get_param (i915, &arg); + vm_id2 = arg.value; + +igt_debug ("Vm_id1: %u\n" , vm_id1); +igt_debug ("Vm_id2: %u\n" , vm_id2); + +/* First blit without set calling setparam */ +intel_bb_copy_intel_buf (ibb, dst, src,4096 ); + src_addr[0 ] = src->addr.offset; + dst_addr[0 ] = dst->addr.offset; +igt_debug ("step1: src: 0x%llx, dst: 0x%llx\n" , + (long long ) src_addr[0 ], (long long ) dst_addr[0 ]); + +/* Open new allocator with vm_id */ + vm =intel_allocator_open_vm (i915, vm_id1,INTEL_ALLOCATOR_SIMPLE ); + prev_vm =intel_bb_assign_vm (ibb, vm, vm_id1); + +intel_bb_add_intel_buf (ibb, gap, false); +intel_bb_copy_intel_buf (ibb, dst, src,4096 ); + src_addr[1 ] = src->addr.offset; + dst_addr[1 ] = dst->addr.offset; +igt_debug ("step2: src: 0x%llx, dst: 0x%llx\n" , + (long long ) src_addr[1 ], (long long ) dst_addr[1 ]); + +/* Back with default vm */ +intel_bb_assign_vm (ibb, prev_vm, vm_id2); +intel_bb_add_intel_buf (ibb, gap, false); +intel_bb_copy_intel_buf (ibb, dst, src,4096 ); + src_addr[2 ] = src->addr.offset; + dst_addr[2 ] = dst->addr.offset; +igt_debug ("step3: src: 0x%llx, dst: 0x%llx\n" , + (long long ) src_addr[2 ], (long long ) dst_addr[2 ]); + +/* And exchange one more time */ +intel_bb_assign_vm (ibb, vm, vm_id1); +intel_bb_copy_intel_buf (ibb, dst, src,4096 ); + src_addr[3 ] = src->addr.offset; + dst_addr[3 ] = dst->addr.offset; +igt_debug ("step4: src: 0x%llx, dst: 0x%llx\n" , + (long long ) src_addr[3 ], (long long ) dst_addr[3 ]); + +/* Back with default vm */ +gem_vm_destroy (i915, vm_id1); +gem_vm_destroy (i915, vm_id2); +intel_bb_assign_vm (ibb, prev_vm,0 ); + +/* We can close it after assign previous vm to ibb */ +intel_allocator_close (vm); + +/* Try default vm still works */ +intel_bb_copy_intel_buf (ibb, dst, src,4096 ); + src_addr[4 ] = src->addr.offset; + dst_addr[4 ] = dst->addr.offset; +igt_debug ("step5: src: 0x%llx, dst: 0x%llx\n" , + (long long ) src_addr[4 ], (long long ) dst_addr[4 ]); + +/* Addresses should match for vm and prev_vm blits */ +igt_assert_eq (src_addr[0 ], src_addr[2 ]); +igt_assert_eq (dst_addr[0 ], dst_addr[2 ]); +igt_assert_eq (src_addr[1 ], src_addr[3 ]); +igt_assert_eq (dst_addr[1 ], dst_addr[3 ]); +igt_assert_eq (src_addr[2 ], src_addr[4 ]); +igt_assert_eq (dst_addr[2 ], dst_addr[4 ]); + +intel_buf_destroy (src); +intel_buf_destroy (dst); +intel_buf_destroy (gap); +intel_bb_destroy (ibb); +} +/* * Make sure we lead to realloc in the intel_bb. */
@@ -1455,6 +1557,9 @@ igt_main_args("dpib", NULL, help_str, opt_handler, NULL) igt_subtest("bb-with-allocator")bb_with_allocator (bops); + igt_subtest("bb-with-vm") +bb_with_vm (bops); + igt_subtest("lot-of-buffers")lot_of_buffers (bops);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 27/40 tests/api_intel_allocator: Simple allocator test suite
In reply to Zbigniew KempczyńskiFrom: Dominik Grzegorzek <[email protected]>
We want to verify allocator works as expected. Try to exploit it.
--- tests/i915/api_intel_allocator.c | 573 +++++++++++++++++++++++++++++++ tests/meson.build | 1 + 2 files changed, 574 insertions(+) create mode 100644 tests/i915/api_intel_allocator.c
tests/i915/api_intel_allocator.c new file +573 -0
@@ -0,0 +1,573 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2021 Intel Corporation +*/ + +#include <stdatomic.h> +#include "i915/gem.h" +#include "igt.h" +#include "igt_aux.h" +#include "intel_allocator.h" + +#define OBJ_SIZE 1024 + +struct test_obj { +uint32_t handle; +uint64_t offset; +uint64_t size; +}; + +static _Atomic(uint32_t) next_handle; + +static inline uint32_t gem_handle_gen (void ) +{ +return atomic_fetch_add (&next_handle,1 ); +} + +static void alloc_simple (int fd) +{ +uint64_t ahnd; +uint64_t offset0, offset1, size =0x1000 , align =0x1000 , start, end; +bool is_allocated, freed; + + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + + offset0 =intel_allocator_alloc (ahnd,1 , size, align); + offset1 =intel_allocator_alloc (ahnd,1 , size, align); +igt_assert (offset0 == offset1); + + is_allocated =intel_allocator_is_allocated (ahnd,1 , size, offset0); +igt_assert (is_allocated); + + freed =intel_allocator_free (ahnd,1 ); +igt_assert (freed); + + is_allocated =intel_allocator_is_allocated (ahnd,1 , size, offset0); +igt_assert (!is_allocated); + + freed =intel_allocator_free (ahnd,1 ); +igt_assert (!freed); + +intel_allocator_get_address_range (ahnd, &start, &end); + offset0 =intel_allocator_alloc (ahnd,1 , end - start,0 ); + offset1 =__intel_allocator_alloc (ahnd,2 ,4096 ,0 ); +igt_assert (offset1 ==ALLOC_INVALID_ADDRESS ); +intel_allocator_free (ahnd,1 ); + +igt_assert_eq (intel_allocator_close (ahnd), true); +} + +static void reserve_simple (int fd) +{ +uint64_t ahnd, start, size =0x1000 ; +bool reserved, unreserved; + + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); +intel_allocator_get_address_range (ahnd, &start,NULL ); + + reserved =intel_allocator_reserve (ahnd,0 , size, start); +igt_assert (reserved); + + reserved =intel_allocator_is_reserved (ahnd, size, start); +igt_assert (reserved); + + reserved =intel_allocator_reserve (ahnd,0 , size, start); +igt_assert (!reserved); + + unreserved =intel_allocator_unreserve (ahnd,0 , size, start); +igt_assert (unreserved); + + reserved =intel_allocator_is_reserved (ahnd, size, start); +igt_assert (!reserved); + +igt_assert_eq (intel_allocator_close (ahnd), true); +} + +static void reserve (int fd,uint8_t type) +{ +struct test_obj obj; +uint64_t ahnd, offset =0x40000 , size =0x1000 ; + + ahnd =intel_allocator_open (fd,0 , type); + +igt_assert_eq (intel_allocator_reserve (ahnd,0 , size, offset), true); +/* try overlapping won't succeed */ +igt_assert_eq (intel_allocator_reserve (ahnd,0 , size, offset + size/2 ), false); + + obj.handle =gem_handle_gen (); + obj.size =OBJ_SIZE ; + obj.offset =intel_allocator_alloc (ahnd, obj.handle, obj.size,0 ); + +igt_assert_eq (intel_allocator_reserve (ahnd,0 , obj.size, obj.offset), false); +intel_allocator_free (ahnd, obj.handle); +igt_assert_eq (intel_allocator_reserve (ahnd,0 , obj.size, obj.offset), true); + +igt_assert_eq (intel_allocator_unreserve (ahnd,0 , obj.size, obj.offset), true); +igt_assert_eq (intel_allocator_unreserve (ahnd,0 , size, offset), true); +igt_assert_eq (intel_allocator_reserve (ahnd,0 , size, offset + size/2 ), true); +igt_assert_eq (intel_allocator_unreserve (ahnd,0 , size, offset + size/2 ), true); + +igt_assert_eq (intel_allocator_close (ahnd), true); +} + +static bool overlaps (struct test_obj *buf1,struct test_obj *buf2) +{ +uint64_t begin1 = buf1->offset; +uint64_t end1 = buf1->offset + buf1->size; +uint64_t begin2 = buf2->offset; +uint64_t end2 = buf2->offset + buf2->size; + +return (end1 > begin2 && end2 > end1) || (end2 > begin1 && end1 > end2); +} + +static void basic_alloc (int fd,int cnt,uint8_t type) +{ +struct test_obj *obj; +uint64_t ahnd; +int i, j; + + ahnd =intel_allocator_open (fd,0 , type); + obj =malloc (sizeof (struct test_obj ) * cnt); + +for (i =0 ; i < cnt; i++) { +igt_progress ("allocating objects: " , i, cnt); + obj[i].handle =gem_handle_gen (); + obj[i].size =OBJ_SIZE ; + obj[i].offset =intel_allocator_alloc (ahnd, obj[i].handle, + obj[i].size,4096 ); +igt_assert_eq (obj[i].offset %4096 ,0 ); + } + +for (i =0 ; i < cnt; i++) { +igt_progress ("check overlapping: " , i, cnt); + +if (type ==INTEL_ALLOCATOR_RANDOM ) +continue ; + +for (j =0 ; j < cnt; j++) { +if (j == i) +continue ; +igt_assert (!overlaps (&obj[i], &obj[j])); + } + } + +for (i =0 ; i < cnt; i++) { +igt_progress ("freeing objects: " , i, cnt); +intel_allocator_free (ahnd, obj[i].handle); + } + +free (obj); +igt_assert_eq (intel_allocator_close (ahnd), true); +} + +static void reuse (int fd,uint8_t type) +{ +struct test_obj obj[128 ], tmp; +uint64_t ahnd, prev_offset; +int i; + + ahnd =intel_allocator_open (fd,0 , type); + +for (i =0 ; i <128 ; i++) { + obj[i].handle =gem_handle_gen (); + obj[i].size =OBJ_SIZE ; + obj[i].offset =intel_allocator_alloc (ahnd, obj[i].handle, + obj[i].size,0x40 ); + } + +/* check simple reuse */ +for (i =0 ; i <128 ; i++) { + prev_offset = obj[i].offset; + obj[i].offset =intel_allocator_alloc (ahnd, obj[i].handle, + obj[i].size,0 ); +igt_assert (prev_offset == obj[i].offset); + } + i--; + +/* free previously allocated bo */ +intel_allocator_free (ahnd, obj[i].handle); +/* alloc different buffer to fill freed hole */ + tmp.handle =gem_handle_gen (); + tmp.offset =intel_allocator_alloc (ahnd, tmp.handle,OBJ_SIZE ,0 ); +igt_assert (prev_offset == tmp.offset); + + obj[i].offset =intel_allocator_alloc (ahnd, obj[i].handle, + obj[i].size,0 ); +igt_assert (prev_offset != obj[i].offset); +intel_allocator_free (ahnd, tmp.handle); + +for (i =0 ; i <128 ; i++) +intel_allocator_free (ahnd, obj[i].handle); + +igt_assert_eq (intel_allocator_close (ahnd), true); +} + +struct ial_thread_args { +uint64_t ahnd; +pthread_t thread; +uint32_t *handles; +uint64_t *offsets; +uint32_t count; +int threads; +int idx; +}; + +static void *alloc_bo_in_thread (void *arg) +{ +struct ial_thread_args *a = arg; +int i; + +for (i = a->idx; i < a->count; i += a->threads) { + a->handles[i] =gem_handle_gen (); + a->offsets[i] =intel_allocator_alloc (a->ahnd, a->handles[i],OBJ_SIZE , +1UL << ((random () %20 ) +1 )); + } + +return NULL ; +} + +static void *free_bo_in_thread (void *arg) +{ +struct ial_thread_args *a = arg; +int i; + +for (i = (a->idx +1 ) % a->threads; i < a->count; i += a->threads) +intel_allocator_free (a->ahnd, a->handles[i]); + +return NULL ; +} + +#define THREADS 6 + +static void parallel_one (int fd,uint8_t type) +{ +struct ial_thread_args a[THREADS ]; +uint32_t *handles; +uint64_t ahnd, *offsets; +int count, i; + +srandom (0xdeadbeef ); + ahnd =intel_allocator_open (fd,0 , type); + count =1UL <<12 ; + + handles =malloc (sizeof (uint32_t ) * count); + offsets =calloc (1 ,sizeof (uint64_t ) * count); + +for (i =0 ; i <THREADS ; i++) { + a[i].ahnd = ahnd; + a[i].handles = handles; + a[i].offsets = offsets; + a[i].count = count; + a[i].threads =THREADS ; + a[i].idx = i; +pthread_create (&a[i].thread,NULL , alloc_bo_in_thread, &a[i]); + } + +for (i =0 ; i <THREADS ; i++) +pthread_join (a[i].thread,NULL ); + +/* Check if all objects are allocated */ +for (i =0 ; i < count; i++) { +/* Reloc + random allocators don't have state. */ +if (type ==INTEL_ALLOCATOR_RELOC || type ==INTEL_ALLOCATOR_RANDOM ) +break ; + +igt_assert_eq (offsets[i], +intel_allocator_alloc (a->ahnd, handles[i],OBJ_SIZE ,0 )); + } + +for (i =0 ; i <THREADS ; i++) +pthread_create (&a[i].thread,NULL , free_bo_in_thread, &a[i]); + +for (i =0 ; i <THREADS ; i++) +pthread_join (a[i].thread,NULL ); + +free (handles); +free (offsets); + +igt_assert_eq (intel_allocator_close (ahnd), true); +} + +#define SIMPLE_GROUP_ALLOCS 8 +static void __simple_allocs (int fd) +{ +uint32_t handles[SIMPLE_GROUP_ALLOCS ]; +uint64_t ahnd; +uint32_t ctx; +int i; + + ctx =rand () %2 ; + ahnd =intel_allocator_open (fd, ctx,INTEL_ALLOCATOR_SIMPLE ); + +for (i =0 ; i <SIMPLE_GROUP_ALLOCS ; i++) { +uint32_t size; + + size = (rand () %4 +1 ) *0x1000 ; + handles[i] =gem_create (fd, size); +intel_allocator_alloc (ahnd, handles[i], size,0x1000 ); + } + +for (i =0 ; i <SIMPLE_GROUP_ALLOCS ; i++) { +igt_assert_f (intel_allocator_free (ahnd, handles[i]) ==1 , +"Error freeing handle: %u\n" , handles[i]); +gem_close (fd, handles[i]); + } + +intel_allocator_close (ahnd); +} + +static void fork_simple_once (int fd) +{ +intel_allocator_multiprocess_start (); + + igt_fork(child, 1) +__simple_allocs (fd); + +igt_waitchildren (); + +intel_allocator_multiprocess_stop (); +} + +#define SIMPLE_TIMEOUT 5 +static void *__fork_simple_thread (void *data) +{ +int fd = (int ) (long ) data; + +igt_until_timeout (SIMPLE_TIMEOUT ) { +__simple_allocs (fd); + } + +return NULL ; +} + +static void fork_simple_stress (int fd,bool two_level_inception) +{ +pthread_t thread0, thread1; +uint64_t ahnd0, ahnd1; +bool are_empty; + +__intel_allocator_multiprocess_prepare (); + + igt_fork(child, 8) { +if (two_level_inception) { +pthread_create (&thread0,NULL , __fork_simple_thread, + (void *) (long ) fd); +pthread_create (&thread1,NULL , __fork_simple_thread, + (void *) (long ) fd); + } + +igt_until_timeout (SIMPLE_TIMEOUT ) { +__simple_allocs (fd); + } + +if (two_level_inception) { +pthread_join (thread0,NULL ); +pthread_join (thread1,NULL ); + } + } + +pthread_create (&thread0,NULL , __fork_simple_thread, (void *) (long ) fd); +pthread_create (&thread1,NULL , __fork_simple_thread, (void *) (long ) fd); + + ahnd0 =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + ahnd1 =intel_allocator_open (fd,1 ,INTEL_ALLOCATOR_SIMPLE ); + +__intel_allocator_multiprocess_start (); + +igt_waitchildren (); + +pthread_join (thread0,NULL ); +pthread_join (thread1,NULL ); + + are_empty =intel_allocator_close (ahnd0); + are_empty &=intel_allocator_close (ahnd1); + +intel_allocator_multiprocess_stop (); + +igt_assert_f (are_empty,"Allocators were not emptied\n" ); +} + +static void __reopen_allocs (int fd1,int fd2,bool check) +{ +uint64_t ahnd0, ahnd1, ahnd2; + + ahnd0 =intel_allocator_open (fd1,0 ,INTEL_ALLOCATOR_SIMPLE ); + ahnd1 =intel_allocator_open (fd2,0 ,INTEL_ALLOCATOR_SIMPLE ); + ahnd2 =intel_allocator_open (fd2,0 ,INTEL_ALLOCATOR_SIMPLE ); +igt_assert (ahnd0 != ahnd1); +igt_assert (ahnd1 != ahnd2); + +/* in fork mode we can have more references, so skip check */ +if (!check) { +intel_allocator_close (ahnd0); +intel_allocator_close (ahnd1); +intel_allocator_close (ahnd2); + }else { +igt_assert_eq (intel_allocator_close (ahnd0), true); +igt_assert_eq (intel_allocator_close (ahnd1), false); +igt_assert_eq (intel_allocator_close (ahnd2), true); + } +} + +static void reopen (int fd) +{ +int fd2; + +igt_require_gem (fd); + + fd2 =gem_reopen_driver (fd); + +__reopen_allocs (fd, fd2, true); + +close (fd2); +} + +#define REOPEN_TIMEOUT 3 +static void reopen_fork (int fd) +{ +int fd2; + +igt_require_gem (fd); + +intel_allocator_multiprocess_start (); + + fd2 =gem_reopen_driver (fd); + + igt_fork(child, 2) { +igt_until_timeout (REOPEN_TIMEOUT) +__reopen_allocs (fd, fd2, false); + } +igt_until_timeout (REOPEN_TIMEOUT) +__reopen_allocs (fd, fd2, false); + +igt_waitchildren (); + +/* Check references at the end */ +__reopen_allocs (fd, fd2, true); + +close (fd2); + +intel_allocator_multiprocess_stop (); +} + +static void open_vm (int fd) +{ +uint64_t ahnd[4 ], offset[4 ], size =0x1000 ; +int i, n =ARRAY_SIZE (ahnd); + + ahnd[0 ] =intel_allocator_open_vm (fd,1 ,INTEL_ALLOCATOR_SIMPLE ); + ahnd[1 ] =intel_allocator_open_vm (fd,1 ,INTEL_ALLOCATOR_SIMPLE ); + ahnd[2 ] =intel_allocator_open_vm_as (ahnd[1 ],2 ); + ahnd[3 ] =intel_allocator_open (fd,3 ,INTEL_ALLOCATOR_SIMPLE ); + + offset[0 ] =intel_allocator_alloc (ahnd[0 ],1 , size,0 ); + offset[1 ] =intel_allocator_alloc (ahnd[1 ],2 , size,0 ); +igt_assert (offset[0 ] != offset[1 ]); + + offset[2 ] =intel_allocator_alloc (ahnd[2 ],3 , size,0 ); +igt_assert (offset[0 ] != offset[2 ] && offset[1 ] != offset[2 ]); + + offset[3 ] =intel_allocator_alloc (ahnd[3 ],1 , size,0 ); +igt_assert (offset[0 ] == offset[3 ]); + +/* +* As ahnd[0-2] lead to same allocator check can we free all handles +* using selected ahnd. +*/ +intel_allocator_free (ahnd[0 ],1 ); +intel_allocator_free (ahnd[0 ],2 ); +intel_allocator_free (ahnd[0 ],3 ); +intel_allocator_free (ahnd[3 ],1 ); + +for (i =0 ; i < n -1 ; i++) +igt_assert_eq (intel_allocator_close (ahnd[i]), (i == n -2 )); +igt_assert_eq (intel_allocator_close (ahnd[n-1 ]), true); +} + +struct allocators { +const char *name; +uint8_t type; +} als[] = { + {"simple" ,INTEL_ALLOCATOR_SIMPLE }, + {"reloc" ,INTEL_ALLOCATOR_RELOC }, + {"random" ,INTEL_ALLOCATOR_RANDOM }, + {NULL ,0 }, +}; + +igt_main +{ +int fd; +struct allocators *a; + + igt_fixture { + fd =drm_open_driver (DRIVER_INTEL ); +atomic_init (&next_handle,1 ); +srandom (0xdeadbeef ); + } + + igt_subtest_f("alloc-simple") +alloc_simple (fd); + + igt_subtest_f("reserve-simple") +reserve_simple (fd); + + igt_subtest_f("reuse") +reuse (fd,INTEL_ALLOCATOR_SIMPLE ); + + igt_subtest_f("reserve") +reserve (fd,INTEL_ALLOCATOR_SIMPLE ); + +for (a = als; a->name; a++) { + igt_subtest_with_dynamic_f("%s-allocator", a->name) { + igt_dynamic("basic") +basic_alloc (fd,1UL <<8 , a->type); + + igt_dynamic("parallel-one") +parallel_one (fd, a->type); + + igt_dynamic("print") +basic_alloc (fd,1UL <<2 , a->type); + +if (a->type ==INTEL_ALLOCATOR_SIMPLE ) { + igt_dynamic("reuse") +reuse (fd, a->type); + + igt_dynamic("reserve") +reserve (fd, a->type); + } + } + } + + igt_subtest_f("fork-simple-once") +fork_simple_once (fd); + + igt_subtest_f("fork-simple-stress") +fork_simple_stress (fd, false); + + igt_subtest_f("fork-simple-stress-signal") { +igt_fork_signal_helper (); +fork_simple_stress (fd, false); +igt_stop_signal_helper (); + } + + igt_subtest_f("two-level-inception") +fork_simple_stress (fd, true); + + igt_subtest_f("two-level-inception-interruptible") { +igt_fork_signal_helper (); +fork_simple_stress (fd, true); +igt_stop_signal_helper (); + } + + igt_subtest_f("reopen") +reopen (fd); + + igt_subtest_f("reopen-fork") +reopen_fork (fd); + + igt_subtest_f("open-vm") +open_vm (fd); + +igt_fixture +close (fd ); +}
tests/meson.build +1 -0
@@ -111,6 +111,7 @@ test_progs = [ ] i915_progs = [ + 'api_intel_allocator', 'api_intel_bb', 'gen3_mixed_blits', 'gen3_render_linear_blits',
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 28/40 tests/api_intel_allocator: Add execbuf with allocator example
In reply to Zbigniew KempczyńskiSimplified version of non-fork test which can be used as a copy-paste template. Uses blit to show how to prepare batch with addresses acquired from allocator.
--- tests/i915/api_intel_allocator.c | 91 ++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+)
tests/i915/api_intel_allocator.c +91 -0
@@ -484,6 +484,94 @@ static void open_vm(int fd)igt_assert_eq (intel_allocator_close (ahnd[n-1 ]), true); } +/* Simple execbuf which uses allocator, non-fork mode */ +static void execbuf_with_allocator (int fd) +{ +struct drm_i915_gem_execbuffer2 execbuf; +struct drm_i915_gem_exec_object2 object[3 ]; +uint64_t ahnd, sz =4096 , gtt_size; +unsigned int flags =EXEC_OBJECT_PINNED ; +uint32_t *ptr, batch[32 ], copied; +int gen =intel_gen (intel_get_drm_devid (fd)); +int i; +const uint32_t magic =0x900df00d ; + +igt_require (gem_uses_full_ppgtt (fd)); + + gtt_size =gem_aperture_size (fd); +if ((gtt_size -1 ) >>32 ) + flags |=EXEC_OBJECT_SUPPORTS_48B_ADDRESS ; + + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + +memset (object,0 ,sizeof (object)); + +/* i == 0 (src), i == 1 (dst), i == 2 (batch) */ +for (i =0 ; i <ARRAY_SIZE (object); i++) { +uint64_t offset; + + object[i].handle =gem_create (fd, sz); + offset =intel_allocator_alloc (ahnd, object[i].handle, sz,0 ); + object[i].offset =CANONICAL (offset); + + object[i].flags = flags; +if (i ==1 ) + object[i].flags |=EXEC_OBJECT_WRITE ; + } + +/* Prepare src data */ + ptr =gem_mmap__device_coherent (fd, object[0 ].handle,0 , sz,PROT_WRITE ); + ptr[0 ] = magic; +gem_munmap (ptr, sz); + +/* Blit src -> dst */ + i =0 ; + batch[i++] =XY_SRC_COPY_BLT_CMD | +XY_SRC_COPY_BLT_WRITE_ALPHA | +XY_SRC_COPY_BLT_WRITE_RGB ; +if (gen >=8 ) + batch[i -1 ] |=8 ; +else + batch[i -1 ] |=6 ; + + batch[i++] = (3 <<24 ) | (0xcc <<16 ) |4 ; + batch[i++] =0 ; + batch[i++] = (1 <<16 ) |4 ; + batch[i++] = object[1 ].offset; +if (gen >=8 ) + batch[i++] = object[1 ].offset >>32 ; + batch[i++] =0 ; + batch[i++] =4 ; + batch[i++] = object[0 ].offset; +if (gen >=8 ) + batch[i++] = object[0 ].offset >>32 ; + batch[i++] =MI_BATCH_BUFFER_END ; + batch[i++] =MI_NOOP ; + +gem_write (fd, object[2 ].handle,0 , batch, i *sizeof (batch[0 ])); + +memset (&execbuf,0 ,sizeof (execbuf)); + execbuf.buffers_ptr =to_user_pointer (object); + execbuf.buffer_count =3 ; +if (gen >=6 ) + execbuf.flags =I915_EXEC_BLT ; +gem_execbuf (fd, &execbuf); +gem_sync (fd, object[1 ].handle); + +/* Check dst data */ + ptr =gem_mmap__device_coherent (fd, object[1 ].handle,0 , sz,PROT_READ ); + copied = ptr[0 ]; +gem_munmap (ptr, sz); + +for (i =0 ; i <ARRAY_SIZE (object); i++) { +igt_assert (intel_allocator_free (ahnd, object[i].handle)); +gem_close (fd, object[i].handle); + } + +igt_assert (copied == magic); +igt_assert (intel_allocator_close (ahnd) == true); +} +struct allocators {const char *name;uint8_t type;
@@ -568,6 +656,9 @@ igt_main igt_subtest_f("open-vm")open_vm (fd); + igt_subtest_f("execbuf-with-allocator") +execbuf_with_allocator (fd); +igt_fixture close (fd ); }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 29/40 tests/api_intel_allocator: Verify child can use its standalone allocator
In reply to Zbigniew KempczyńskiSometimes we don't want to use common allocator provided by main IGT process. Verify it is able to "detach" from it and initialize its own version of allocator.
--- tests/i915/api_intel_allocator.c | 42 ++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+)
tests/i915/api_intel_allocator.c +42 -0
@@ -288,6 +288,45 @@ static void parallel_one(int fd, uint8_t type)igt_assert_eq (intel_allocator_close (ahnd), true); } +static void standalone (int fd) +{ +uint64_t ahnd, offset, size =4096 ; +uint32_t handle =1 , child_handle =2 ; +uint64_t *shared; + + shared =mmap (0 ,4096 ,PROT_WRITE ,MAP_SHARED |MAP_ANON ,-1 ,0 ); + +intel_allocator_multiprocess_start (); + + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + offset =intel_allocator_alloc (ahnd, handle, size,0 ); + + igt_fork(child, 2) { +/* +* Use standalone allocator for child 1, detach from parent, +* child 2 use allocator from parent. +*/ +if (child ==1 ) +intel_allocator_init (); + + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + shared[child] =intel_allocator_alloc (ahnd, child_handle, size,0 ); + +intel_allocator_free (ahnd, child_handle); +intel_allocator_close (ahnd); + } +igt_waitchildren (); +igt_assert_eq (offset, shared[1 ]); +igt_assert_neq (offset, shared[2 ]); + +intel_allocator_free (ahnd, handle); +igt_assert_eq (intel_allocator_close (ahnd), true); + +intel_allocator_multiprocess_stop (); + +munmap (shared,4096 ); +} +#define SIMPLE_GROUP_ALLOCS 8static void __simple_allocs (int fd) {
@@ -626,6 +665,9 @@ igt_main } } + igt_subtest_f("standalone") +standalone (fd); + igt_subtest_f("fork-simple-once")fork_simple_once (fd);
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 30/40 tests/gem_softpin: Verify allocator and execbuf pair work together
In reply to Zbigniew KempczyńskiExercise objects offsets produced by the allocator for execbuf are valid and no EINVAL/ENOSPC occurs. Check it works properly also for multiprocess allocations/execbufs for same context. As we're in full-ppgtt we disable softpin to verify offsets produced by the allocator are valid and kernel doesn't want to relocate them.
Add allocator-basic and allocator-basic-reserve to BAT.
--- tests/i915/gem_softpin.c | 194 ++++++++++++++++++++++++++ tests/intel-ci/fast-feedback.testlist | 2 + 2 files changed, 196 insertions(+)
tests/i915/gem_softpin.c +194 -0
@@ -28,6 +28,7 @@#include "i915/gem.h" #include "igt.h" +#include "intel_allocator.h" #define EXEC_OBJECT_PINNED (1<<4)#define EXEC_OBJECT_SUPPORTS_48B_ADDRESS (1<<3)
@@ -697,6 +698,184 @@ static void test_noreloc(int fd, enum sleep sleep, unsigned flags)gem_close (fd, object[i].handle); } +static void __reserve (uint64_t ahnd,int i915,bool pinned, +struct drm_i915_gem_exec_object2 *objects, +int num_obj,uint64_t size) +{ +uint64_t gtt =gem_aperture_size (i915); +unsigned int flags; +int i; + +igt_assert (num_obj >1 ); + + flags =EXEC_OBJECT_SUPPORTS_48B_ADDRESS ; +if (pinned) + flags |=EXEC_OBJECT_PINNED ; + +memset (objects,0 ,sizeof (objects) * num_obj); + +for (i =0 ; i < num_obj; i++) { + objects[i].handle =gem_create (i915, size); +if (i < num_obj/2 ) + objects[i].offset = i * size; +else + objects[i].offset = gtt - (i +1 - num_obj/2 ) * size; + objects[i].flags = flags; + +intel_allocator_reserve (ahnd, objects[i].handle, + size, objects[i].offset); +igt_debug ("Reserve i: %d, handle: %u, offset: %llx\n" , i, + objects[i].handle, (long long ) objects[i].offset); + } +} + +static void __unreserve (uint64_t ahnd,int i915, +struct drm_i915_gem_exec_object2 *objects, +int num_obj,uint64_t size) +{ +int i; + +for (i =0 ; i < num_obj; i++) { +intel_allocator_unreserve (ahnd, objects[i].handle, + size, objects[i].offset); +igt_debug ("Unreserve i: %d, handle: %u, offset: %llx\n" , i, + objects[i].handle, (long long ) objects[i].offset); +gem_close (i915, objects[i].handle); + } +} + +static void __exec_using_allocator (uint64_t ahnd,int i915,int num_obj, +bool pinned) +{ +const uint32_t bbe =MI_BATCH_BUFFER_END ; +struct drm_i915_gem_execbuffer2 execbuf; +struct drm_i915_gem_exec_object2 object[num_obj]; +uint64_t stored_offsets[num_obj]; +unsigned int flags; +uint64_t sz =4096 ; +int i; + +igt_assert (num_obj >10 ); + + flags =EXEC_OBJECT_SUPPORTS_48B_ADDRESS ; +if (pinned) + flags |=EXEC_OBJECT_PINNED ; + +memset (object,0 ,sizeof (object)); + +for (i =0 ; i < num_obj; i++) { + sz = (rand () %15 +1 ) *4096 ; +if (i == num_obj -1 ) + sz =4096 ; + object[i].handle =gem_create (i915, sz); + object[i].offset = +intel_allocator_alloc (ahnd, object[i].handle, sz,0 ); + } +gem_write (i915, object[--i].handle,0 , &bbe,sizeof (bbe)); + +for (i =0 ; i < num_obj; i++) { + object[i].flags = flags; + object[i].offset =gen8_canonical_addr (object[i].offset); + stored_offsets[i] = object[i].offset; + } + +memset (&execbuf,0 ,sizeof (execbuf)); + execbuf.buffers_ptr =to_user_pointer (object); + execbuf.buffer_count = num_obj; +gem_execbuf (i915, &execbuf); + +for (i =0 ; i < num_obj; i++) { +igt_assert (intel_allocator_free (ahnd, object[i].handle)); +gem_close (i915, object[i].handle); + } + +/* Check kernel will keep offsets even if pinned is not set. */ +for (i =0 ; i < num_obj; i++) +igt_assert_eq_u64 (stored_offsets[i], object[i].offset); +} + +static void test_allocator_basic (int fd,bool reserve) +{ +const int num_obj =257 , num_reserved =8 ; +struct drm_i915_gem_exec_object2 objects[num_reserved]; +uint64_t ahnd, ressize =4096 ; + +/* +* Check that we can place objects at start/end +* of the GTT using the allocator. +*/ + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + +if (reserve) +__reserve (ahnd, fd, true, objects, num_reserved, ressize); +__exec_using_allocator (ahnd, fd, num_obj, true); +if (reserve) +__unreserve (ahnd, fd, objects, num_reserved, ressize); +igt_assert (intel_allocator_close (ahnd) == true); +} + +static void test_allocator_nopin (int fd,bool reserve) +{ +const int num_obj =257 , num_reserved =8 ; +struct drm_i915_gem_exec_object2 objects[num_reserved]; +uint64_t ahnd, ressize =4096 ; + +/* +* Check that we can combine manual placement with automatic +* GTT placement. +* +* This will also check that we agree with this small sampling of +* allocator placements -- that is the given the same restrictions +* in execobj[] the kernel does not reject the placement due +* to overlaps or invalid addresses. +*/ + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + +if (reserve) +__reserve (ahnd, fd, false, objects, num_reserved, ressize); + +__exec_using_allocator (ahnd, fd, num_obj, false); + +if (reserve) +__unreserve (ahnd, fd, objects, num_reserved, ressize); + +igt_assert (intel_allocator_close (ahnd) == true); +} + +static void test_allocator_fork (int fd) +{ +const int num_obj =17 , num_reserved =8 ; +struct drm_i915_gem_exec_object2 objects[num_reserved]; +uint64_t ahnd, ressize =4096 ; + +/* +* Must be called before opening allocator in multiprocess environment +* due to freeing previous allocator infrastructure and proper setup +* of data structures and allocation thread. +*/ +intel_allocator_multiprocess_start (); + + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); +__reserve (ahnd, fd, true, objects, num_reserved, ressize); + + igt_fork(child, 8) { + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); + igt_until_timeout(2) +__exec_using_allocator (ahnd, fd, num_obj, true); +intel_allocator_close (ahnd); + } + +igt_waitchildren (); + +__unreserve (ahnd, fd, objects, num_reserved, ressize); +igt_assert (intel_allocator_close (ahnd) == true); + + ahnd =intel_allocator_open (fd,0 ,INTEL_ALLOCATOR_SIMPLE ); +igt_assert (intel_allocator_close (ahnd) == true); + +intel_allocator_multiprocess_stop (); +} + igt_main {int fd =-1 ;
@@ -727,6 +906,21 @@ igt_main igt_subtest("full")test_full (fd); + + igt_subtest("allocator-basic") +test_allocator_basic (fd, false); + + igt_subtest("allocator-basic-reserve") +test_allocator_basic (fd, true); + + igt_subtest("allocator-nopin") +test_allocator_nopin (fd, false); + + igt_subtest("allocator-nopin-reserve") +test_allocator_nopin (fd, true); + + igt_subtest("allocator-fork") +test_allocator_fork (fd); }igt_subtest ("softpin" )
tests/intel-ci/fast-feedback.testlist +2 -0
@@ -39,6 +39,8 @@ igt@gem_mmap_gtt@basic igt@gem_render_linear_blits@basic igt@gem_render_tiled_blits@basic igt@gem_ringfill@basic-all +igt@gem_softpin@allocator-basic +igt@gem_softpin@allocator-basic-reserve igt@gem_sync@basic-all igt@gem_sync@basic-each igt@gem_tiled_blits@basic
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 31/40 tests/gem|kms: Remove intel_bb from fixture
In reply to Zbigniew KempczyńskiAs intel_bb "opens" connection to allocator when test completes it can leave allocator in unknown state (mostly in failed tests). As igt_core was armed in resetting allocator infrastructure connection to it inside intel_bb is not valid anymore. Trying to use it leads to catastrofic errors.
Migrate intel_bb out of fixture and create it inside tests individually.
--- tests/i915/gem_caching.c | 14 ++++++++-- tests/i915/gem_partial_pwrite_pread.c | 40 +++++++++++++++++---------- tests/i915/gem_render_copy.c | 31 ++++++++++----------- tests/kms_big_fb.c | 12 +++++--- 4 files changed, 61 insertions(+), 36 deletions(-)
tests/i915/gem_caching.c +12 -2
@@ -158,7 +158,6 @@ igt_main flags =0 ; } data.bops =buf_ops_create (data.fd); - ibb =intel_bb_create (data.fd,PAGE_SIZE ); scratch_buf =intel_buf_create (data.bops,BO_SIZE /4 ,1 ,32 ,0 ,I915_TILING_NONE ,0 );
@@ -174,6 +173,8 @@ igt_mainigt_info ("checking partial reads\n" ); + ibb =intel_bb_create (data.fd,PAGE_SIZE ); +for (i =0 ; i <ROUNDS ; i++) {uint8_t val0 = i;int start, len;
@@ -195,11 +196,15 @@ igt_mainigt_progress ("partial reads test: " , i,ROUNDS ); } + +intel_bb_destroy (ibb); } igt_subtest("writes") {igt_require (flags &TEST_WRITE ); + ibb =intel_bb_create (data.fd,PAGE_SIZE ); +igt_info ("checking partial writes\n" );for (i =0 ; i <ROUNDS ; i++) {
@@ -240,11 +245,15 @@ igt_mainigt_progress ("partial writes test: " , i,ROUNDS ); } + +intel_bb_destroy (ibb); } igt_subtest("read-writes") {igt_require ((flags &TEST_BOTH ) ==TEST_BOTH ); + ibb =intel_bb_create (data.fd,PAGE_SIZE ); +igt_info ("checking partial writes after partial reads\n" );for (i =0 ; i <ROUNDS ; i++) {
@@ -307,10 +316,11 @@ igt_mainigt_progress ("partial read/writes test: " , i,ROUNDS ); } + +intel_bb_destroy (ibb); } igt_fixture { -intel_bb_destroy (ibb);intel_buf_destroy (scratch_buf);intel_buf_destroy (staging_buf);buf_ops_destroy (data.bops);
tests/i915/gem_partial_pwrite_pread.c +26 -14
@@ -53,7 +53,6 @@ IGT_TEST_DESCRIPTION("Test pwrite/pread consistency when touching partial"#define PAGE_SIZE 4096#define BO_SIZE (4*4096) -struct intel_bb *ibb;struct intel_buf *scratch_buf;struct intel_buf *staging_buf;
@@ -77,7 +76,8 @@ static void *__try_gtt_map_first(data_t *data, struct intel_buf *buf,return ptr; } -static void copy_bo (struct intel_buf *src,struct intel_buf *dst) +static void copy_bo (struct intel_bb *ibb, +struct intel_buf *src,struct intel_buf *dst) {bool has_64b_reloc;
@@ -109,8 +109,8 @@ static void copy_bo(struct intel_buf *src, struct intel_buf *dst) }static void -blt_bo_fill (data_t *data,struct intel_buf *tmp_bo, -struct intel_buf *bo,uint8_t val) +blt_bo_fill (data_t *data,struct intel_bb *ibb, +struct intel_buf *tmp_bo,struct intel_buf *bo,uint8_t val) {uint8_t *gtt_ptr;int i;
@@ -124,7 +124,7 @@ blt_bo_fill(data_t *data, struct intel_buf *tmp_bo,igt_drop_caches_set (data->drm_fd,DROP_BOUND ); -copy_bo (tmp_bo, bo); +copy_bo (ibb, tmp_bo, bo); }#define MAX_BLT_SIZE 128
@@ -139,14 +139,17 @@ static void get_range(int *start, int *len)static void test_partial_reads (data_t *data) { +struct intel_bb *ibb;int i, j; + ibb =intel_bb_create (data->drm_fd,PAGE_SIZE ); +igt_info ("checking partial reads\n" );for (i =0 ; i <ROUNDS ; i++) {uint8_t val = i;int start, len; -blt_bo_fill (data, staging_buf, scratch_buf, val); +blt_bo_fill (data, ibb, staging_buf, scratch_buf, val);get_range (&start, &len);gem_read (data->drm_fd, scratch_buf->handle, start, tmp, len);
@@ -159,26 +162,31 @@ static void test_partial_reads(data_t *data)igt_progress ("partial reads test: " , i,ROUNDS ); } + +intel_bb_destroy (ibb); }static void test_partial_writes (data_t *data) { +struct intel_bb *ibb;int i, j;uint8_t *gtt_ptr; + ibb =intel_bb_create (data->drm_fd,PAGE_SIZE ); +igt_info ("checking partial writes\n" );for (i =0 ; i <ROUNDS ; i++) {uint8_t val = i;int start, len; -blt_bo_fill (data, staging_buf, scratch_buf, val); +blt_bo_fill (data, ibb, staging_buf, scratch_buf, val);memset (tmp, i +63 ,BO_SIZE );get_range (&start, &len);gem_write (data->drm_fd, scratch_buf->handle, start, tmp, len); -copy_bo (scratch_buf, staging_buf); +copy_bo (ibb, scratch_buf, staging_buf); gtt_ptr =__try_gtt_map_first (data, staging_buf,0 );for (j =0 ; j < start; j++) {
@@ -200,19 +208,24 @@ static void test_partial_writes(data_t *data)igt_progress ("partial writes test: " , i,ROUNDS ); } + +intel_bb_destroy (ibb); }static void test_partial_read_writes (data_t *data) { +struct intel_bb *ibb;int i, j;uint8_t *gtt_ptr; + ibb =intel_bb_create (data->drm_fd,PAGE_SIZE ); +igt_info ("checking partial writes after partial reads\n" );for (i =0 ; i <ROUNDS ; i++) {uint8_t val = i;int start, len; -blt_bo_fill (data, staging_buf, scratch_buf, val); +blt_bo_fill (data, ibb, staging_buf, scratch_buf, val);/* partial read */ get_range (&start, &len);
@@ -226,7 +239,7 @@ static void test_partial_read_writes(data_t *data)/* Change contents through gtt to make the pread cachelines * stale. */ val +=17 ; -blt_bo_fill (data, staging_buf, scratch_buf, val); +blt_bo_fill (data, ibb, staging_buf, scratch_buf, val);/* partial write */ memset (tmp, i +63 ,BO_SIZE );
@@ -234,7 +247,7 @@ static void test_partial_read_writes(data_t *data)get_range (&start, &len);gem_write (data->drm_fd, scratch_buf->handle, start, tmp, len); -copy_bo (scratch_buf, staging_buf); +copy_bo (ibb, scratch_buf, staging_buf); gtt_ptr =__try_gtt_map_first (data, staging_buf,0 );for (j =0 ; j < start; j++) {
@@ -256,6 +269,8 @@ static void test_partial_read_writes(data_t *data)igt_progress ("partial read/writes test: " , i,ROUNDS ); } + +intel_bb_destroy (ibb); }static void do_tests (data_t *data,int cache_level,const char *suffix)
@@ -289,8 +304,6 @@ igt_main data.devid =intel_get_drm_devid (data.drm_fd); data.bops =buf_ops_create (data.drm_fd); - ibb =intel_bb_create (data.drm_fd,PAGE_SIZE ); -/* overallocate the buffers we're actually using because */ scratch_buf =intel_buf_create (data.bops,BO_SIZE /4 ,1 ,32 ,0 ,I915_TILING_NONE ,0 ); staging_buf =intel_buf_create (data.bops,BO_SIZE /4 ,1 ,32 ,0 ,I915_TILING_NONE ,0 );
@@ -304,7 +317,6 @@ igt_maindo_tests (&data,2 ,"-display" ); igt_fixture { -intel_bb_destroy (ibb);intel_buf_destroy (scratch_buf);intel_buf_destroy (staging_buf);buf_ops_destroy (data.bops);
tests/i915/gem_render_copy.c +15 -16
@@ -58,7 +58,6 @@ typedef struct {int drm_fd;uint32_t devid;struct buf_ops *bops; -struct intel_bb *ibb;igt_render_copyfunc_t render_copy;igt_vebox_copyfunc_t vebox_copy; } data_t;
@@ -341,6 +340,7 @@ static void test(data_t *data, uint32_t src_tiling, uint32_t dst_tiling, enum i915_compression dst_compression, int flags) { +struct intel_bb *ibb;struct intel_buf ref, src_tiled, src_ccs, dst_ccs, dst;struct {struct intel_buf buf;
@@ -397,6 +397,8 @@ static void test(data_t *data, uint32_t src_tiling, uint32_t dst_tiling, src_compressed || dst_compressed)igt_require (intel_gen (data->devid) >=9 ); + ibb =intel_bb_create (data->drm_fd,4096 ); +for (int i =0 ; i < num_src; i++)scratch_buf_init (data, &src[i].buf,WIDTH ,HEIGHT , src[i].tiling,I915_COMPRESSION_NONE );
@@ -456,12 +458,12 @@ static void test(data_t *data, uint32_t src_tiling, uint32_t dst_tiling,*/ if (src_mixed_tiled) {if (dst_compressed) - data->render_copy (data->ibb, + data->render_copy (ibb, &dst,0 ,0 ,WIDTH ,HEIGHT , &dst_ccs,0 ,0 );for (int i =0 ; i < num_src; i++) { - data->render_copy(data->ibb, + data->render_copy(ibb, &src[i].buf, WIDTH/4, HEIGHT/4, WIDTH/2-2, HEIGHT/2-2, dst_compressed ? &dst_ccs : &dst,
@@ -469,13 +471,13 @@ static void test(data_t *data, uint32_t src_tiling, uint32_t dst_tiling, }if (dst_compressed) - data->render_copy (data->ibb, + data->render_copy (ibb, &dst_ccs,0 ,0 ,WIDTH ,HEIGHT , &dst,0 ,0 ); }else {if (src_compression ==I915_COMPRESSION_RENDER ) { - data->render_copy (data->ibb, + data->render_copy (ibb, &src_tiled,0 ,0 ,WIDTH ,HEIGHT , &src_ccs,0 ,0 );
@@ -486,7 +488,7 @@ static void test(data_t *data, uint32_t src_tiling, uint32_t dst_tiling, "render-src_ccs.bin"); } }else if (src_compression ==I915_COMPRESSION_MEDIA ) { - data->vebox_copy (data->ibb, + data->vebox_copy (ibb, &src_tiled,WIDTH ,HEIGHT , &src_ccs);if (dump_compressed_src_buf) {
@@ -498,34 +500,34 @@ static void test(data_t *data, uint32_t src_tiling, uint32_t dst_tiling, }if (dst_compression ==I915_COMPRESSION_RENDER ) { - data->render_copy (data->ibb, + data->render_copy (ibb, src_compressed ? &src_ccs : &src_tiled,0 ,0 ,WIDTH ,HEIGHT , &dst_ccs,0 ,0 ); - data->render_copy (data->ibb, + data->render_copy (ibb, &dst_ccs,0 ,0 ,WIDTH ,HEIGHT , &dst,0 ,0 ); }else if (dst_compression ==I915_COMPRESSION_MEDIA ) { - data->vebox_copy (data->ibb, + data->vebox_copy (ibb, src_compressed ? &src_ccs : &src_tiled,WIDTH ,HEIGHT , &dst_ccs); - data->vebox_copy (data->ibb, + data->vebox_copy (ibb, &dst_ccs,WIDTH ,HEIGHT , &dst); }else if (force_vebox_dst_copy) { - data->vebox_copy (data->ibb, + data->vebox_copy (ibb, src_compressed ? &src_ccs : &src_tiled,WIDTH ,HEIGHT , &dst); }else { - data->render_copy(data->ibb, + data->render_copy(ibb, src_compressed ? &src_ccs : &src_tiled, 0, 0, WIDTH, HEIGHT, &dst,
@@ -572,8 +574,7 @@ static void test(data_t *data, uint32_t src_tiling, uint32_t dst_tiling,for (int i =0 ; i < num_src; i++)scratch_buf_fini (&src[i].buf); -/* handles gone, need to clean the objects cache within intel_bb */ -intel_bb_reset (data->ibb, true); +intel_bb_destroy (ibb); }static int opt_handler (int opt,int opt_index,void *data)
@@ -796,7 +797,6 @@ igt_main_args("dac", NULL, help_str, opt_handler, NULL) data.vebox_copy =igt_get_vebox_copyfunc (data.devid); data.bops =buf_ops_create (data.drm_fd); - data.ibb =intel_bb_create (data.drm_fd,4096 );igt_fork_hang_detector (data.drm_fd); }
@@ -849,7 +849,6 @@ igt_main_args("dac", NULL, help_str, opt_handler, NULL) igt_fixture {igt_stop_hang_detector (); -intel_bb_destroy (data.ibb);buf_ops_destroy (data.bops); } }
tests/kms_big_fb.c +8 -4
@@ -664,7 +664,6 @@ igt_main data.render_copy =igt_get_render_copyfunc (data.devid); data.bops =buf_ops_create (data.drm_fd); - data.ibb =intel_bb_create (data.drm_fd,4096 ); }/*
@@ -677,7 +676,9 @@ igt_mainigt_subtest_f ("%s-addfb-size-overflow" , modifiers[i].name) { data.modifier = modifiers[i].modifier; + data.ibb =intel_bb_create (data.drm_fd,4096 );test_size_overflow (&data); +intel_bb_destroy (data.ibb); } }
@@ -685,15 +686,18 @@ igt_mainigt_subtest_f ("%s-addfb-size-offset-overflow" , modifiers[i].name) { data.modifier = modifiers[i].modifier; + data.ibb =intel_bb_create (data.drm_fd,4096 );test_size_offset_overflow (&data); +intel_bb_destroy (data.ibb); } }for (int i =0 ; i <ARRAY_SIZE (modifiers); i++) { igt_subtest_f("%s-addfb", modifiers[i].name) { data.modifier = modifiers[i].modifier; - + data.ibb =intel_bb_create (data.drm_fd,4096 );test_addfb (&data); +intel_bb_destroy (data.ibb); } }
@@ -711,7 +715,9 @@ igt_mainigt_require (data.format ==DRM_FORMAT_C8 ||igt_fb_supported_format (data.format));igt_require (igt_display_has_format_mod (&data.display, data.format, data.modifier)); + data.ibb =intel_bb_create (data.drm_fd,4096 );test_scanout (&data); +intel_bb_destroy (data.ibb); } }
@@ -722,8 +728,6 @@ igt_main igt_fixture {igt_display_fini (&data.display); - -intel_bb_destroy (data.ibb);buf_ops_destroy (data.bops); } }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 32/40 tests/gem_mmap_offset: Use intel_buf wrapper code instead direct
In reply to Zbigniew KempczyńskiGenerally when playing with intel_buf we should use wrapper code instead of adding it to intel_bb directly. Code checks required alignment on specific gens so protects us from passing unaligned properly addresses.
--- tests/i915/gem_mmap_offset.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
tests/i915/gem_mmap_offset.c +2 -2
@@ -614,8 +614,8 @@ static void blt_coherency(int i915) dst =create_bo (bops,1 , width, height); size = src->surface[0 ].size; -intel_bb_add_object (ibb, src->handle, size, src->addr.offset,0 , false); -intel_bb_add_object (ibb, dst->handle, size, dst->addr.offset,0 , true); +intel_bb_add_intel_buf (ibb, src, false); +intel_bb_add_intel_buf (ibb, dst, true); intel_bb_blt_copy(ibb, src, 0, 0, src->surface[0].stride,
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 33/40 tests/gem_ppgtt: Adopt test to use intel_bb with allocator
In reply to Zbigniew KempczyńskiInitialize allocator within child processes to avoid creation allocator thread and unnecessary communication to it.
--- tests/i915/gem_ppgtt.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
tests/i915/gem_ppgtt.c +6 -1
@@ -104,12 +104,14 @@ static void fork_rcs_copy(int timeout, uint32_t final,struct intel_buf *src;unsigned long i; +/* Standalone allocator */ +intel_allocator_init (); +if (flags &CREATE_CONTEXT ) ctx =gem_context_create (buf_ops_get_fd (dst[child]->bops)); ibb =intel_bb_create_with_context (buf_ops_get_fd (dst[child]->bops), ctx,4096 ); - i =0 ;igt_until_timeout (timeout) { src = create_bo(dst[child]->bops,
@@ -151,6 +153,9 @@ static void fork_bcs_copy(int timeout, uint32_t final,struct intel_bb *ibb;unsigned long i; +/* Standalone allocator */ +intel_allocator_init (); + ibb =intel_bb_create (buf_ops_get_fd (dst[child]->bops),4096 ); i =0 ;
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 34/40 tests/gem_render_copy_redux: Adopt to use with intel_bb and allocator
In reply to Zbigniew KempczyńskiAs intel_bb has some strong requirements when allocator is in use (addresses cannot move when simple allocator is used) ensure gem buffer which is created from flink will reacquire new address.
--- tests/i915/gem_render_copy_redux.c | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-)
tests/i915/gem_render_copy_redux.c +15 -9
@@ -63,7 +63,6 @@ typedef struct {int fd;uint32_t devid;struct buf_ops *bops; -struct intel_bb *ibb;igt_render_copyfunc_t render_copy;uint32_t linear[WIDTH *HEIGHT ]; } data_t;
@@ -77,13 +76,10 @@ static void data_init(data_t *data) data->render_copy =igt_get_render_copyfunc (data->devid);igt_require_f (data->render_copy,"no render-copy function\n" ); - - data->ibb =intel_bb_create (data->fd,4096 ); }static void data_fini (data_t *data) { -intel_bb_destroy (data->ibb);buf_ops_destroy (data->bops);close (data->fd); }
@@ -126,15 +122,17 @@ scratch_buf_check(data_t *data, struct intel_buf *buf, int x, int y,static void copy (data_t *data) { +struct intel_bb *ibb;struct intel_buf src, dst; + ibb =intel_bb_create (data->fd,4096 );scratch_buf_init (data, &src,WIDTH ,HEIGHT ,STRIDE ,SRC_COLOR );scratch_buf_init (data, &dst,WIDTH ,HEIGHT ,STRIDE ,DST_COLOR );scratch_buf_check (data, &src,WIDTH /2 ,HEIGHT /2 ,SRC_COLOR );scratch_buf_check (data, &dst,WIDTH /2 ,HEIGHT /2 ,DST_COLOR ); - data->render_copy (data->ibb, + data->render_copy (ibb, &src,0 ,0 ,WIDTH ,HEIGHT , &dst,WIDTH /2 ,HEIGHT /2 );
@@ -143,11 +141,13 @@ static void copy(data_t *data)scratch_buf_fini (data, &src);scratch_buf_fini (data, &dst); +intel_bb_destroy (ibb); }static void copy_flink (data_t *data) {data_t local; +struct intel_bb *ibb, *local_ibb;struct intel_buf src, dst;struct intel_buf local_src, local_dst;struct intel_buf flink;
@@ -155,32 +155,36 @@ static void copy_flink(data_t *data)data_init (&local); + ibb =intel_bb_create (data->fd,4096 ); + local_ibb =intel_bb_create (local.fd,4096 );scratch_buf_init (data, &src,WIDTH ,HEIGHT ,STRIDE ,0 );scratch_buf_init (data, &dst,WIDTH ,HEIGHT ,STRIDE ,DST_COLOR ); - data->render_copy (data->ibb, + data->render_copy (ibb, &src,0 ,0 ,WIDTH ,HEIGHT , &dst,WIDTH ,HEIGHT );scratch_buf_init (&local, &local_src,WIDTH ,HEIGHT ,STRIDE ,0 );scratch_buf_init (&local, &local_dst,WIDTH ,HEIGHT ,STRIDE ,SRC_COLOR ); - local.render_copy (local.ibb, + local.render_copy (local_ibb, &local_src,0 ,0 ,WIDTH ,HEIGHT , &local_dst,WIDTH ,HEIGHT ); name =gem_flink (local.fd, local_dst.handle); flink = local_dst; flink.handle =gem_open (data->fd, name); + flink.ibb = ibb; + flink.addr.offset =INTEL_BUF_INVALID_ADDRESS ; - data->render_copy (data->ibb, + data->render_copy (ibb, &flink,0 ,0 ,WIDTH ,HEIGHT , &dst,WIDTH /2 ,HEIGHT /2 );scratch_buf_check (data, &dst,10 ,10 ,DST_COLOR );scratch_buf_check (data, &dst,WIDTH -10 ,HEIGHT -10 ,SRC_COLOR ); -intel_bb_reset (data->ibb, true); +intel_bb_reset (ibb, true);scratch_buf_fini (data, &src);scratch_buf_fini (data, &flink);scratch_buf_fini (data, &dst);
@@ -188,6 +192,8 @@ static void copy_flink(data_t *data)scratch_buf_fini (&local, &local_src);scratch_buf_fini (&local, &local_dst); +intel_bb_destroy (local_ibb); +intel_bb_destroy (ibb);data_fini (&local); }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 35/40 tests/perf.c: Remove buffer from batch
In reply to Zbigniew KempczyńskiCurrently we need to ensure intel_buf is a part of single ibb due to fact it is acquiring address from allocator so we cannot keep it in two separate ibbs (theoretically it is possible when different ibbs would be in same context but it is not currently implemented).
--- tests/i915/perf.c | 9 +++++++++ 1 file changed, 9 insertions(+)
tests/i915/perf.c +9 -0
@@ -3527,6 +3527,9 @@ gen8_test_single_ctx_render_target_writes_a_counter(void)/* Another redundant flush to clarify batch bo is free to reuse */ intel_bb_flush_render (ibb0); +/* Remove intel_buf from ibb0 added implicitly in rendercopy */ +intel_bb_remove_intel_buf (ibb0, dst_buf); +/* submit two copies on the other context to avoid a false * positive in case the driver somehow ended up filtering for * context1
@@ -3919,6 +3922,9 @@ static void gen12_single_ctx_helper(void) BO_REPORT_ID0);intel_bb_flush_render (ibb0); +/* Remove intel_buf from ibb0 added implicitly in rendercopy */ +intel_bb_remove_intel_buf (ibb0, dst_buf); +/* This is the work/context that is measured for counter increments */ render_copy(ibb0, &src[0], 0, 0, width, height,
@@ -3965,6 +3971,9 @@ static void gen12_single_ctx_helper(void) BO_REPORT_ID3);intel_bb_flush_render (ibb1); +/* Remove intel_buf from ibb1 added implicitly in rendercopy */ +intel_bb_remove_intel_buf (ibb1, dst_buf); +/* Submit an mi-rpc to context0 after all measurable work */ #define BO_TIMESTAMP_OFFSET1 1032#define BO_REPORT_OFFSET1 256
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 36/40 tests/gem_linear_blits: Use intel allocator
In reply to Zbigniew KempczyńskiFrom: Dominik Grzegorzek <[email protected]>
Use intel allocator directly, without intel-bb infrastructure.
--- tests/i915/gem_linear_blits.c | 90 ++++++++++++++++++++++++++--------- 1 file changed, 68 insertions(+), 22 deletions(-)
tests/i915/gem_linear_blits.c +68 -22
@@ -53,10 +53,13 @@ IGT_TEST_DESCRIPTION("Test doing many blits with a working set larger than the"#define WIDTH 512#define HEIGHT 512 +/* We don't have alignment detection yet, so assume worst case scenario */ +#define ALIGNMENT (2048*1024) +static uint32_t linear[WIDTH *HEIGHT ]; -static void -copy (int fd,uint32_t dst,uint32_t src) +static void copy (int fd,uint64_t ahnd,uint32_t dst,uint32_t src, +uint64_t dst_offset,uint64_t src_offset,bool do_relocs) {uint32_t batch[12 ];struct drm_i915_gem_relocation_entry reloc[2 ];
@@ -64,6 +67,20 @@ copy(int fd, uint32_t dst, uint32_t src)struct drm_i915_gem_execbuffer2 exec;int i =0 ; +memset (obj,0 ,sizeof (obj)); + obj[0 ].handle = dst; + obj[0 ].offset =CANONICAL (dst_offset); + obj[0 ].flags =EXEC_OBJECT_WRITE |EXEC_OBJECT_SUPPORTS_48B_ADDRESS ; + obj[1 ].handle = src; + obj[1 ].offset =CANONICAL (src_offset); + obj[1 ].flags =EXEC_OBJECT_SUPPORTS_48B_ADDRESS ; + + obj[2 ].handle =gem_create (fd,4096 ); + obj[2 ].offset =intel_allocator_alloc (ahnd, obj[2 ].handle, +4096 ,ALIGNMENT ); + obj[2 ].offset =CANONICAL (obj[2 ].offset); + obj[2 ].flags =EXEC_OBJECT_SUPPORTS_48B_ADDRESS ; + batch[i++] =XY_SRC_COPY_BLT_CMD |XY_SRC_COPY_BLT_WRITE_ALPHA |XY_SRC_COPY_BLT_WRITE_RGB ;
@@ -77,22 +94,24 @@ copy(int fd, uint32_t dst, uint32_t src)WIDTH *4 ; batch[i++] =0 ;/* dst x1,y1 */ batch[i++] = (HEIGHT <<16 ) |WIDTH ;/* dst x2,y2 */ - batch[i++] =0 ;/* dst reloc */ + batch[i++] = obj[0 ].offset;if (intel_gen (intel_get_drm_devid (fd)) >=8 ) - batch[i++] =0 ; + batch[i++] = obj[0 ].offset >>32 ; batch[i++] =0 ;/* src x1,y1 */ batch[i++] =WIDTH *4 ; - batch[i++] =0 ;/* src reloc */ + batch[i++] = obj[1 ].offset;if (intel_gen (intel_get_drm_devid (fd)) >=8 ) - batch[i++] =0 ; + batch[i++] = obj[1 ].offset >>32 ; batch[i++] =MI_BATCH_BUFFER_END ; batch[i++] =MI_NOOP ; +gem_write (fd, obj[2 ].handle,0 , batch, i *sizeof (batch[0 ])); +memset (reloc,0 ,sizeof (reloc)); reloc[0 ].target_handle = dst; reloc[0 ].delta =0 ; reloc[0 ].offset =4 *sizeof (batch[0 ]); - reloc[0 ].presumed_offset =0 ; + reloc[0 ].presumed_offset = obj[0 ].offset; reloc[0 ].read_domains =I915_GEM_DOMAIN_RENDER ; reloc[0 ].write_domain =I915_GEM_DOMAIN_RENDER ;
@@ -101,25 +120,27 @@ copy(int fd, uint32_t dst, uint32_t src) reloc[1 ].offset =7 *sizeof (batch[0 ]);if (intel_gen (intel_get_drm_devid (fd)) >=8 ) reloc[1 ].offset +=sizeof (batch[0 ]); - reloc[1 ].presumed_offset =0 ; + reloc[1 ].presumed_offset = obj[1 ].offset; reloc[1 ].read_domains =I915_GEM_DOMAIN_RENDER ; reloc[1 ].write_domain =0 ; -memset (obj,0 ,sizeof (obj)); - obj[0 ].handle = dst; - obj[1 ].handle = src; - obj[2 ].handle =gem_create (fd,4096 ); -gem_write (fd, obj[2 ].handle,0 , batch, i *sizeof (batch[0 ])); - obj[2 ].relocation_count =2 ; - obj[2 ].relocs_ptr =to_user_pointer (reloc); +if (do_relocs) { + obj[2 ].relocation_count =ARRAY_SIZE (reloc); + obj[2 ].relocs_ptr =to_user_pointer (reloc); + }else { + obj[0 ].flags |=EXEC_OBJECT_PINNED ; + obj[1 ].flags |=EXEC_OBJECT_PINNED ; + obj[2 ].flags |=EXEC_OBJECT_PINNED ; + }memset (&exec,0 ,sizeof (exec)); exec.buffers_ptr =to_user_pointer (obj); - exec.buffer_count =3 ; + exec.buffer_count =ARRAY_SIZE (obj); exec.batch_len = i *sizeof (batch[0 ]); exec.flags =gem_has_blt (fd) ?I915_EXEC_BLT :0 ; -gem_execbuf (fd, &exec); + +intel_allocator_free (ahnd, obj[2 ].handle);gem_close (fd, obj[2 ].handle); }
@@ -157,17 +178,28 @@ check_bo(int fd, uint32_t handle, uint32_t val)igt_assert_eq (num_errors,0 ); } -static void run_test (int fd,int count) +static void run_test (int fd,int count,bool do_relocs) {uint32_t *handle, *start_val; +uint64_t *offset, ahnd;uint32_t start =0 ;int i; + ahnd =intel_allocator_open (fd,0 , do_relocs ? +INTEL_ALLOCATOR_RELOC : +INTEL_ALLOCATOR_SIMPLE ); + handle =malloc (sizeof (uint32_t ) * count *2 ); + offset =calloc (1 ,sizeof (uint64_t ) * count); +igt_assert_f (handle && offset,"Allocation failed\n" ); start_val = handle + count;for (i =0 ; i < count; i++) { handle[i] =create_bo (fd, start); + + offset[i] =intel_allocator_alloc (ahnd, handle[i], +sizeof (linear),ALIGNMENT ); + start_val[i] = start; start +=1024 *1024 /4 ; }
@@ -178,17 +210,22 @@ static void run_test(int fd, int count)if (src == dst)continue ; +copy (fd, ahnd, handle[dst], handle[src], + offset[dst], offset[src], do_relocs); -copy (fd, handle[dst], handle[src]); start_val[dst] = start_val[src]; }for (i =0 ; i < count; i++) {check_bo (fd, handle[i], start_val[i]); +intel_allocator_free (ahnd, handle[i]);gem_close (fd, handle[i]); }free (handle); +free (offset); + +intel_allocator_close (ahnd); }#define MAX_32b ((1ull << 32) - 4096)
@@ -197,16 +234,21 @@ igt_main {const int ncpus =sysconf (_SC_NPROCESSORS_ONLN);uint64_t count =0 ; +bool do_relocs;int fd =-1 ; igt_fixture { fd =drm_open_driver (DRIVER_INTEL );igt_require_gem (fd);gem_require_blitter (fd); + do_relocs = !gem_uses_ppgtt (fd); count =gem_aperture_size (fd);if (count >>32 ) count = MAX_32b; +else + do_relocs = true; + count =3 + count / (1024 *1024 );igt_require (count >1 );intel_require_memory (count,sizeof (linear),CHECK_RAM );
@@ -216,19 +258,23 @@ igt_main } igt_subtest("basic") -run_test (fd,2 ); +run_test (fd,2 , do_relocs); igt_subtest("normal") { +intel_allocator_multiprocess_start (); igt_fork(child, ncpus) -run_test (fd, count); +run_test (fd, count, do_relocs);igt_waitchildren (); +intel_allocator_multiprocess_stop (); } igt_subtest("interruptible") { +intel_allocator_multiprocess_start ();igt_fork_signal_helper (); igt_fork(child, ncpus) -run_test (fd, count); +run_test (fd, count, do_relocs);igt_waitchildren ();igt_stop_signal_helper (); +intel_allocator_multiprocess_stop (); } }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 37/40 lib/intel_allocator: drop kill_children()
In reply to Zbigniew KempczyńskiUse igt_waitchildren_timeout() instead of custom kill_children() function to avoid killing handlers (hang, ...)
--- lib/intel_allocator.c | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-)
lib/intel_allocator.c +2 -13
@@ -715,16 +715,6 @@ static int handle_request(struct alloc_req *req, struct alloc_resp *resp)return ret; } -static void kill_children (int sig) -{ -sighandler_t old; - - old =signal (sig,SIG_IGN ); -igt_assert (old !=SIG_ERR ); -kill (-getpgrp (), sig); -igt_assert (signal (sig, old) !=SIG_ERR ); -} -static void *allocator_thread_loop (void *data) {struct alloc_req req;
@@ -744,7 +734,7 @@ static void *allocator_thread_loop(void *data)if (ret ==-1 ) {igt_warn ("Error receiving request in thread, ret = %d [%s]\n" , ret,strerror (errno)); -kill_children (SIGINT ); +igt_waitchildren_timeout (1 ,"Stopping children, error receiving request\n" );return (void *)-1 ; }
@@ -766,7 +756,7 @@ static void *allocator_thread_loop(void *data)igt_warn ("Error sending response in thread, ret = %d [%s]\n" , ret,strerror (errno)); -kill_children (SIGINT ); +igt_waitchildren_timeout (1 ,"Stopping children, error sending response\n" );return (void *)-1 ; } }
@@ -858,7 +848,6 @@ void intel_allocator_multiprocess_stop(void)pthread_join (allocator_thread,NULL );/* But we're not sure does child will stuck */ -kill_children (SIGINT );igt_waitchildren_timeout (5 ,"Stopping children" ); multiprocess = false; }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 38/40 lib/intel_allocator: Add alloc function which allows passing strategy argument
In reply to Zbigniew KempczyńskiTo use spinners with no-reloc we need to alloc offsets for them from already opened allocator. As we don't know what strategy is chosen for open (likely HIGH_TO_LOW for SIMPLE allocator) we want to overwrite it for spinners (there's expectation they will reside on low addresses).
Extend allocator API adding intel_allocator_alloc_with_strategy() to support spinners rewriting.
--- lib/intel_allocator.c | 47 +++++++++++++++++++++++++++----- lib/intel_allocator.h | 10 +++++-- lib/intel_allocator_msgchannel.h | 1 + lib/intel_allocator_random.c | 4 ++- lib/intel_allocator_reloc.c | 4 ++- lib/intel_allocator_simple.c | 39 ++++++++++++++------------ 6 files changed, 76 insertions(+), 29 deletions(-)
lib/intel_allocator.c +40 -7
@@ -579,15 +579,17 @@ static int handle_request(struct alloc_req *req, struct alloc_resp *resp) resp->alloc.offset = ial->alloc (ial, req->alloc.handle, req->alloc.size, - req->alloc.alignment); + req->alloc.alignment, + req->alloc.strategy);alloc_info ("<alloc> [tid: %ld] ahnd: %" PRIx64", ctx: %u, vm: %u, handle: %u" ", size: 0x%" PRIx64", offset: 0x%" PRIx64 -", alignment: 0x%" PRIx64"\n" , +", alignment: 0x%" PRIx64", strategy: %u\n" , (long ) req->tid, req->allocator_handle, al->ctx, al->vm, req->alloc.handle, req->alloc.size, - resp->alloc.offset, req->alloc.alignment); + resp->alloc.offset, req->alloc.alignment, + req->alloc.strategy);break ;case REQ_FREE :
@@ -1040,13 +1042,15 @@ void intel_allocator_get_address_range(uint64_t allocator_handle,* range returns ALLOC_INVALID_ADDRESS. */ uint64_t __intel_allocator_alloc (uint64_t allocator_handle,uint32_t handle, -uint64_t size,uint64_t alignment) +uint64_t size,uint64_t alignment, +enum allocator_strategy strategy) {struct alloc_req req = { .request_type =REQ_ALLOC , .allocator_handle = allocator_handle, .alloc.handle = handle, .alloc.size = size, - .alloc.alignment = alignment }; + .alloc.alignment = alignment, + .alloc.strategy = strategy };struct alloc_resp resp;igt_assert (handle_request (&req, &resp) ==0 );
@@ -1063,7 +1067,8 @@ uint64_t __intel_allocator_alloc(uint64_t allocator_handle, uint32_t handle,* @alignment: determines object alignment * * Same as __intel_allocator_alloc() but asserts if allocator can't return -* valid address. +* valid address. Uses default allocation strategy chosen during opening +* the allocator. */ uint64_t intel_allocator_alloc (uint64_t allocator_handle,uint32_t handle,uint64_t size,uint64_t alignment)
@@ -1071,12 +1076,40 @@ uint64_t intel_allocator_alloc(uint64_t allocator_handle, uint32_t handle,uint64_t offset; offset =__intel_allocator_alloc (allocator_handle, handle, - size, alignment); + size, alignment, +ALLOC_STRATEGY_NONE );igt_assert (offset !=ALLOC_INVALID_ADDRESS );return offset; } +/** +* intel_allocator_alloc_with_strategy: +* @allocator_handle: handle to an allocator +* @handle: handle to an object +* @size: size of an object +* @alignment: determines object alignment +* @strategy: strategy of allocation +* +* Same as __intel_allocator_alloc() but asserts if allocator can't return +* valid address. Use @strategy instead of default chosen during opening +* the allocator. +*/ +uint64_t intel_allocator_alloc_with_strategy (uint64_t allocator_handle, +uint32_t handle, +uint64_t size,uint64_t alignment, +enum allocator_strategy strategy) +{ +uint64_t offset; + + offset =__intel_allocator_alloc (allocator_handle, handle, + size, alignment, strategy); +igt_assert (offset !=ALLOC_INVALID_ADDRESS ); + +return offset; +} + +/** * intel_allocator_free: * @allocator_handle: handle to an allocator
lib/intel_allocator.h +8 -2
@@ -141,7 +141,8 @@ struct intel_allocator {void (*get_address_range)(struct intel_allocator *ial,uint64_t *startp,uint64_t *endp);uint64_t (*alloc)(struct intel_allocator *ial,uint32_t handle, -uint64_t size,uint64_t alignment); +uint64_t size,uint64_t alignment, +enum allocator_strategy strategy);bool (*is_allocated)(struct intel_allocator *ial,uint32_t handle,uint64_t size,uint64_t alignment); bool (*reserve)(struct intel_allocator *ial,
@@ -181,9 +182,14 @@ bool intel_allocator_close(uint64_t allocator_handle);void intel_allocator_get_address_range (uint64_t allocator_handle,uint64_t *startp,uint64_t *endp);uint64_t __intel_allocator_alloc (uint64_t allocator_handle,uint32_t handle, -uint64_t size,uint64_t alignment); +uint64_t size,uint64_t alignment, +enum allocator_strategy strategy);uint64_t intel_allocator_alloc (uint64_t allocator_handle,uint32_t handle,uint64_t size,uint64_t alignment); +uint64_t intel_allocator_alloc_with_strategy (uint64_t allocator_handle, +uint32_t handle, +uint64_t size,uint64_t alignment, +enum allocator_strategy strategy);bool intel_allocator_free (uint64_t allocator_handle,uint32_t handle);bool intel_allocator_is_allocated (uint64_t allocator_handle,uint32_t handle,uint64_t size,uint64_t offset);
lib/intel_allocator_msgchannel.h +1 -0
@@ -65,6 +65,7 @@ struct alloc_req {uint32_t handle;uint64_t size;uint64_t alignment; +uint8_t strategy; } alloc;struct {
lib/intel_allocator_random.c +3 -1
@@ -45,12 +45,14 @@ static void intel_allocator_random_get_address_range(struct intel_allocator *ialstatic uint64_t intel_allocator_random_alloc (struct intel_allocator *ial,uint32_t handle,uint64_t size, -uint64_t alignment) +uint64_t alignment, +enum allocator_strategy strategy) {struct intel_allocator_random *ialr = ial->priv;uint64_t offset; (void ) handle; + (void ) strategy;/* randomize the address, we try to avoid relocations */ do {
lib/intel_allocator_reloc.c +3 -1
@@ -46,12 +46,14 @@ static void intel_allocator_reloc_get_address_range(struct intel_allocator *ial,static uint64_t intel_allocator_reloc_alloc (struct intel_allocator *ial,uint32_t handle,uint64_t size, -uint64_t alignment) +uint64_t alignment, +enum allocator_strategy strategy) {struct intel_allocator_reloc *ialr = ial->priv;uint64_t offset, aligned_offset; (void ) handle; + (void ) strategy; alignment =max (alignment,4096 ); aligned_offset =ALIGN (ialr->offset, alignment);
lib/intel_allocator_simple.c +21 -18
@@ -25,12 +25,7 @@ intel_allocator_simple_create_full(int fd, uint64_t start, uint64_t end,struct simple_vma_heap {struct igt_list_head holes; - -/* If true, simple_vma_heap_alloc will prefer high addresses -* -* Default is true. -*/ -bool alloc_high; +enum allocator_strategy strategy; };struct simple_vma_hole {
@@ -220,14 +215,11 @@ static void simple_vma_heap_init(struct simple_vma_heap *heap,IGT_INIT_LIST_HEAD (&heap->holes);simple_vma_heap_free (heap, start, size); -switch (strategy) { -case ALLOC_STRATEGY_LOW_TO_HIGH : - heap->alloc_high = false; -break ; -case ALLOC_STRATEGY_HIGH_TO_LOW : -default : - heap->alloc_high = true; - } +/* Use LOW_TO_HIGH or HIGH_TO_LOW strategy only */ +if (strategy ==ALLOC_STRATEGY_LOW_TO_HIGH ) + heap->strategy = strategy; +else + heap->strategy =ALLOC_STRATEGY_HIGH_TO_LOW ; }static void simple_vma_heap_finish (struct simple_vma_heap *heap)
@@ -294,7 +286,8 @@ static void simple_vma_hole_alloc(struct simple_vma_hole *hole,static bool simple_vma_heap_alloc (struct simple_vma_heap *heap,uint64_t *offset,uint64_t size, -uint64_t alignment) +uint64_t alignment, +enum allocator_strategy strategy) {struct simple_vma_hole *hole, *tmp;uint64_t misalign;
@@ -305,7 +298,16 @@ static bool simple_vma_heap_alloc(struct simple_vma_heap *heap,simple_vma_heap_validate (heap); -if (heap->alloc_high) { +/* Ensure we support only NONE/LOW_TO_HIGH/HIGH_TO_LOW strategies */ +igt_assert (strategy ==ALLOC_STRATEGY_NONE || + strategy ==ALLOC_STRATEGY_LOW_TO_HIGH || + strategy ==ALLOC_STRATEGY_HIGH_TO_LOW ); + +/* Use default strategy chosen on open */ +if (strategy ==ALLOC_STRATEGY_NONE ) + strategy = heap->strategy; + +if (strategy ==ALLOC_STRATEGY_HIGH_TO_LOW ) { simple_vma_foreach_hole_safe(hole, heap, tmp) {if (size > hole->size)continue ;
@@ -412,7 +414,8 @@ static bool simple_vma_heap_alloc_addr(struct intel_allocator_simple *ials,static uint64_t intel_allocator_simple_alloc (struct intel_allocator *ial,uint32_t handle,uint64_t size, -uint64_t alignment) +uint64_t alignment, +enum allocator_strategy strategy) {struct intel_allocator_record *rec;struct intel_allocator_simple *ials;
@@ -430,7 +433,7 @@ static uint64_t intel_allocator_simple_alloc(struct intel_allocator *ial,igt_assert (rec->size == size); }else {if (!simple_vma_heap_alloc (&ials->heap, &offset, - size, alignment)) + size, alignment, strategy))return ALLOC_INVALID_ADDRESS ; rec =malloc (sizeof (*rec));
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 39/40 tests/api_intel_allocator: Check alloc with strategy API
In reply to Zbigniew KempczyńskiVerify strategy is properly handled in allocator alloc() call.
--- tests/i915/api_intel_allocator.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
tests/i915/api_intel_allocator.c +10 -1
@@ -50,10 +50,19 @@ static void alloc_simple(int fd)intel_allocator_get_address_range (ahnd, &start, &end); offset0 =intel_allocator_alloc (ahnd,1 , end - start,0 ); - offset1 =__intel_allocator_alloc (ahnd,2 ,4096 ,0 ); + offset1 =__intel_allocator_alloc (ahnd,2 ,4096 ,0 ,ALLOC_STRATEGY_NONE );igt_assert (offset1 ==ALLOC_INVALID_ADDRESS );intel_allocator_free (ahnd,1 ); + offset0 =intel_allocator_alloc_with_strategy (ahnd,1 ,4096 ,0 , +ALLOC_STRATEGY_HIGH_TO_LOW ); + offset1 =intel_allocator_alloc_with_strategy (ahnd,2 ,4096 ,0 , +ALLOC_STRATEGY_LOW_TO_HIGH ); +igt_assert (offset0 > offset1); + +intel_allocator_free (ahnd,1 ); +intel_allocator_free (ahnd,2 ); +igt_assert_eq (intel_allocator_close (ahnd), true); }
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
PATCH v31 40/40 lib/intel_allocator: Wait for allocator thread to be ready
In reply to Zbigniew KempczyńskiBefore allowing allocator working in multiprocess mode we have to ensure it is ready and able to process allocator messages passed from children.
--- lib/intel_allocator.c | 7 +++++++ 1 file changed, 7 insertions(+)
lib/intel_allocator.c +7 -0
@@ -794,10 +794,17 @@ void __intel_allocator_multiprocess_prepare(void) channel->init (channel); } +#define START_TIMEOUT_MS 100void __intel_allocator_multiprocess_start (void ) { +int time_left =START_TIMEOUT_MS ; +pthread_create (&allocator_thread,NULL , allocator_thread_loop,NULL ); + +/* Wait unless allocator thread get started */ +while (time_left-- >0 && !READ_ONCE (allocator_thread_running)) +usleep (1000 ); }/**
Signature · 6 lines
2.26.0 _______________________________________________ igt-dev mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/igt-dev
Patchwork
CI[igt-dev] ✗ Fi.CI.BUILD: failure for Introduce IGT allocator (rev34)
In reply to Zbigniew Kempczyński== Series Details ==
== Series Details ==
Series: Introduce IGT allocator (rev34)
URL : https://patchwork.freedesktop.org/series/82954/
State : failure
== Summary ==
Applying: lib/igt_list: Add igt_list_del_init()
Applying: lib/igt_list: Add igt_list_for_each_entry_safe_reverse
Applying: lib/igt_map: Adopt Mesa hash table
Using index info to reconstruct a base tree...
A lib/Makefile.sources
M lib/meson.build
Falling back to patching base and 3-way merge...
Auto-merging lib/meson.build
CONFLICT (modify/delete): lib/Makefile.sources deleted in HEAD and modified in lib/igt_map: Adopt Mesa hash table. Version lib/igt_map: Adopt Mesa hash table of lib/Makefile.sources left in tree. Patch failed at 0003 lib/igt_map: Adopt Mesa hash table
When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".
_______________________________________________
igt-dev mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/igt-dev