IGT bits for small-bar

We need a couple new fields for the region query and the new flag to ensure the buffer is CPU accessible.

Signed-off-by Matthew Auld <[email protected]>

Cc Gwan-gyeong Mun <[email protected]>

---
  include/drm-uapi/xe_drm.h | 5 ++++-
  1 file changed, 4 insertions(+), 1 deletion(-)

include/drm-uapi/xe_drm.h +4 -1

index 593b01ba..441b377b 100644
@@ -169,7 +169,9 @@ struct drm_xe_query_mem_usage {
  		__u32 max_page_size;
  		__u64 total_size;
  		__u64 used;
-		__u64 reserved[8];
+		__u64 cpu_visible_size;
+		__u64 cpu_visible_used;
+		__u64 reserved[6];
  	} regions[];
  };
 

@@ -270,6 +272,7 @@ struct drm_xe_gem_create {
  	 */
  #define XE_GEM_CREATE_FLAG_DEFER_BACKING	(0x1 << 24)
  #define XE_GEM_CREATE_FLAG_SCANOUT		(0x1 << 25)
+#define XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM	(0x1 << 26)
  	__u32 flags;
 
  	/**

Add helpers for object creation and querying the cpu_visible related bits.

Signed-off-by Matthew Auld <[email protected]>

Cc Gwan-gyeong Mun <[email protected]>

---
  lib/xe/xe_query.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++-
  lib/xe/xe_query.h |  6 +++++
  2 files changed, 74 insertions(+), 1 deletion(-)

lib/xe/xe_query.c +37 -1

index f281bc4a..48a413cd 100644
@@ -140,6 +140,17 @@ static uint64_t gt_vram_size(const struct drm_xe_query_mem_usage *mem_usage,
  	return 0;
  }
 
+static uint64_t gt_visible_vram_size(const struct drm_xe_query_mem_usage *mem_usage,
+				     const struct drm_xe_query_gts *gts, int gt)
+{
+	int region_idx = ffs(native_region_for_gt(gts, gt)) - 1;
+
+	if (XE_IS_CLASS_VRAM(&mem_usage->regions[region_idx]))
+		return mem_usage->regions[region_idx].cpu_visible_size;
+
+	return 0;
+}
+
  static bool __mem_has_vram(struct drm_xe_query_mem_usage *mem_usage)
  {
  	for (int i = 0; i < mem_usage->num_regions; i++)

@@ -246,9 +257,14 @@ struct xe_device *xe_device_get(int fd)
  	xe_dev->hw_engines = xe_query_engines_new(fd, &xe_dev->number_hw_engines);
  	xe_dev->mem_usage = xe_query_mem_usage_new(fd);
  	xe_dev->vram_size = calloc(xe_dev->number_gt, sizeof(*xe_dev->vram_size));
-	for (int gt = 0; gt < xe_dev->number_gt; gt++)
+	xe_dev->visible_vram_size = calloc(xe_dev->number_gt, sizeof(*xe_dev->visible_vram_size));
+	for (int gt = 0; gt < xe_dev->number_gt; gt++) {
  		xe_dev->vram_size[gt] = gt_vram_size(xe_dev->mem_usage,
  						     xe_dev->gts, gt);
+		xe_dev->visible_vram_size[gt] =
+			gt_visible_vram_size(xe_dev->mem_usage,
+					     xe_dev->gts, gt);
+	}
  	xe_dev->default_alignment = __mem_default_alignment(xe_dev->mem_usage);
  	xe_dev->has_vram = __mem_has_vram(xe_dev->mem_usage);
 

@@ -383,6 +399,20 @@ uint64_t vram_memory(int fd, int gt)
  	return native_region_for_gt(xe_dev->gts, gt);
  }
 
+/**
+ * visible_vram_memory:
+ * @fd: xe device fd
+ * @gt: gt id
+ *
+ * Returns vram memory bitmask for xe device @fd and @gt id, with
+ * XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM also set, to ensure that CPU access is
+ * possible.
+ */
+uint64_t visible_vram_memory(int fd, int gt)
+{
+	return vram_memory(fd, gt) | XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM;
+}
+
  /**
   * vram_if_possible:
   * @fd: xe device fd

@@ -400,6 +430,25 @@ uint64_t vram_if_possible(int fd, int gt)
  	return vram ? vram : system_memory;
  }
 
+/**
+ * visible_vram_if_possible:
+ * @fd: xe device fd
+ * @gt: gt id
+ *
+ * Returns vram memory bitmask for xe device @fd and @gt id or system memory if

lib/xe/xe_query.c +21 -0

+	return vram ? vram | XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM : system_memory;
+}
+
  /**
   * xe_hw_engines:
   * @fd: xe device fd

@@ -459,6 +508,23 @@ uint64_t xe_vram_size(int fd, int gt)
  	return xe_dev->vram_size[gt];
  }
 
+/**
+ * xe_visible_vram_size:
+ * @fd: xe device fd
+ * @gt: gt
+ *
+ * Returns size of visible vram of xe device @fd.
+ */
+uint64_t xe_visible_vram_size(int fd, int gt)
+{
+	struct xe_device *xe_dev;
+
+	xe_dev = find_in_cache(fd);
+	igt_assert(xe_dev);
+
+	return xe_dev->visible_vram_size[gt];
+}
+
  /**
   * xe_get_default_alignment:
   * @fd: xe device fd

@@ -475,6 +541,7 @@ xe_dev_FN(xe_get_default_alignment, default_alignment, uint32_t);
   */
  xe_dev_FN(xe_va_bits, va_bits, uint32_t);
 
+
  /**
   * xe_dev_id:
   * @fd: xe device fd

lib/xe/xe_query.h +6 -0

index 3a00ecd1..5aa5b402 100644
@@ -47,6 +47,9 @@ struct xe_device {
  	/** @vram_size: array of vram sizes for all gts */
  	uint64_t *vram_size;
 
+	/** @visible_vram_size: array of visible vram sizes for all gts */
+	uint64_t *visible_vram_size;
+
  	/** @default_alignment: safe alignment regardless region location */
  	uint32_t default_alignment;
 

@@ -76,13 +79,16 @@ unsigned int xe_number_gt(int fd);
  uint64_t all_memory_regions(int fd);
  uint64_t system_memory(int fd);
  uint64_t vram_memory(int fd, int gt);
+uint64_t visible_vram_memory(int fd, int gt);
  uint64_t vram_if_possible(int fd, int gt);
+uint64_t visible_vram_if_possible(int fd, int gt);
  struct drm_xe_engine_class_instance *xe_hw_engines(int fd);
  struct drm_xe_engine_class_instance *xe_hw_engine(int fd, int idx);
  unsigned int xe_number_hw_engines(int fd);
  bool xe_has_vram(int fd);
  //uint64_t xe_vram_size(int fd);
  uint64_t xe_vram_size(int fd, int gt);
+uint64_t xe_visible_vram_size(int fd, int gt);
  uint32_t xe_get_default_alignment(int fd);
  uint32_t xe_va_bits(int fd);
  uint16_t xe_dev_id(int fd);

Quoted 84 lines · Matthew Auld

Add helpers for object creation and querying the cpu_visible related bits.

Signed-off-by Matthew Auld <[email protected]>

Cc Gwan-gyeong Mun <[email protected]>

---
  lib/xe/xe_query.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++- lib/xe/xe_query.h |  6 +++++

  2 files changed, 74 insertions(+), 1 deletion(-)

lib/xe/xe_query.c +11 -0

index f281bc4a..48a413cd 100644
@@ -140,6 +140,17 @@ static uint64_t gt_vram_size(const struct 
 drm_xe_query_mem_usage *mem_usage,
       return 0;
   }
+static uint64_t gt_visible_vram_size(const struct 
 drm_xe_query_mem_usage *mem_usage,
+                     const struct drm_xe_query_gts *gts, int gt)
+{
+    int region_idx = ffs(native_region_for_gt(gts, gt)) - 1;
+
+    if (XE_IS_CLASS_VRAM(&mem_usage->regions[region_idx]))
+        return mem_usage->regions[region_idx].cpu_visible_size;
+
+    return 0;
+}
+
   static bool __mem_has_vram(struct drm_xe_query_mem_usage *mem_usage)
   {

      for (int i = 0; i < mem_usage->num_regions; i++)

lib/xe/xe_query.c +13 -1

@@ -246,9 +257,14 @@ struct xe_device *xe_device_get(int fd)
       xe_dev->hw_engines = xe_query_engines_new(fd, &xe_dev->number_hw_engines);
       xe_dev->mem_usage = xe_query_mem_usage_new(fd);
       xe_dev->vram_size = calloc(xe_dev->number_gt, sizeof(*xe_dev->vram_size));
-    for (int gt = 0; gt < xe_dev->number_gt; gt++)
+    xe_dev->visible_vram_size = calloc(xe_dev->number_gt, 
 sizeof(*xe_dev->visible_vram_size));
+    for (int gt = 0; gt < xe_dev->number_gt; gt++) {
           xe_dev->vram_size[gt] = gt_vram_size(xe_dev->mem_usage,
                                xe_dev->gts, gt);
+        xe_dev->visible_vram_size[gt] =
+            gt_visible_vram_size(xe_dev->mem_usage,
+                         xe_dev->gts, gt);
+    }
       xe_dev->default_alignment = __mem_default_alignment(xe_dev->mem_usage);
       xe_dev->has_vram = __mem_has_vram(xe_dev->mem_usage);

@@ -383,6 +399,20 @@ uint64_t vram_memory(int fd, int gt)
       return native_region_for_gt(xe_dev->gts, gt);
   }
+/**
+ * visible_vram_memory:
+ * @fd: xe device fd
+ * @gt: gt id
+ *
+ * Returns vram memory bitmask for xe device @fd and @gt id, with
+ * XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM also set, to ensure that CPU 

access is
+ * possible.
+ */

lib/xe/xe_query.c +5 -0

+uint64_t visible_vram_memory(int fd, int gt)
+{
+    return vram_memory(fd, gt) | XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM;
+}
+

  /**
   * vram_if_possible:
   * @fd: xe device fd

lib/xe/xe_query.c +6 -0

@@ -400,6 +430,25 @@ uint64_t vram_if_possible(int fd, int gt)
       return vram ? vram : system_memory;
   }
+/**
+ * visible_vram_if_possible:
+ * @fd: xe device fd
+ * @gt: gt id
+ *
+ * Returns vram memory bitmask for xe device @fd and @gt id or system 

memory if
+ * there's no vram memory available for @gt. Also attaches the
+ * XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM to ensure that CPU access is possible
+ * when using vram.
+ */

lib/xe/xe_query.c uint64_t vram_if_possible(int fd, int gt) · line 448

Quoted 6 lines

lib/xe/xe_query.c +6 -0

+uint64_t visible_vram_if_possible(int fd, int gt)
+{
+    uint64_t regions = all_memory_regions(fd);
+    uint64_t system_memory = regions & 0x1;
+    uint64_t vram = regions & (0x2 << gt);
+

Hi Matt,

vram_if_possible() uses as the below check routine for vram

uint64_t vram = regions & (~0x1);

but, here uses

uint64_t vram = regions & (0x2 << gt);

Why do you use a different check method than the vram_if_possible()?

Other than that, the rest looks good.

Br,
G.G.

Quoted 67 lines

+    return vram ? vram | XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM :
system_memory;

lib/xe/xe_query.c +2 -0

+}
+

  /**
   * xe_hw_engines:
   * @fd: xe device fd

lib/xe/xe_query.c +18 -0

@@ -459,6 +508,23 @@ uint64_t xe_vram_size(int fd, int gt)
       return xe_dev->vram_size[gt];
   }
+/**
+ * xe_visible_vram_size:
+ * @fd: xe device fd
+ * @gt: gt
+ *
+ * Returns size of visible vram of xe device @fd.
+ */
+uint64_t xe_visible_vram_size(int fd, int gt)
+{
+    struct xe_device *xe_dev;
+
+    xe_dev = find_in_cache(fd);
+    igt_assert(xe_dev);
+
+    return xe_dev->visible_vram_size[gt];
+}
+
   /**
    * xe_get_default_alignment:
    * @fd: xe device fd

@@ -475,6 +541,7 @@ xe_dev_FN(xe_get_default_alignment, 
 default_alignment, uint32_t);
    */
   xe_dev_FN(xe_va_bits, va_bits, uint32_t);
+
   /**
    * xe_dev_id:
    * @fd: xe device fd

lib/xe/xe_query.h +6 -0

index 3a00ecd1..5aa5b402 100644
@@ -47,6 +47,9 @@ struct xe_device {
       /** @vram_size: array of vram sizes for all gts */
       uint64_t *vram_size;
+    /** @visible_vram_size: array of visible vram sizes for all gts */
+    uint64_t *visible_vram_size;
+
       /** @default_alignment: safe alignment regardless region location */
       uint32_t default_alignment;

@@ -76,13 +79,16 @@ unsigned int xe_number_gt(int fd);
   uint64_t all_memory_regions(int fd);
   uint64_t system_memory(int fd);
   uint64_t vram_memory(int fd, int gt);
+uint64_t visible_vram_memory(int fd, int gt);
   uint64_t vram_if_possible(int fd, int gt);
+uint64_t visible_vram_if_possible(int fd, int gt);
   struct drm_xe_engine_class_instance *xe_hw_engines(int fd);
   struct drm_xe_engine_class_instance *xe_hw_engine(int fd, int idx);
   unsigned int xe_number_hw_engines(int fd);
   bool xe_has_vram(int fd);
   //uint64_t xe_vram_size(int fd);
   uint64_t xe_vram_size(int fd, int gt);
+uint64_t xe_visible_vram_size(int fd, int gt);
   uint32_t xe_get_default_alignment(int fd);
   uint32_t xe_va_bits(int fd);
   uint16_t xe_dev_id(int fd);

Quoted 99 lines · Gwan-gyeong Mun

Quoted 84 lines · Matthew Auld

Add helpers for object creation and querying the cpu_visible related bits.

Signed-off-by Matthew Auld <[email protected]>

Cc Gwan-gyeong Mun <[email protected]>

---
  lib/xe/xe_query.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++- lib/xe/xe_query.h |  6 +++++

  2 files changed, 74 insertions(+), 1 deletion(-)

lib/xe/xe_query.c +11 -0

index f281bc4a..48a413cd 100644
@@ -140,6 +140,17 @@ static uint64_t gt_vram_size(const struct 
 drm_xe_query_mem_usage *mem_usage,
       return 0;
   }
+static uint64_t gt_visible_vram_size(const struct 
 drm_xe_query_mem_usage *mem_usage,
+                     const struct drm_xe_query_gts *gts, int gt)
+{
+    int region_idx = ffs(native_region_for_gt(gts, gt)) - 1;
+
+    if (XE_IS_CLASS_VRAM(&mem_usage->regions[region_idx]))
+        return mem_usage->regions[region_idx].cpu_visible_size;
+
+    return 0;
+}
+
   static bool __mem_has_vram(struct drm_xe_query_mem_usage *mem_usage)
   {

      for (int i = 0; i < mem_usage->num_regions; i++)

lib/xe/xe_query.c +13 -1

@@ -246,9 +257,14 @@ struct xe_device *xe_device_get(int fd)
       xe_dev->hw_engines = xe_query_engines_new(fd, &xe_dev->number_hw_engines);
       xe_dev->mem_usage = xe_query_mem_usage_new(fd);
       xe_dev->vram_size = calloc(xe_dev->number_gt, sizeof(*xe_dev->vram_size));
-    for (int gt = 0; gt < xe_dev->number_gt; gt++)
+    xe_dev->visible_vram_size = calloc(xe_dev->number_gt, 
 sizeof(*xe_dev->visible_vram_size));
+    for (int gt = 0; gt < xe_dev->number_gt; gt++) {
           xe_dev->vram_size[gt] = gt_vram_size(xe_dev->mem_usage,
                                xe_dev->gts, gt);
+        xe_dev->visible_vram_size[gt] =
+            gt_visible_vram_size(xe_dev->mem_usage,
+                         xe_dev->gts, gt);
+    }
       xe_dev->default_alignment = __mem_default_alignment(xe_dev->mem_usage);
       xe_dev->has_vram = __mem_has_vram(xe_dev->mem_usage);

@@ -383,6 +399,20 @@ uint64_t vram_memory(int fd, int gt)
       return native_region_for_gt(xe_dev->gts, gt);
   }
+/**
+ * visible_vram_memory:
+ * @fd: xe device fd
+ * @gt: gt id
+ *
+ * Returns vram memory bitmask for xe device @fd and @gt id, with
+ * XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM also set, to ensure that 

CPU access is
+ * possible.
+ */

lib/xe/xe_query.c +5 -0

+uint64_t visible_vram_memory(int fd, int gt)
+{
+    return vram_memory(fd, gt) | XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM;
+}
+

  /**
   * vram_if_possible:
   * @fd: xe device fd

lib/xe/xe_query.c +6 -0

@@ -400,6 +430,25 @@ uint64_t vram_if_possible(int fd, int gt)
       return vram ? vram : system_memory;
   }
+/**
+ * visible_vram_if_possible:
+ * @fd: xe device fd
+ * @gt: gt id
+ *
+ * Returns vram memory bitmask for xe device @fd and @gt id or 

system memory if
+ * there's no vram memory available for @gt. Also attaches the
+ * XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM to ensure that CPU access is possible
+ * when using vram.
+ */

lib/xe/xe_query.c uint64_t vram_if_possible(int fd, int gt) · line 448

Quoted 6 lines

lib/xe/xe_query.c +6 -0

+uint64_t visible_vram_if_possible(int fd, int gt)
+{
+    uint64_t regions = all_memory_regions(fd);
+    uint64_t system_memory = regions & 0x1;
+    uint64_t vram = regions & (0x2 << gt);
+

Hi Matt,

vram_if_possible() uses as the below check routine for vram

uint64_t vram = regions & (~0x1);

Quoted 5 lines

but, here uses

uint64_t vram = regions & (0x2 << gt);

Why do you use a different check method than the vram_if_possible()?

I assume it was just copy-pasted from an earlier version of vram_if_possible(). Although I don't quite get why it wants to use (~0x1) here, if we are passing in the GT...

Quoted 72 lines

Other than that, the rest looks good.

Br,
G.G.

Quoted 67 lines

+    return vram ? vram | XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM :
system_memory;

lib/xe/xe_query.c +2 -0

+}
+

  /**
   * xe_hw_engines:
   * @fd: xe device fd

lib/xe/xe_query.c +18 -0

@@ -459,6 +508,23 @@ uint64_t xe_vram_size(int fd, int gt)
       return xe_dev->vram_size[gt];
   }
+/**
+ * xe_visible_vram_size:
+ * @fd: xe device fd
+ * @gt: gt
+ *
+ * Returns size of visible vram of xe device @fd.
+ */
+uint64_t xe_visible_vram_size(int fd, int gt)
+{
+    struct xe_device *xe_dev;
+
+    xe_dev = find_in_cache(fd);
+    igt_assert(xe_dev);
+
+    return xe_dev->visible_vram_size[gt];
+}
+
   /**
    * xe_get_default_alignment:
    * @fd: xe device fd

@@ -475,6 +541,7 @@ xe_dev_FN(xe_get_default_alignment, 
 default_alignment, uint32_t);
    */
   xe_dev_FN(xe_va_bits, va_bits, uint32_t);
+
   /**
    * xe_dev_id:
    * @fd: xe device fd

lib/xe/xe_query.h +6 -0

index 3a00ecd1..5aa5b402 100644
@@ -47,6 +47,9 @@ struct xe_device {
       /** @vram_size: array of vram sizes for all gts */
       uint64_t *vram_size;
+    /** @visible_vram_size: array of visible vram sizes for all gts */
+    uint64_t *visible_vram_size;
+
       /** @default_alignment: safe alignment regardless region location */
       uint32_t default_alignment;

@@ -76,13 +79,16 @@ unsigned int xe_number_gt(int fd);
   uint64_t all_memory_regions(int fd);
   uint64_t system_memory(int fd);
   uint64_t vram_memory(int fd, int gt);
+uint64_t visible_vram_memory(int fd, int gt);
   uint64_t vram_if_possible(int fd, int gt);
+uint64_t visible_vram_if_possible(int fd, int gt);
   struct drm_xe_engine_class_instance *xe_hw_engines(int fd);
   struct drm_xe_engine_class_instance *xe_hw_engine(int fd, int idx);
   unsigned int xe_number_hw_engines(int fd);
   bool xe_has_vram(int fd);
   //uint64_t xe_vram_size(int fd);
   uint64_t xe_vram_size(int fd, int gt);
+uint64_t xe_visible_vram_size(int fd, int gt);
   uint32_t xe_get_default_alignment(int fd);
   uint32_t xe_va_bits(int fd);
   uint16_t xe_dev_id(int fd);

Convert all the existing tests that require CPU access.

Signed-off-by Matthew Auld <[email protected]>

Cc Gwan-gyeong Mun <[email protected]>

---
  lib/xe/xe_spin.c                |  3 ++-
  tests/xe/xe_dma_buf_sync.c      |  3 ++-
  tests/xe/xe_evict.c             | 32 +++++++++++++++++++-------------
  tests/xe/xe_exec_balancer.c     |  6 +++---
  tests/xe/xe_exec_basic.c        | 19 ++++++++++---------
  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_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                | 21 ++++++++++++++-------
  14 files changed, 84 insertions(+), 56 deletions(-)

lib/xe/xe_spin.c +2 -1

index 856d0ba2..3266905c 100644
@@ -100,7 +100,8 @@ void xe_cork_init(int fd, struct drm_xe_engine_class_instance *hwe,
 
  	vm = xe_vm_create(fd, 0, 0);
 
-	bo = xe_bo_create(fd, hwe->gt_id, vm, bo_size);
+	bo = xe_bo_create_flags(fd, vm, bo_size,
+				visible_vram_if_possible(fd, hwe->gt_id));
  	spin = xe_bo_map(fd, bo, 0x1000);
 
  	xe_vm_bind_sync(fd, vm, bo, 0, addr, bo_size);

tests/xe/xe_dma_buf_sync.c +2 -1

index 8b97480a..3b4ee6bb 100644
@@ -122,7 +122,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]);
 

tests/xe/xe_evict.c +14 -11

index eddbbd6f..26ed63de 100644
@@ -98,15 +98,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 {

@@ -281,16 +283,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) |
-								  system_memory(fd));
+								  visible_vram_memory(fd, eci->gt_id));
  			}
  		} else {
  			__bo = bo[i % (n_execs / 2)];

tests/xe/xe_evict.c +1 -1

  /**

@@ -670,7 +676,7 @@ igt_main
  		fd = drm_open_driver(DRIVER_XE);
  		xe_device_get(fd);
  		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)

tests/xe/xe_exec_balancer.c +3 -3

index f3341a99..766e834c 100644
@@ -70,7 +70,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++) {

@@ -229,7 +229,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);
  	}
 

@@ -454,7 +454,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);

tests/xe/xe_exec_basic.c +10 -9

index 2a3cebd3..5e09e4a0 100644
@@ -129,15 +129,16 @@ 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 = 0;
+		if (bo_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,
+					visible_vram_if_possible(fd, eci->gt_id) |
+					bo_flags);
  		if (!(flags & DEFER_BIND))
  			data = xe_bo_map(fd, bo, bo_size);
  	}

tests/xe/xe_exec_compute_mode.c +2 -2

index 60713a95..b06acd9b 100644
@@ -152,8 +152,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);

tests/xe/xe_exec_fault_mode.c +8 -4

index b5d924a3..95eacfd5 100644
@@ -157,9 +157,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);

@@ -390,8 +392,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;

tests/xe/xe_exec_reset.c +8 -5

index 57dc90dd..d171b3b3 100644
@@ -51,7 +51,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);

@@ -197,7 +198,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++) {

@@ -398,7 +399,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++) {

@@ -577,7 +579,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);
 

@@ -710,7 +713,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;
 

tests/xe/xe_exec_threads.c +6 -3

index c34d8aec..1d7534e5 100644
@@ -107,7 +107,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);

@@ -309,7 +310,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);

@@ -517,7 +519,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);

tests/xe/xe_guc_pc.c +2 -1

index 60c93288..bf304bd7 100644
@@ -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++) {

tests/xe/xe_mmap.c +2 -2

index 6b313a18..b23ce10c 100644
@@ -70,10 +70,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_fixture {
  		xe_device_put(fd);

tests/xe/xe_pm.c +2 -1

index 23b8246e..b3f47355 100644
@@ -250,7 +250,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++) {

tests/xe/xe_prime_self_import.c +4 -4

index 5710cff9..97e330db 100644
@@ -107,7 +107,7 @@ static void test_with_fd_dup(void)
  	fd2 = drm_open_driver(DRIVER_XE);
  	xe_device_get(fd2);
 
-	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);

@@ -146,8 +146,8 @@ static void test_with_two_bos(void)
  	fd2 = drm_open_driver(DRIVER_XE);
  	xe_device_get(fd2);
 
-	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);

@@ -225,7 +225,7 @@ static void test_with_one_bo(void)
  	fd2 = drm_open_driver(DRIVER_XE);
  	xe_device_get(fd2);
 
-	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);

tests/xe/xe_vm.c +14 -7

index 15356c70..96b12f60 100644
@@ -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);
 

@@ -549,7 +550,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, 0, vm, bo_size);
+		bo[i] = xe_bo_create_flags(fd, vm, bo_size,
+					   visible_vram_if_possible(fd, 0));
  		data[i] = xe_bo_map(fd, bo[i], bo_size);
  	}
 

@@ -717,7 +719,7 @@ 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, 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);
 
  	for (i = 0; i < N_ENGINES; i++) {

@@ -874,7 +876,7 @@ 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, 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);
 
  	if (flags & BIND_ARRAY_BIND_ENGINE_FLAG)

@@ -1052,7 +1054,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, 0, vm, bo_size);
+		igt_skip_on(xe_visible_vram_size(fd, 0) && bo_size >
+			    xe_visible_vram_size(fd, 0));
+
+		bo = xe_bo_create_flags(fd, vm, bo_size,
+					visible_vram_if_possible(fd, 0));
  		map = xe_bo_map(fd, bo, bo_size);
  	}
 

@@ -1329,7 +1335,8 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
  			    MAP_ANONYMOUS, -1, 0);
  		igt_assert(data != MAP_FAILED);
  	} else {
-		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);

Convert all the existing tests that require CPU access.

Signed-off-by Matthew Auld <[email protected]>

Cc Gwan-gyeong Mun <[email protected]>

---
 lib/xe/xe_spin.c                |  3 ++-

 tests/xe/xe_dma_buf_sync.c      |  3 ++-
 tests/xe/xe_evict.c             | 32 +++++++++++++++++++-------------
 tests/xe/xe_exec_balancer.c     |  6 +++---
 tests/xe/xe_exec_basic.c        | 19 ++++++++++---------
 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_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                | 21 ++++++++++++++-------
 14 files changed, 84 insertions(+), 56 deletions(-)

lib/xe/xe_spin.c +2 -1

index 856d0ba2..3266905c 100644
@@ -100,7 +100,8 @@ void xe_cork_init(int fd, struct drm_xe_engine_class_instance *hwe,
 
 	vm = xe_vm_create(fd, 0, 0);
 
-	bo = xe_bo_create(fd, hwe->gt_id, vm, bo_size);
+	bo = xe_bo_create_flags(fd, vm, bo_size,
+				visible_vram_if_possible(fd, hwe->gt_id));
 	spin = xe_bo_map(fd, bo, 0x1000);
 
 	xe_vm_bind_sync(fd, vm, bo, 0, addr, bo_size);

tests/xe/xe_dma_buf_sync.c +2 -1

index 8b97480a..3b4ee6bb 100644
@@ -122,7 +122,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]);
 

tests/xe/xe_evict.c +14 -11

index eddbbd6f..26ed63de 100644
@@ -98,15 +98,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 {

@@ -281,16 +283,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) |
-								  system_memory(fd));
+								  visible_vram_memory(fd, eci->gt_id));
 			}
 		} else {
 			__bo = bo[i % (n_execs / 2)];

tests/xe/xe_evict.c +1 -1

 }
 
 /**

@@ -670,7 +676,7 @@ igt_main
 		fd = drm_open_driver(DRIVER_XE);
 		xe_device_get(fd);
 		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)

tests/xe/xe_exec_balancer.c +3 -3

index f3341a99..766e834c 100644
@@ -70,7 +70,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++) {

@@ -229,7 +229,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);
 	}
 

@@ -454,7 +454,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);

tests/xe/xe_exec_basic.c +0 -0

index 2a3cebd3..5e09e4a0 100644

tests/xe/xe_exec_basic.c +1 -0

+					bo_flags);
 		if (!(flags & DEFER_BIND))
 			data = xe_bo_map(fd, bo, bo_size);
 	}

tests/xe/xe_exec_compute_mode.c +2 -2

index 60713a95..b06acd9b 100644
@@ -152,8 +152,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);

tests/xe/xe_exec_fault_mode.c +8 -4

index b5d924a3..95eacfd5 100644
@@ -157,9 +157,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);

@@ -390,8 +392,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;

tests/xe/xe_exec_reset.c +8 -5

index 57dc90dd..d171b3b3 100644
@@ -51,7 +51,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);

@@ -197,7 +198,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++) {

@@ -398,7 +399,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++) {

@@ -577,7 +579,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);
 

@@ -710,7 +713,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;
 

tests/xe/xe_exec_threads.c +6 -3

index c34d8aec..1d7534e5 100644
@@ -107,7 +107,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);

@@ -309,7 +310,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);

@@ -517,7 +519,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);

tests/xe/xe_guc_pc.c +2 -1

index 60c93288..bf304bd7 100644
@@ -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++) {

tests/xe/xe_mmap.c +2 -2

index 6b313a18..b23ce10c 100644
@@ -70,10 +70,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_fixture {
 		xe_device_put(fd);

tests/xe/xe_pm.c +2 -1

index 23b8246e..b3f47355 100644
@@ -250,7 +250,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++) {

tests/xe/xe_prime_self_import.c +4 -4

index 5710cff9..97e330db 100644
@@ -107,7 +107,7 @@ static void test_with_fd_dup(void)
 	fd2 = drm_open_driver(DRIVER_XE);
 	xe_device_get(fd2);
 
-	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);

@@ -146,8 +146,8 @@ static void test_with_two_bos(void)
 	fd2 = drm_open_driver(DRIVER_XE);
 	xe_device_get(fd2);
 
-	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);

@@ -225,7 +225,7 @@ static void test_with_one_bo(void)
 	fd2 = drm_open_driver(DRIVER_XE);
 	xe_device_get(fd2);
 
-	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);

tests/xe/xe_vm.c +14 -7

index 15356c70..96b12f60 100644
@@ -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);
 

@@ -549,7 +550,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, 0, vm, bo_size);
+		bo[i] = xe_bo_create_flags(fd, vm, bo_size,
+					   visible_vram_if_possible(fd, 0));
 		data[i] = xe_bo_map(fd, bo[i], bo_size);
 	}
 

@@ -717,7 +719,7 @@ 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, 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);
 
 	for (i = 0; i < N_ENGINES; i++) {

@@ -874,7 +876,7 @@ 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, 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);
 
 	if (flags & BIND_ARRAY_BIND_ENGINE_FLAG)

@@ -1052,7 +1054,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, 0, vm, bo_size);
+		igt_skip_on(xe_visible_vram_size(fd, 0) && bo_size >
+			    xe_visible_vram_size(fd, 0));
+
+		bo = xe_bo_create_flags(fd, vm, bo_size,
+					visible_vram_if_possible(fd, 0));
 		map = xe_bo_map(fd, bo, bo_size);
 	}
 

@@ -1329,7 +1335,8 @@ test_munmap_style_unbind(int fd, struct drm_xe_engine_class_instance *eci,
 			    MAP_ANONYMOUS, -1, 0);
 		igt_assert(data != MAP_FAILED);
 	} else {
-		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);

Signature · 1 line

2.39.2

Print the visible size and how much is used. Also sanity check the values.

Signed-off-by Matthew Auld <[email protected]>

Cc Gwan-gyeong Mun <[email protected]>

---
  tests/xe/xe_query.c | 15 +++++++++++++++
  1 file changed, 15 insertions(+)

tests/xe/xe_query.c +5 -0

index 3f038225..9367d65e 100644
@@ -228,6 +228,21 @@ test_query_mem_usage(int fd)
  		igt_info("min_page_size=0x%x, max_page_size=0x%x\n",
  		       mem_usage->regions[i].min_page_size,
  		       mem_usage->regions[i].max_page_size);
+
+		igt_info("visible size=%lluMiB\n",
+			 mem_usage->regions[i].cpu_visible_size >> 20);
+		igt_info("visible used=%lluMiB\n",
+			 mem_usage->regions[i].cpu_visible_used >> 20);

tests/xe/xe_query.c +0 -0

  	}
  	dump_hex_debug(mem_usage, query.size);
  	free(mem_usage);