From: "Souza, Jose" <jose.souza@intel.com>
To: "igt-dev@lists.freedesktop.org" <igt-dev@lists.freedesktop.org>,
"Auld, Matthew" <matthew.auld@intel.com>
Subject: Re: [igt-dev] [PATCH i-g-t v3 4/6] tests/xe: handle small-bar systems
Date: Fri, 14 Jul 2023 17:02:16 +0000 [thread overview]
Message-ID: <fa7f7577e26a1027a2e17db9d0912ab457be14cf.camel@intel.com> (raw)
In-Reply-To: <20230714144238.573403-5-matthew.auld@intel.com>
On Fri, 2023-07-14 at 15:42 +0100, Matthew Auld wrote:
> Convert all the existing tests that require CPU access.
>
Missing conversion in test_bad_flags(), test_bad_extensions(), test_bad_object(), test_with_one_bo_two_files(), test_reimport_close_race(),
thread_fn_export_vs_close(), test_llseek_size(), test_llseek_bad().
The mmaps tests are expected to fail but not because region is not cpu mmaped.
For the prime_self_import test it is also good to require visible vram even if the test don't do any operation with CPU, in real world applications
you need to give applications the flexibility to access it in CPU as well.
> v2:
> - Split out the lib changes
> - Prefer SZ_256M and SZ_1G in xe_evict
> - Simplify and fix the bo_flags handling in test_exec
> v3:
> - Small fix in xe_evict conversion (missing system_memory(fd))
>
> Signed-off-by: Matthew Auld <matthew.auld@intel.com>
> Cc: José Roberto de Souza <jose.souza@intel.com>
> Cc: Kamil Konieczny <kamil.konieczny@linux.intel.com>
> Cc: Gwan-gyeong Mun <gwan-gyeong.mun@intel.com>
> ---
> tests/xe/xe_dma_buf_sync.c | 3 ++-
> tests/xe/xe_evict.c | 34 +++++++++++++++++++++------------
> tests/xe/xe_exec_balancer.c | 6 +++---
> tests/xe/xe_exec_basic.c | 17 ++++++++---------
> tests/xe/xe_exec_compute_mode.c | 4 ++--
> tests/xe/xe_exec_fault_mode.c | 12 ++++++++----
> tests/xe/xe_exec_reset.c | 13 ++++++++-----
> tests/xe/xe_exec_store.c | 6 ++++--
> tests/xe/xe_exec_threads.c | 9 ++++++---
> tests/xe/xe_guc_pc.c | 3 ++-
> tests/xe/xe_mmap.c | 4 ++--
> tests/xe/xe_pm.c | 3 ++-
> tests/xe/xe_prime_self_import.c | 8 ++++----
> tests/xe/xe_vm.c | 23 +++++++++++++++-------
> 14 files changed, 89 insertions(+), 56 deletions(-)
>
> diff --git a/tests/xe/xe_dma_buf_sync.c b/tests/xe/xe_dma_buf_sync.c
> index c08f8ac18..4e76d85ab 100644
> --- a/tests/xe/xe_dma_buf_sync.c
> +++ b/tests/xe/xe_dma_buf_sync.c
> @@ -120,7 +120,8 @@ test_export_dma_buf(struct drm_xe_engine_class_instance *hwe0,
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd[0]),
> xe_get_default_alignment(fd[0]));
> for (i = 0; i < n_bo; ++i) {
> - bo[i] = xe_bo_create(fd[0], hwe0->gt_id, 0, bo_size);
> + bo[i] = xe_bo_create_flags(fd[0], 0, bo_size,
> + visible_vram_if_possible(fd[0], hwe0->gt_id));
> dma_buf_fd[i] = prime_handle_to_fd(fd[0], bo[i]);
> import_bo[i] = prime_fd_to_handle(fd[1], dma_buf_fd[i]);
>
> diff --git a/tests/xe/xe_evict.c b/tests/xe/xe_evict.c
> index 1a70f1b45..c44cb80dc 100644
> --- a/tests/xe/xe_evict.c
> +++ b/tests/xe/xe_evict.c
> @@ -97,15 +97,17 @@ test_evict(int fd, struct drm_xe_engine_class_instance *eci,
> i < n_execs / 8 ? 0 : vm;
>
> if (flags & MULTI_VM) {
> - __bo = bo[i] = xe_bo_create(fd, eci->gt_id, 0,
> - bo_size);
> + __bo = bo[i] = xe_bo_create_flags(fd, 0,
> + bo_size,
> + visible_vram_memory(fd, eci->gt_id));
> } else if (flags & THREADED) {
> - __bo = bo[i] = xe_bo_create(fd, eci->gt_id, vm,
> - bo_size);
> + __bo = bo[i] = xe_bo_create_flags(fd, vm,
> + bo_size,
> + visible_vram_memory(fd, eci->gt_id));
> } else {
> __bo = bo[i] = xe_bo_create_flags(fd, _vm,
> bo_size,
> - vram_memory(fd, eci->gt_id) |
> + visible_vram_memory(fd, eci->gt_id) |
> system_memory(fd));
> }
> } else {
> @@ -278,15 +280,17 @@ test_evict_cm(int fd, struct drm_xe_engine_class_instance *eci,
> i < n_execs / 8 ? 0 : vm;
>
> if (flags & MULTI_VM) {
> - __bo = bo[i] = xe_bo_create(fd, eci->gt_id,
> - 0, bo_size);
> + __bo = bo[i] = xe_bo_create_flags(fd, 0,
> + bo_size,
> + visible_vram_memory(fd, eci->gt_id));
> } else if (flags & THREADED) {
> - __bo = bo[i] = xe_bo_create(fd, eci->gt_id,
> - vm, bo_size);
> + __bo = bo[i] = xe_bo_create_flags(fd, vm,
> + bo_size,
> + visible_vram_memory(fd, eci->gt_id));
> } else {
> __bo = bo[i] = xe_bo_create_flags(fd, _vm,
> bo_size,
> - vram_memory(fd, eci->gt_id) |
> + visible_vram_memory(fd, eci->gt_id) |
> system_memory(fd));
> }
> } else {
> @@ -449,9 +453,15 @@ threads(int fd, struct drm_xe_engine_class_instance *eci,
> pthread_join(threads_data[i].thread, NULL);
> }
>
> +#define SZ_256M 0x10000000
> +#define SZ_1G 0x40000000
> +
> static uint64_t calc_bo_size(uint64_t vram_size, int mul, int div)
> {
> - return (ALIGN(vram_size, 0x40000000) * mul) / div;
> + if (vram_size >= SZ_1G)
> + return (ALIGN(vram_size, SZ_1G) * mul) / div;
> + else
> + return (ALIGN(vram_size, SZ_256M) * mul) / div; /* small-bar */
> }
>
> /**
> @@ -664,7 +674,7 @@ igt_main
> igt_fixture {
> fd = drm_open_driver(DRIVER_XE);
> igt_require(xe_has_vram(fd));
> - vram_size = xe_vram_size(fd, 0);
> + vram_size = xe_visible_vram_size(fd, 0);
> igt_assert(vram_size);
>
> xe_for_each_hw_engine(fd, hwe)
> diff --git a/tests/xe/xe_exec_balancer.c b/tests/xe/xe_exec_balancer.c
> index 8df6ceba8..0b00d93de 100644
> --- a/tests/xe/xe_exec_balancer.c
> +++ b/tests/xe/xe_exec_balancer.c
> @@ -69,7 +69,7 @@ static void test_all_active(int fd, int gt, int class)
> bo_size = sizeof(*data) * num_placements;
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd), xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, gt, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> data = xe_bo_map(fd, bo, bo_size);
>
> for (i = 0; i < num_placements; i++) {
> @@ -225,7 +225,7 @@ test_exec(int fd, int gt, int class, int n_engines, int n_execs,
> }
> memset(data, 0, bo_size);
> } else {
> - bo = xe_bo_create(fd, gt, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> data = xe_bo_map(fd, bo, bo_size);
> }
>
> @@ -447,7 +447,7 @@ test_cm(int fd, int gt, int class, int n_engines, int n_execs,
> igt_assert(data);
> }
> } else {
> - bo = xe_bo_create(fd, gt, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> data = xe_bo_map(fd, bo, bo_size);
> }
> memset(data, 0, bo_size);
> diff --git a/tests/xe/xe_exec_basic.c b/tests/xe/xe_exec_basic.c
> index af581c327..a4bae93f0 100644
> --- a/tests/xe/xe_exec_basic.c
> +++ b/tests/xe/xe_exec_basic.c
> @@ -126,15 +126,14 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
> }
> memset(data, 0, bo_size);
> } else {
> - if (flags & DEFER_ALLOC) {
> - bo = xe_bo_create_flags(fd, n_vm == 1 ? vm[0] : 0,
> - bo_size,
> - vram_if_possible(fd, eci->gt_id) |
> - XE_GEM_CREATE_FLAG_DEFER_BACKING);
> - } else {
> - bo = xe_bo_create(fd, eci->gt_id, n_vm == 1 ? vm[0] : 0,
> - bo_size);
> - }
> + uint32_t bo_flags;
> +
> + bo_flags = visible_vram_if_possible(fd, eci->gt_id);
> + if (flags & DEFER_ALLOC)
> + bo_flags |= XE_GEM_CREATE_FLAG_DEFER_BACKING;
> +
> + bo = xe_bo_create_flags(fd, n_vm == 1 ? vm[0] : 0,
> + bo_size, bo_flags);
> if (!(flags & DEFER_BIND))
> data = xe_bo_map(fd, bo, bo_size);
> }
> diff --git a/tests/xe/xe_exec_compute_mode.c b/tests/xe/xe_exec_compute_mode.c
> index 27b538414..ee9756c21 100644
> --- a/tests/xe/xe_exec_compute_mode.c
> +++ b/tests/xe/xe_exec_compute_mode.c
> @@ -150,8 +150,8 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
> igt_assert(data);
> }
> } else {
> - bo = xe_bo_create(fd, eci->gt_id, flags & VM_FOR_BO ? vm : 0,
> - bo_size);
> + bo = xe_bo_create_flags(fd, flags & VM_FOR_BO ? vm : 0,
> + bo_size, visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
> }
> memset(data, 0, bo_size);
> diff --git a/tests/xe/xe_exec_fault_mode.c b/tests/xe/xe_exec_fault_mode.c
> index bf7230c5a..7dcbb3c45 100644
> --- a/tests/xe/xe_exec_fault_mode.c
> +++ b/tests/xe/xe_exec_fault_mode.c
> @@ -153,9 +153,11 @@ test_exec(int fd, struct drm_xe_engine_class_instance *eci,
> } else {
> if (flags & PREFETCH)
> bo = xe_bo_create_flags(fd, 0, bo_size,
> - all_memory_regions(fd));
> + all_memory_regions(fd) |
> + visible_vram_if_possible(fd, 0));
> else
> - bo = xe_bo_create(fd, eci->gt_id, 0, bo_size);
> + bo = xe_bo_create_flags(fd, 0, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
> }
> memset(data, 0, bo_size);
> @@ -382,8 +384,10 @@ test_atomic(int fd, struct drm_xe_engine_class_instance *eci,
> addr_wait = addr + bo_size;
>
> bo = xe_bo_create_flags(fd, vm, bo_size,
> - all_memory_regions(fd));
> - bo_wait = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + all_memory_regions(fd) |
> + visible_vram_if_possible(fd, 0));
> + bo_wait = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
> wait = xe_bo_map(fd, bo_wait, bo_size);
> ptr = &data[0].data;
> diff --git a/tests/xe/xe_exec_reset.c b/tests/xe/xe_exec_reset.c
> index 6ca1cd769..dfbaa6035 100644
> --- a/tests/xe/xe_exec_reset.c
> +++ b/tests/xe/xe_exec_reset.c
> @@ -50,7 +50,8 @@ static void test_spin(int fd, struct drm_xe_engine_class_instance *eci)
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> spin = xe_bo_map(fd, bo, bo_size);
>
> engine = xe_engine_create(fd, vm, eci, 0);
> @@ -187,7 +188,7 @@ test_balancer(int fd, int gt, int class, int n_engines, int n_execs,
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, gt, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, gt));
> data = xe_bo_map(fd, bo, bo_size);
>
> for (i = 0; i < n_engines; i++) {
> @@ -379,7 +380,8 @@ test_legacy_mode(int fd, struct drm_xe_engine_class_instance *eci,
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
>
> for (i = 0; i < n_engines; i++) {
> @@ -550,7 +552,8 @@ test_compute_mode(int fd, struct drm_xe_engine_class_instance *eci,
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
> memset(data, 0, bo_size);
>
> @@ -682,7 +685,7 @@ static void submit_jobs(struct gt_thread_data *t)
> uint32_t bo;
> uint32_t *data;
>
> - bo = xe_bo_create(fd, 0, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, 0));
> data = xe_bo_map(fd, bo, bo_size);
> data[0] = MI_BATCH_BUFFER_END;
>
> diff --git a/tests/xe/xe_exec_store.c b/tests/xe/xe_exec_store.c
> index 9640b1567..ab1bde36e 100644
> --- a/tests/xe/xe_exec_store.c
> +++ b/tests/xe/xe_exec_store.c
> @@ -82,7 +82,8 @@ static void store(int fd)
> xe_get_default_alignment(fd));
>
> hw_engine = xe_hw_engine(fd, 1);
> - bo = xe_bo_create(fd, hw_engine->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, hw_engine->gt_id));
>
> xe_vm_bind_async(fd, vm, hw_engine->gt_id, bo, 0, addr, bo_size, &sync, 1);
> data = xe_bo_map(fd, bo, bo_size);
> @@ -138,7 +139,8 @@ static void store_all(int fd, int gt, int class)
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, 0, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, 0));
> data = xe_bo_map(fd, bo, bo_size);
>
> xe_for_each_hw_engine(fd, hwe) {
> diff --git a/tests/xe/xe_exec_threads.c b/tests/xe/xe_exec_threads.c
> index 414d8ee9a..396398984 100644
> --- a/tests/xe/xe_exec_threads.c
> +++ b/tests/xe/xe_exec_threads.c
> @@ -106,7 +106,8 @@ test_balancer(int fd, int gt, uint32_t vm, uint64_t addr, uint64_t userptr,
> igt_assert(data);
> }
> } else {
> - bo = xe_bo_create(fd, gt, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, gt));
> data = xe_bo_map(fd, bo, bo_size);
> }
> memset(data, 0, bo_size);
> @@ -306,7 +307,8 @@ test_compute_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
> igt_assert(data);
> }
> } else {
> - bo = xe_bo_create(fd, eci->gt_id, 0, bo_size);
> + bo = xe_bo_create_flags(fd, 0, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
> }
> memset(data, 0, bo_size);
> @@ -516,7 +518,8 @@ test_legacy_mode(int fd, uint32_t vm, uint64_t addr, uint64_t userptr,
> igt_assert(data);
> }
> } else {
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
> }
> memset(data, 0, bo_size);
> diff --git a/tests/xe/xe_guc_pc.c b/tests/xe/xe_guc_pc.c
> index c34df8d60..6339b3893 100644
> --- a/tests/xe/xe_guc_pc.c
> +++ b/tests/xe/xe_guc_pc.c
> @@ -64,7 +64,8 @@ static void exec_basic(int fd, struct drm_xe_engine_class_instance *eci,
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
>
> for (i = 0; i < n_engines; i++) {
> diff --git a/tests/xe/xe_mmap.c b/tests/xe/xe_mmap.c
> index 798facca9..583f39d7a 100644
> --- a/tests/xe/xe_mmap.c
> +++ b/tests/xe/xe_mmap.c
> @@ -118,10 +118,10 @@ igt_main
> test_mmap(fd, system_memory(fd));
>
> igt_subtest("vram")
> - test_mmap(fd, vram_memory(fd, 0));
> + test_mmap(fd, visible_vram_memory(fd, 0));
>
> igt_subtest("vram-system")
> - test_mmap(fd, vram_memory(fd, 0) | system_memory(fd));
> + test_mmap(fd, visible_vram_memory(fd, 0) | system_memory(fd));
>
> igt_subtest("bad-flags")
> test_bad_flags(fd);
> diff --git a/tests/xe/xe_pm.c b/tests/xe/xe_pm.c
> index a7f73c4e6..559eccdeb 100644
> --- a/tests/xe/xe_pm.c
> +++ b/tests/xe/xe_pm.c
> @@ -254,7 +254,8 @@ test_exec(device_t device, struct drm_xe_engine_class_instance *eci,
> if (check_rpm && runtime_usage_available(device.pci_xe))
> rpm_usage = igt_pm_get_runtime_usage(device.pci_xe);
>
> - bo = xe_bo_create(device.fd_xe, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(device.fd_xe, vm, bo_size,
> + visible_vram_if_possible(device.fd_xe, eci->gt_id));
> data = xe_bo_map(device.fd_xe, bo, bo_size);
>
> for (i = 0; i < n_engines; i++) {
> diff --git a/tests/xe/xe_prime_self_import.c b/tests/xe/xe_prime_self_import.c
> index 0fd79f704..e712e2a9c 100644
> --- a/tests/xe/xe_prime_self_import.c
> +++ b/tests/xe/xe_prime_self_import.c
> @@ -107,7 +107,7 @@ static void test_with_fd_dup(void)
> fd1 = drm_open_driver(DRIVER_XE);
> fd2 = drm_open_driver(DRIVER_XE);
>
> - handle = xe_bo_create(fd1, 0, 0, BO_SIZE);
> + handle = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
>
> dma_buf_fd1 = prime_handle_to_fd(fd1, handle);
> gem_close(fd1, handle);
> @@ -141,8 +141,8 @@ static void test_with_two_bos(void)
> fd1 = drm_open_driver(DRIVER_XE);
> fd2 = drm_open_driver(DRIVER_XE);
>
> - handle1 = xe_bo_create(fd1, 0, 0, BO_SIZE);
> - handle2 = xe_bo_create(fd1, 0, 0, BO_SIZE);
> + handle1 = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
> + handle2 = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
>
> dma_buf_fd = prime_handle_to_fd(fd1, handle1);
> handle_import = prime_fd_to_handle(fd2, dma_buf_fd);
> @@ -211,7 +211,7 @@ static void test_with_one_bo(void)
> fd1 = drm_open_driver(DRIVER_XE);
> fd2 = drm_open_driver(DRIVER_XE);
>
> - handle = xe_bo_create(fd1, 0, 0, BO_SIZE);
> + handle = xe_bo_create_flags(fd1, 0, BO_SIZE, visible_vram_if_possible(fd1, 0));
>
> dma_buf_fd = prime_handle_to_fd(fd1, handle);
> handle_import1 = prime_fd_to_handle(fd2, dma_buf_fd);
> diff --git a/tests/xe/xe_vm.c b/tests/xe/xe_vm.c
> index 04d6c3956..982c50f6d 100644
> --- a/tests/xe/xe_vm.c
> +++ b/tests/xe/xe_vm.c
> @@ -52,7 +52,8 @@ write_dwords(int fd, uint32_t vm, int n_dwords, uint64_t *addrs)
> batch_size = (n_dwords * 4 + 1) * sizeof(uint32_t);
> batch_size = ALIGN(batch_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
> - batch_bo = xe_bo_create(fd, 0, vm, batch_size);
> + batch_bo = xe_bo_create_flags(fd, vm, batch_size,
> + visible_vram_if_possible(fd, 0));
> batch_map = xe_bo_map(fd, batch_bo, batch_size);
>
> for (i = 0; i < n_dwords; i++) {
> @@ -116,7 +117,7 @@ __test_bind_one_bo(int fd, uint32_t vm, int n_addrs, uint64_t *addrs)
> vms = malloc(sizeof(*vms) * n_addrs);
> igt_assert(vms);
> }
> - bo = xe_bo_create(fd, 0, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size, visible_vram_if_possible(fd, 0));
> map = xe_bo_map(fd, bo, bo_size);
> memset(map, 0, bo_size);
>
> @@ -554,7 +555,8 @@ shared_pte_page(int fd, struct drm_xe_engine_class_instance *eci, int n_bo,
> xe_get_default_alignment(fd));
>
> for (i = 0; i < n_bo; ++i) {
> - bo[i] = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo[i] = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data[i] = xe_bo_map(fd, bo[i], bo_size);
> }
>
> @@ -723,7 +725,8 @@ test_bind_engines_independent(int fd, struct drm_xe_engine_class_instance *eci)
> bo_size = sizeof(*data) * N_ENGINES;
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
>
> for (i = 0; i < N_ENGINES; i++) {
> @@ -880,7 +883,8 @@ test_bind_array(int fd, struct drm_xe_engine_class_instance *eci, int n_execs,
> bo_size = ALIGN(bo_size + xe_cs_prefetch_size(fd),
> xe_get_default_alignment(fd));
>
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> data = xe_bo_map(fd, bo, bo_size);
>
> if (flags & BIND_ARRAY_BIND_ENGINE_FLAG)
> @@ -1072,7 +1076,11 @@ test_large_binds(int fd, struct drm_xe_engine_class_instance *eci,
> map = aligned_alloc(xe_get_default_alignment(fd), bo_size);
> igt_assert(map);
> } else {
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + igt_skip_on(xe_visible_vram_size(fd, 0) && bo_size >
> + xe_visible_vram_size(fd, 0));
redundant 'xe_visible_vram_size(fd, 0)' if it is 0 it will be smaller than bo_size.
Other than this and the missing cases LGTM.
> +
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> map = xe_bo_map(fd, bo, bo_size);
> }
>
> @@ -1350,7 +1358,8 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
> MAP_ANONYMOUS, -1, 0);
> igt_assert(map != MAP_FAILED);
> } else {
> - bo = xe_bo_create(fd, eci->gt_id, vm, bo_size);
> + bo = xe_bo_create_flags(fd, vm, bo_size,
> + visible_vram_if_possible(fd, eci->gt_id));
> map = xe_bo_map(fd, bo, bo_size);
> }
> memset(map, 0, bo_size);
next prev parent reply other threads:[~2023-07-14 17:02 UTC|newest]
Thread overview: 16+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-07-14 14:42 [igt-dev] [PATCH i-g-t v3 0/6] IGT bits for small-bar Matthew Auld
2023-07-14 14:42 ` [igt-dev] [PATCH i-g-t v3 1/6] xe: sync small-bar uapi Matthew Auld
2023-07-14 14:42 ` [igt-dev] [PATCH i-g-t v3 2/6] lib/xe: add visible vram helpers Matthew Auld
2023-07-14 16:30 ` Souza, Jose
2023-07-14 16:34 ` Souza, Jose
2023-07-14 16:55 ` Matthew Auld
2023-07-14 17:03 ` Souza, Jose
2023-07-14 14:42 ` [igt-dev] [PATCH i-g-t v3 3/6] lib/xe: handle small-bar systems Matthew Auld
2023-07-14 14:42 ` [igt-dev] [PATCH i-g-t v3 4/6] tests/xe: " Matthew Auld
2023-07-14 17:02 ` Souza, Jose [this message]
2023-07-15 21:20 ` Souza, Jose
2023-07-14 14:42 ` [igt-dev] [PATCH i-g-t v3 5/6] tests/xe/query: extend for CPU visible accounting Matthew Auld
2023-07-14 14:42 ` [igt-dev] [PATCH i-g-t v3 6/6] tests/xe/mmap: sanity check small-bar Matthew Auld
2023-07-14 15:55 ` [igt-dev] ✓ Fi.CI.BAT: success for IGT bits for small-bar (rev5) Patchwork
2023-07-14 16:27 ` [igt-dev] ○ CI.xeBAT: info " Patchwork
2023-07-14 17:30 ` [igt-dev] ✓ Fi.CI.IGT: success " Patchwork
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=fa7f7577e26a1027a2e17db9d0912ab457be14cf.camel@intel.com \
--to=jose.souza@intel.com \
--cc=igt-dev@lists.freedesktop.org \
--cc=matthew.auld@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox