Skip to contentSkip to conversation

Some small-bar prep patches

PATCH Superseded Matthew Auld 3 participants 14 messages Mar 8, 2023 – Mar 20, 2023

Subsystems (2)

v2 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

v2 cover Some small-bar prep patches

Split from the small-bar series. Plus one extra patch to fix the overloaded meaning behind xe_ttm_stolen_cpu_inaccessible(), as pointed out by Maarten.

v2: Apply s/lmem/vram/ for the entire driver

Signature · 1 line
2.39.2
#1 lore raw

PATCH v2 1/6 drm/xe: add xe_ttm_stolen_cpu_access_needs_ggtt()

xe_ttm_stolen_cpu_inaccessible() was originally meant to just cover the case where stolen is not directly CPU accessible on some older integrated platforms, and as such a GGTT mapping was also required for CPU access (as per the check in xe_bo_create_pin_map_at()).

However with small-bar systems on dgfx we have one more case where stolen is also inaccessible, however here we don't have any fallback GGTT mode for CPU access. Fix the check in xe_bo_create_pin_map_at() to make this distinction clear. In such a case the later vmap() will fail anyway.

v2: fix kernel-doc warning

---
 drivers/gpu/drm/xe/xe_bo.c             |  2 +-
 drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c | 14 ++++++++++++++
 drivers/gpu/drm/xe/xe_ttm_stolen_mgr.h |  1 +
 3 files changed, 16 insertions(+), 1 deletion(-)
drivers/gpu/drm/xe/xe_bo.c +1 -1
index 2bfd3f6f2e9a..876f77669104 100644
@@ -1151,7 +1151,7 @@ struct xe_bo *xe_bo_create_pin_map_at(struct xe_device *xe, struct xe_gt *gt,
 	u64 end = offset == ~0ull ? offset : start + size;
 
 	if (flags & XE_BO_CREATE_STOLEN_BIT &&
-	    xe_ttm_stolen_cpu_inaccessible(xe))
+	    xe_ttm_stolen_cpu_access_needs_ggtt(xe))
 		flags |= XE_BO_CREATE_GGTT_BIT;
 
 	bo = xe_bo_create_locked_range(xe, gt, vm, size, start, end, type, flags);
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +14 -0
index 2e8d07ad42ae..e608b49072ba 100644
@@ -66,6 +66,20 @@ bool xe_ttm_stolen_cpu_inaccessible(struct xe_device *xe)
 	return !mgr->io_base || GRAPHICS_VERx100(xe) < 1270;
 }
 
+/**
+ * xe_ttm_stolen_cpu_access_needs_ggtt - If we can't directly CPU access stolen,
+ * can we then fallback to mapping through the GGTT.
+ * @xe: xe device
+ *
+ * Some older integrated platforms don't support reliable CPU access for stolen,
+ * however on such hardware we can always use the mappable part of the GGTT for
+ * CPU access. Check if that's the case for this device.
+ */
+bool xe_ttm_stolen_cpu_access_needs_ggtt(struct xe_device *xe)
+{
+	return xe_ttm_stolen_cpu_inaccessible(xe) && !IS_DGFX(xe);
+}
+
 static s64 detect_bar2_dgfx(struct xe_device *xe, struct xe_ttm_stolen_mgr *mgr)
 {
 	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.h +1 -0
index 2fda97b97a05..e210dada636e 100644
@@ -15,6 +15,7 @@ struct xe_device;
 void xe_ttm_stolen_mgr_init(struct xe_device *xe);
 int xe_ttm_stolen_io_mem_reserve(struct xe_device *xe, struct ttm_resource *mem);
 bool xe_ttm_stolen_cpu_inaccessible(struct xe_device *xe);
+bool xe_ttm_stolen_cpu_access_needs_ggtt(struct xe_device *xe);
 u64 xe_ttm_stolen_io_offset(struct xe_bo *bo, u32 offset);
 u64 xe_ttm_stolen_gpu_offset(struct xe_device *xe);
 
Signature · 1 line
2.39.2
#2 lore raw

Re: [Intel-xe] [PATCH v2 1/6] drm/xe: add xe_ttm_stolen_cpu_access_needs_ggtt()

Quoted 50 lines · Matthew Auld

xe_ttm_stolen_cpu_inaccessible() was originally meant to just cover the case where stolen is not directly CPU accessible on some older integrated platforms, and as such a GGTT mapping was also required for CPU access (as per the check in xe_bo_create_pin_map_at()).

However with small-bar systems on dgfx we have one more case where stolen is also inaccessible, however here we don't have any fallback GGTT mode for CPU access. Fix the check in xe_bo_create_pin_map_at() to make this distinction clear. In such a case the later vmap() will fail anyway.

v2: fix kernel-doc warning

---
  drivers/gpu/drm/xe/xe_bo.c             |  2 +-
  drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c | 14 ++++++++++++++
  drivers/gpu/drm/xe/xe_ttm_stolen_mgr.h |  1 +
  3 files changed, 16 insertions(+), 1 deletion(-)
drivers/gpu/drm/xe/xe_bo.c +1 -1
index 2bfd3f6f2e9a..876f77669104 100644
@@ -1151,7 +1151,7 @@ struct xe_bo *xe_bo_create_pin_map_at(struct xe_device *xe, struct xe_gt *gt,
  	u64 end = offset == ~0ull ? offset : start + size;
 
  	if (flags & XE_BO_CREATE_STOLEN_BIT &&
-	    xe_ttm_stolen_cpu_inaccessible(xe))
+	    xe_ttm_stolen_cpu_access_needs_ggtt(xe))
  		flags |= XE_BO_CREATE_GGTT_BIT;
 
  	bo = xe_bo_create_locked_range(xe, gt, vm, size, start, end, type, flags);
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +7 -0
index 2e8d07ad42ae..e608b49072ba 100644
@@ -66,6 +66,20 @@ bool xe_ttm_stolen_cpu_inaccessible(struct xe_device *xe)
  	return !mgr->io_base || GRAPHICS_VERx100(xe) < 1270;
  }
 
+/**
+ * xe_ttm_stolen_cpu_access_needs_ggtt - If we can't directly CPU access stolen,
+ * can we then fallback to mapping through the GGTT.
+ * @xe: xe device
+ *
+ * Some older integrated platforms don't support reliable CPU access for stolen,
+ * however on such hardware we can always use the mappable part of the GGTT for

drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c bool xe_ttm_stolen_cpu_inaccessible(struct xe_device *xe) · line 85

Quoted 10 lines
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +7 -0
+ * CPU access. Check if that's the case for this device.
+ */
+bool xe_ttm_stolen_cpu_access_needs_ggtt(struct xe_device *xe)
+{
+	return xe_ttm_stolen_cpu_inaccessible(xe) && !IS_DGFX(xe);
+}
+
  static s64 detect_bar2_dgfx(struct xe_device *xe, struct xe_ttm_stolen_mgr *mgr)
  {
  	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);

I think it's more the other way around by the way, if you make cpu_inaccessible use

xe_ttm_stolen_cpu_access_needs_ggtt, it can be used insidexe_ttm_stolen_mgr_init too.

Quoted 12 lines
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.h +1 -0
index 2fda97b97a05..e210dada636e 100644
@@ -15,6 +15,7 @@ struct xe_device;
  void xe_ttm_stolen_mgr_init(struct xe_device *xe);
  int xe_ttm_stolen_io_mem_reserve(struct xe_device *xe, struct ttm_resource *mem);
  bool xe_ttm_stolen_cpu_inaccessible(struct xe_device *xe);
+bool xe_ttm_stolen_cpu_access_needs_ggtt(struct xe_device *xe);
  u64 xe_ttm_stolen_io_offset(struct xe_bo *bo, u32 offset);
  u64 xe_ttm_stolen_gpu_offset(struct xe_device *xe);
 
#3 lore raw

PATCH v2 2/6 drm/xe: s/lmem/vram/

In reply to Matthew Auld

This seems to be the preferred nomenclature in xe. Currently we are intermixing vram and lmem, which is confusing.

v2 (Gwan-gyeong Mun & Lucas):
- Rather apply to the entire driver

Cc Maarten Lankhorst <[email protected]>
Cc Gwan-gyeong Mun <[email protected]>
Cc Lucas De Marchi <[email protected]>
---
 drivers/gpu/drm/xe/Kconfig.debug      |  2 +-
 drivers/gpu/drm/xe/tests/xe_migrate.c |  2 +-
 drivers/gpu/drm/xe/xe_bo.c            | 10 +++----
 drivers/gpu/drm/xe/xe_bo.h            |  6 ++--
 drivers/gpu/drm/xe/xe_ggtt.c          |  6 ++--
 drivers/gpu/drm/xe/xe_migrate.c       | 12 ++++----
 drivers/gpu/drm/xe/xe_mmio.c          | 40 +++++++++++++--------------
 drivers/gpu/drm/xe/xe_module.c        |  6 ++--
 drivers/gpu/drm/xe/xe_module.h        |  2 +-
 drivers/gpu/drm/xe/xe_pt.c            | 12 ++++----
 drivers/gpu/drm/xe/xe_vm.c            | 10 +++----
 11 files changed, 54 insertions(+), 54 deletions(-)
drivers/gpu/drm/xe/Kconfig.debug +1 -1
index 565be3f6b9b9..93b284cdd0a2 100644
@@ -41,7 +41,7 @@ config DRM_XE_DEBUG_VM
 	  If in doubt, say "N".
 
 config DRM_XE_DEBUG_MEM
-	bool "Enable passing SYS/LMEM addresses to user space"
+	bool "Enable passing SYS/VRAM addresses to user space"
 	default n
 	help
 	  Pass object location trough uapi. Intended for extended
drivers/gpu/drm/xe/tests/xe_migrate.c +1 -1
index b7e4a126e8b7..ac659b94e7f5 100644
@@ -129,7 +129,7 @@ static void test_copy(struct xe_migrate *m, struct xe_bo *bo,
 	}
 	dma_fence_put(fence);
 
-	/* Try to copy 0xc0 from sysmem to lmem with 2MB or 64KiB/4KiB pages */
+	/* Try to copy 0xc0 from sysmem to vram with 2MB or 64KiB/4KiB pages */
 	xe_map_memset(xe, &sysmem->vmap, 0, 0xc0, sysmem->size);
 	xe_map_memset(xe, &bo->vmap, 0, 0xd0, bo->size);
 
drivers/gpu/drm/xe/xe_bo.c +5 -5
index 876f77669104..73a7f2cd4ad8 100644
@@ -1290,12 +1290,12 @@ int xe_bo_pin(struct xe_bo *bo)
 	if (IS_DGFX(xe) && !(IS_ENABLED(CONFIG_DRM_XE_DEBUG) &&
 	    bo->flags & XE_BO_INTERNAL_TEST)) {
 		struct ttm_place *place = &(bo->placements[0]);
-		bool lmem;
+		bool vram;
 
 		if (mem_type_is_vram(place->mem_type)) {
 			XE_BUG_ON(!(place->flags & TTM_PL_FLAG_CONTIGUOUS));
 
-			place->fpfn = (xe_bo_addr(bo, 0, PAGE_SIZE, &lmem) -
+			place->fpfn = (xe_bo_addr(bo, 0, PAGE_SIZE, &vram) -
 				       vram_region_io_offset(bo)) >> PAGE_SHIFT;
 			place->lpfn = place->fpfn + (bo->size >> PAGE_SHIFT);
 
@@ -1415,7 +1415,7 @@ bool xe_bo_is_xe_bo(struct ttm_buffer_object *bo)
 }
 
 dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset,
-		      size_t page_size, bool *is_lmem)
+		      size_t page_size, bool *is_vram)
 {
 	struct xe_res_cursor cur;
 	u64 page;
@@ -1427,9 +1427,9 @@ dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset,
 	page = offset >> PAGE_SHIFT;
 	offset &= (PAGE_SIZE - 1);
 
-	*is_lmem = xe_bo_is_vram(bo);
+	*is_vram = xe_bo_is_vram(bo);
 
-	if (!*is_lmem && !xe_bo_is_stolen(bo)) {
+	if (!*is_vram && !xe_bo_is_stolen(bo)) {
 		XE_BUG_ON(!bo->ttm.ttm);
 
 		xe_res_first_sg(xe_bo_get_sg(bo), page << PAGE_SHIFT,
drivers/gpu/drm/xe/xe_bo.h +3 -3
index 0699b2b4c5ca..f841e74cd417 100644
@@ -196,14 +196,14 @@ static inline void xe_bo_unpin_map_no_vm(struct xe_bo *bo)
 
 bool xe_bo_is_xe_bo(struct ttm_buffer_object *bo);
 dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset,
-		      size_t page_size, bool *is_lmem);
+		      size_t page_size, bool *is_vram);
 
 static inline dma_addr_t
 xe_bo_main_addr(struct xe_bo *bo, size_t page_size)
 {
-	bool is_lmem;
+	bool is_vram;
 
-	return xe_bo_addr(bo, 0, page_size, &is_lmem);
+	return xe_bo_addr(bo, 0, page_size, &is_vram);
 }
 
 static inline u32
drivers/gpu/drm/xe/xe_ggtt.c +3 -3
index a0d672b6afb2..a430d1568890 100644
@@ -28,12 +28,12 @@ u64 xe_ggtt_pte_encode(struct xe_bo *bo, u64 bo_offset)
 {
 	struct xe_device *xe = xe_bo_device(bo);
 	u64 pte;
-	bool is_lmem;
+	bool is_vram;
 
-	pte = xe_bo_addr(bo, bo_offset, GEN8_PAGE_SIZE, &is_lmem);
+	pte = xe_bo_addr(bo, bo_offset, GEN8_PAGE_SIZE, &is_vram);
 	pte |= GEN8_PAGE_PRESENT;
 
-	if (is_lmem)
+	if (is_vram)
 		pte |= GEN12_GGTT_PTE_LM;
 
 	/* FIXME: vfunc + pass in caching rules */
drivers/gpu/drm/xe/xe_migrate.c +6 -6
index bc69ec17d5ad..c0523d8fe944 100644
@@ -222,15 +222,15 @@ static int xe_migrate_prepare_vm(struct xe_gt *gt, struct xe_migrate *m,
 			level++;
 		}
 	} else {
-		bool is_lmem;
-		u64 batch_addr = xe_bo_addr(batch, 0, GEN8_PAGE_SIZE, &is_lmem);
+		bool is_vram;
+		u64 batch_addr = xe_bo_addr(batch, 0, GEN8_PAGE_SIZE, &is_vram);
 
 		m->batch_base_ofs = xe_migrate_vram_ofs(batch_addr);
 
 		if (xe->info.supports_usm) {
 			batch = gt->usm.bb_pool.bo;
 			batch_addr = xe_bo_addr(batch, 0, GEN8_PAGE_SIZE,
-						&is_lmem);
+						&is_vram);
 			m->usm_batch_base_ofs = xe_migrate_vram_ofs(batch_addr);
 		}
 	}
@@ -933,12 +933,12 @@ static void write_pgtable(struct xe_gt *gt, struct xe_bb *bb, u64 ppgtt_ofs,
 	 */
 	XE_BUG_ON(update->qwords > 0x1ff);
 	if (!ppgtt_ofs) {
-		bool is_lmem;
+		bool is_vram;
 
 		ppgtt_ofs = xe_migrate_vram_ofs(xe_bo_addr(update->pt_bo, 0,
 							   GEN8_PAGE_SIZE,
-							   &is_lmem));
-		XE_BUG_ON(!is_lmem);
+							   &is_vram));
+		XE_BUG_ON(!is_vram);
 	}
 
 	do {
drivers/gpu/drm/xe/xe_mmio.c +20 -20
index 65b0df9bb579..e5bd4609aaee 100644
@@ -68,7 +68,7 @@ _resize_bar(struct xe_device *xe, int resno, resource_size_t size)
 	return 1;
 }
 
-static int xe_resize_lmem_bar(struct xe_device *xe, resource_size_t lmem_size)
+static int xe_resize_vram_bar(struct xe_device *xe, resource_size_t vram_size)
 {
 	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
 	struct pci_bus *root = pdev->bus;
@@ -78,31 +78,31 @@ static int xe_resize_lmem_bar(struct xe_device *xe, resource_size_t lmem_size)
 	u32 pci_cmd;
 	int i;
 	int ret;
-	u64 force_lmem_bar_size = xe_force_lmem_bar_size;
+	u64 force_vram_bar_size = xe_force_vram_bar_size;
 
 	current_size = roundup_pow_of_two(pci_resource_len(pdev, GEN12_LMEM_BAR));
 
-	if (force_lmem_bar_size) {
+	if (force_vram_bar_size) {
 		u32 bar_sizes;
 
-		rebar_size = force_lmem_bar_size * (resource_size_t)SZ_1M;
+		rebar_size = force_vram_bar_size * (resource_size_t)SZ_1M;
 		bar_sizes = pci_rebar_get_possible_sizes(pdev, GEN12_LMEM_BAR);
 
 		if (rebar_size == current_size)
 			return 0;
 
 		if (!(bar_sizes & BIT(pci_rebar_bytes_to_size(rebar_size))) ||
-		    rebar_size >= roundup_pow_of_two(lmem_size)) {
-			rebar_size = lmem_size;
+		    rebar_size >= roundup_pow_of_two(vram_size)) {
+			rebar_size = vram_size;
 			drm_info(&xe->drm,
 				 "Given bar size is not within supported size, setting it to default: %llu\n",
-				 (u64)lmem_size >> 20);
+				 (u64)vram_size >> 20);
 		}
 	} else {
 		rebar_size = current_size;
 
-		if (rebar_size != roundup_pow_of_two(lmem_size))
-			rebar_size = lmem_size;
+		if (rebar_size != roundup_pow_of_two(vram_size))
+			rebar_size = vram_size;
 		else
 			return 0;
 	}
@@ -117,7 +117,7 @@ static int xe_resize_lmem_bar(struct xe_device *xe, resource_size_t lmem_size)
 	}
 
 	if (!root_res) {
-		drm_info(&xe->drm, "Can't resize LMEM BAR - platform support is missing\n");
+		drm_info(&xe->drm, "Can't resize VRAM BAR - platform support is missing\n");
 		return -1;
 	}
 
@@ -168,7 +168,7 @@ int xe_mmio_total_vram_size(struct xe_device *xe, u64 *vram_size, u64 *usable_si
 	if (usable_size) {
 		reg = xe_gt_mcr_unicast_read_any(gt, XEHP_FLAT_CCS_BASE_ADDR);
 		*usable_size = (u64)REG_FIELD_GET(GENMASK(31, 8), reg) * SZ_64K;
-		drm_info(&xe->drm, "lmem_size: 0x%llx usable_size: 0x%llx\n",
+		drm_info(&xe->drm, "vram_size: 0x%llx usable_size: 0x%llx\n",
 			 *vram_size, *usable_size);
 	}
 
@@ -180,7 +180,7 @@ int xe_mmio_probe_vram(struct xe_device *xe)
 	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
 	struct xe_gt *gt;
 	u8 id;
-	u64 lmem_size;
+	u64 vram_size;
 	u64 original_size;
 	u64 current_size;
 	u64 usable_size;
@@ -207,29 +207,29 @@ int xe_mmio_probe_vram(struct xe_device *xe)
 	gt = xe_device_get_gt(xe, 0);
 	original_size = pci_resource_len(pdev, GEN12_LMEM_BAR);
 
-	err = xe_mmio_total_vram_size(xe, &lmem_size, &usable_size);
+	err = xe_mmio_total_vram_size(xe, &vram_size, &usable_size);
 	if (err)
 		return err;
 
-	resize_result = xe_resize_lmem_bar(xe, lmem_size);
+	resize_result = xe_resize_vram_bar(xe, vram_size);
 	current_size = pci_resource_len(pdev, GEN12_LMEM_BAR);
 	xe->mem.vram.io_start = pci_resource_start(pdev, GEN12_LMEM_BAR);
 
-	xe->mem.vram.size = min(current_size, lmem_size);
+	xe->mem.vram.size = min(current_size, vram_size);
 
 	if (!xe->mem.vram.size)
 		return -EIO;
 
 	if (resize_result > 0)
-		drm_info(&xe->drm, "Successfully resize LMEM from %lluMiB to %lluMiB\n",
+		drm_info(&xe->drm, "Successfully resize VRAM from %lluMiB to %lluMiB\n",
 			 (u64)original_size >> 20,
 			 (u64)current_size >> 20);
-	else if (xe->mem.vram.size < lmem_size && !xe_force_lmem_bar_size)
+	else if (xe->mem.vram.size < vram_size && !xe_force_vram_bar_size)
 		drm_info(&xe->drm, "Using a reduced BAR size of %lluMiB. Consider enabling 'Resizable BAR' support in your BIOS.\n",
 			 (u64)xe->mem.vram.size >> 20);
-	if (xe->mem.vram.size < lmem_size)
+	if (xe->mem.vram.size < vram_size)
 		drm_warn(&xe->drm, "Restricting VRAM size to PCI resource size (0x%llx->0x%llx)\n",
-			 lmem_size, (u64)xe->mem.vram.size);
+			 vram_size, (u64)xe->mem.vram.size);
 
 	xe->mem.vram.mapping = ioremap_wc(xe->mem.vram.io_start, xe->mem.vram.size);
 	xe->mem.vram.size = min_t(u64, xe->mem.vram.size, usable_size);
@@ -360,7 +360,7 @@ int xe_mmio_init(struct xe_device *xe)
 	 * and we should not continue with driver initialization.
 	 */
 	if (IS_DGFX(xe) && !(xe_mmio_read32(gt, GU_CNTL.reg) & LMEM_INIT)) {
-		drm_err(&xe->drm, "LMEM not initialized by firmware\n");
+		drm_err(&xe->drm, "VRAM not initialized by firmware\n");
 		return -ENODEV;
 	}
 
drivers/gpu/drm/xe/xe_module.c +3 -3
index 5a51a9959eff..6860586ce7f8 100644
@@ -22,9 +22,9 @@ bool enable_display = true;
 module_param_named(enable_display, enable_display, bool, 0444);
 MODULE_PARM_DESC(enable_display, "Enable display");
 
-u32 xe_force_lmem_bar_size;
-module_param_named(lmem_bar_size, xe_force_lmem_bar_size, uint, 0600);
-MODULE_PARM_DESC(lmem_bar_size, "Set the lmem bar size(in MiB)");
+u32 xe_force_vram_bar_size;
+module_param_named(vram_bar_size, xe_force_vram_bar_size, uint, 0600);
+MODULE_PARM_DESC(vram_bar_size, "Set the vram bar size(in MiB)");
 
 int xe_guc_log_level = 5;
 module_param_named(guc_log_level, xe_guc_log_level, int, 0600);
drivers/gpu/drm/xe/xe_module.h +1 -1
index 2c6ee46f5595..86916c176382 100644
@@ -8,6 +8,6 @@
 /* Module modprobe variables */
 extern bool enable_guc;
 extern bool enable_display;
-extern u32 xe_force_lmem_bar_size;
+extern u32 xe_force_vram_bar_size;
 extern int xe_guc_log_level;
 extern char *xe_param_force_probe;
drivers/gpu/drm/xe/xe_pt.c +6 -6
index 06fc7b206997..dfd97b0ec42a 100644
@@ -62,12 +62,12 @@ u64 gen8_pde_encode(struct xe_bo *bo, u64 bo_offset,
 		    const enum xe_cache_level level)
 {
 	u64 pde;
-	bool is_lmem;
+	bool is_vram;
 
-	pde = xe_bo_addr(bo, bo_offset, GEN8_PAGE_SIZE, &is_lmem);
+	pde = xe_bo_addr(bo, bo_offset, GEN8_PAGE_SIZE, &is_vram);
 	pde |= GEN8_PAGE_PRESENT | GEN8_PAGE_RW;
 
-	XE_WARN_ON(IS_DGFX(xe_bo_device(bo)) && !is_lmem);
+	XE_WARN_ON(IS_DGFX(xe_bo_device(bo)) && !is_vram);
 
 	/* FIXME: I don't think the PPAT handling is correct for MTL */
 
@@ -80,13 +80,13 @@ u64 gen8_pde_encode(struct xe_bo *bo, u64 bo_offset,
 }
 
 static dma_addr_t vma_addr(struct xe_vma *vma, u64 offset,
-			   size_t page_size, bool *is_lmem)
+			   size_t page_size, bool *is_vram)
 {
 	if (xe_vma_is_userptr(vma)) {
 		struct xe_res_cursor cur;
 		u64 page;
 
-		*is_lmem = false;
+		*is_vram = false;
 		page = offset >> PAGE_SHIFT;
 		offset &= (PAGE_SIZE - 1);
 
@@ -94,7 +94,7 @@ static dma_addr_t vma_addr(struct xe_vma *vma, u64 offset,
 				&cur);
 		return xe_res_dma(&cur) + offset;
 	} else {
-		return xe_bo_addr(vma->bo, offset, page_size, is_lmem);
+		return xe_bo_addr(vma->bo, offset, page_size, is_vram);
 	}
 }
 
drivers/gpu/drm/xe/xe_vm.c +5 -5
index a0e35627e45e..6cf7172e84cc 100644
@@ -3355,7 +3355,7 @@ int xe_vm_invalidate_vma(struct xe_vma *vma)
 int xe_analyze_vm(struct drm_printer *p, struct xe_vm *vm, int gt_id)
 {
 	struct rb_node *node;
-	bool is_lmem;
+	bool is_vram;
 	uint64_t addr;
 
 	if (!down_read_trylock(&vm->lock)) {
@@ -3363,8 +3363,8 @@ int xe_analyze_vm(struct drm_printer *p, struct xe_vm *vm, int gt_id)
 		return 0;
 	}
 	if (vm->pt_root[gt_id]) {
-		addr = xe_bo_addr(vm->pt_root[gt_id]->bo, 0, GEN8_PAGE_SIZE, &is_lmem);
-		drm_printf(p, " VM root: A:0x%llx %s\n", addr, is_lmem ? "LMEM" : "SYS");
+		addr = xe_bo_addr(vm->pt_root[gt_id]->bo, 0, GEN8_PAGE_SIZE, &is_vram);
+		drm_printf(p, " VM root: A:0x%llx %s\n", addr, is_vram ? "VRAM" : "SYS");
 	}
 
 	for (node = rb_first(&vm->vmas); node; node = rb_next(node)) {
@@ -3377,11 +3377,11 @@ int xe_analyze_vm(struct drm_printer *p, struct xe_vm *vm, int gt_id)
 			xe_res_first_sg(vma->userptr.sg, 0, GEN8_PAGE_SIZE, &cur);
 			addr = xe_res_dma(&cur);
 		} else {
-			addr = xe_bo_addr(vma->bo, 0, GEN8_PAGE_SIZE, &is_lmem);
+			addr = xe_bo_addr(vma->bo, 0, GEN8_PAGE_SIZE, &is_vram);
 		}
 		drm_printf(p, " [%016llx-%016llx] S:0x%016llx A:%016llx %s\n",
 			   vma->start, vma->end, vma->end - vma->start + 1ull,
-			   addr, is_userptr ? "USR" : is_lmem ? "VRAM" : "SYS");
+			   addr, is_userptr ? "USR" : is_vram ? "VRAM" : "SYS");
 	}
 	up_read(&vm->lock);
 
Signature · 1 line
2.39.2
#4 lore raw

PATCH v2 3/6 drm/xe/vram: start tracking the io_size

In reply to Matthew Auld

First step towards supporting small-bar is to track the io_size for vram. We can longer assume that the io_size == vram size. This way we know how much is CPU accessible via the BAR, and how much is not. Effectively giving us a two tiered vram, where in some later patches we can support different allocation strategies depending on if the memory needs to be CPU accessible or not.

Note as this stage we still clamp the vram size to the usable vram size. Only in the final patch do we turn this on for real, and allow distinct io_size and vram_size.

v2: (Lucas):
- Improve the commit message, plus improve the kernel-doc for the io_size to give a better sense of what it actually is.

---
 drivers/gpu/drm/xe/xe_device_types.h | 14 +++++++--
 drivers/gpu/drm/xe/xe_gt_types.h     | 14 +++++++--
 drivers/gpu/drm/xe/xe_mmio.c         | 44 ++++++++++++++++++++--------
 3 files changed, 55 insertions(+), 17 deletions(-)
drivers/gpu/drm/xe/xe_device_types.h +12 -2
index 034e0956f4ea..b98ffad45064 100644
@@ -176,9 +176,19 @@ struct xe_device {
 	struct {
 		/** @vram: VRAM info for device */
 		struct {
-			/** @io_start: start address of VRAM */
+			/** @io_start: IO start address of VRAM */
 			resource_size_t io_start;
-			/** @size: size of VRAM */
+			/**
+			 * @io_size: IO size of VRAM.
+			 *
+			 * This represents how much of VRAM we can access via
+			 * the CPU through the VRAM BAR. This can be smaller
+			 * than @size, in which case only part of VRAM is CPU
+			 * accessible (typically the first 256M). This
+			 * configuration is known as small-bar.
+			 */
+			resource_size_t io_size;
+			/** @size: Total size of VRAM */
 			resource_size_t size;
 			/** @mapping: pointer to VRAM mappable space */
 			void *__iomem mapping;
drivers/gpu/drm/xe/xe_gt_types.h +12 -2
index 74b4e6776bf1..8f29aba455e0 100644
@@ -143,9 +143,19 @@ struct xe_gt {
 		 * (virtual split), can be subset of global device VRAM
 		 */
 		struct {
-			/** @io_start: start address of VRAM */
+			/** @io_start: IO start address of this VRAM instance */
 			resource_size_t io_start;
-			/** @size: size of VRAM */
+			/**
+			 * @io_size: IO size of this VRAM instance
+			 *
+			 * This represents how much of this VRAM we can access
+			 * via the CPU through the VRAM BAR. This can be smaller
+			 * than @size, in which case only part of VRAM is CPU
+			 * accessible (typically the first 256M). This
+			 * configuration is known as small-bar.
+			 */
+			resource_size_t io_size;
+			/** @size: size of VRAM. */
 			resource_size_t size;
 			/** @mapping: pointer to VRAM mappable space */
 			void *__iomem mapping;
drivers/gpu/drm/xe/xe_mmio.c +31 -13

102 lines not on this page · raw message

Signature · 1 line
2.39.2
#5 lore raw

PATCH v2 4/6 drm/xe/buddy: remove the virtualized start

In reply to Matthew Auld

Hopefully not needed anymore. We can add a .compatible() hook once we need to differentiate between mappable and non-mappable vram. If the allocation is not contiguous then the start value is kind of meaningless, so rather just mark as invalid.

In upstream, TTM wants to eventually remove the ttm_resource.start usage.

---
 drivers/gpu/drm/xe/xe_bo.c           |  6 ++++++
 drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 29 ++++++++++++++--------------
 2 files changed, 20 insertions(+), 15 deletions(-)
drivers/gpu/drm/xe/xe_bo.c +6 -0
index 73a7f2cd4ad8..346573f406c2 100644
@@ -662,6 +662,12 @@ static int xe_bo_move(struct ttm_buffer_object *ttm_bo, bool evict,
 				void *new_addr = gt->mem.vram.mapping +
 					(new_mem->start << PAGE_SHIFT);
 
+				if (XE_WARN_ON(new_mem->start == XE_BO_INVALID_OFFSET)) {
+					ret = -EINVAL;
+					xe_device_mem_access_put(xe);
+					goto out;
+				}
+
 				XE_BUG_ON(new_mem->start !=
 					  bo->placements->fpfn);
 
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +14 -15
index 643365b18bc7..e3ac8c6d3978 100644
@@ -54,7 +54,6 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man,
 	struct xe_ttm_vram_mgr_resource *vres;
 	u64 size, remaining_size, lpfn, fpfn;
 	struct drm_buddy *mm = &mgr->mm;
-	struct drm_buddy_block *block;
 	unsigned long pages_per_block;
 	int r;
 
@@ -186,24 +185,24 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man,
 			list_splice_tail(trim_list, &vres->blocks);
 	}
 
-	vres->base.start = 0;
-	list_for_each_entry(block, &vres->blocks, link) {
-		unsigned long start;
+	if (!(vres->base.placement & TTM_PL_FLAG_CONTIGUOUS) &&
+	    xe_is_vram_mgr_blocks_contiguous(mm, &vres->blocks))
+		vres->base.placement |= TTM_PL_FLAG_CONTIGUOUS;
 
-		start = drm_buddy_block_offset(block) +
-			drm_buddy_block_size(mm, block);
-		start >>= PAGE_SHIFT;
+	/*
+	 * For some kernel objects we still rely on the start when io mapping
+	 * the object.
+	 */
+	if (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS) {
+		struct drm_buddy_block *block = list_first_entry(&vres->blocks,
+								 typeof(*block),
+								 link);
 
-		if (start > PFN_UP(vres->base.size))
-			start -= PFN_UP(vres->base.size);
-		else
-			start = 0;
-		vres->base.start = max(vres->base.start, start);
+		vres->base.start = drm_buddy_block_offset(block) >> PAGE_SHIFT;
+	} else {
+		vres->base.start = XE_BO_INVALID_OFFSET;
 	}
 
-	if (xe_is_vram_mgr_blocks_contiguous(mm, &vres->blocks))
-		vres->base.placement |= TTM_PL_FLAG_CONTIGUOUS;
-
 	*res = &vres->base;
 	return 0;
 
Signature · 1 line
2.39.2
#6 lore raw

PATCH v2 5/6 drm/xe/buddy: add visible tracking

In reply to Matthew Auld

Replace the allocation code with the i915 version. This simplifies the code a little, and importantly we get the accounting at the mgr level, which is useful for debug (and maybe userspace), plus per resource tracking so we can easily check if a resource is using one or pages in the mappable part of vram (useful for eviction), or if the resource is completely within the mappable portion (useful for checking if the resource can be safely CPU mapped).

Cc Maarten Lankhorst <[email protected]>
Cc Lucas De Marchi <[email protected]>
---
 drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c     |  18 +-
 drivers/gpu/drm/xe/xe_ttm_vram_mgr.c       | 201 ++++++++++-----------
 drivers/gpu/drm/xe/xe_ttm_vram_mgr.h       |   3 +-
 drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h |   6 +
 4 files changed, 118 insertions(+), 110 deletions(-)
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +14 -4
index e608b49072ba..35e6bc62766e 100644
@@ -158,7 +158,7 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
 {
 	struct xe_ttm_stolen_mgr *mgr = drmm_kzalloc(&xe->drm, sizeof(*mgr), GFP_KERNEL);
 	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
-	u64 stolen_size, pgsize;
+	u64 stolen_size, io_size, pgsize;
 	int err;
 
 	if (IS_DGFX(xe))
@@ -177,7 +177,17 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
 	if (pgsize < PAGE_SIZE)
 		pgsize = PAGE_SIZE;
 
-	err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, stolen_size, pgsize);
+	/*
+	 * We don't try to attempt partial visible support for stolen vram,
+	 * since stolen is always at the end of vram, and the BAR size is pretty
+	 * much always 256M, with small-bar.
+	 */
+	io_size = 0;
+	if (!xe_ttm_stolen_cpu_inaccessible(xe))
+		io_size = stolen_size;
+
+	err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, stolen_size,
+				     io_size, pgsize);
 	if (err) {
 		drm_dbg_kms(&xe->drm, "Stolen mgr init failed: %i\n", err);
 		return;
@@ -186,8 +196,8 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
 	drm_dbg_kms(&xe->drm, "Initialized stolen memory support with %llu bytes\n",
 		    stolen_size);
 
-	if (!xe_ttm_stolen_cpu_inaccessible(xe))
-		mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, stolen_size);
+	if (io_size)
+		mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, io_size);
 }
 
 u64 xe_ttm_stolen_io_offset(struct xe_bo *bo, u32 offset)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +96 -105

281 lines not on this page · raw message

drivers/gpu/drm/xe/xe_ttm_vram_mgr.h +2 -1
index 78f332d26224..35e5367a79fb 100644
@@ -13,7 +13,8 @@ struct xe_device;
 struct xe_gt;
 
 int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
-			   u32 mem_type, u64 size, u64 default_page_size);
+			   u32 mem_type, u64 size, u64 io_size,
+			   u64 default_page_size);
 int xe_ttm_vram_mgr_init(struct xe_gt *gt, struct xe_ttm_vram_mgr *mgr);
 int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe,
 			      struct ttm_resource *res,
drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h +6 -0
index 39aa2ec1b968..3d9417ff7434 100644
@@ -23,6 +23,10 @@ struct xe_ttm_vram_mgr {
 	struct ttm_resource_manager manager;
 	/** @mm: DRM buddy allocator which manages the VRAM */
 	struct drm_buddy mm;
+	/** @visible_size: Proped size of the CPU visible portion */
+	u64 visible_size;
+	/** @visible_avail: CPU visible portion still unallocated */
+	u64 visible_avail;
 	/** @default_page_size: default page size */
 	u64 default_page_size;
 	/** @lock: protects allocations of VRAM */
@@ -39,6 +43,8 @@ struct xe_ttm_vram_mgr_resource {
 	struct ttm_resource base;
 	/** @blocks: list of DRM buddy blocks */
 	struct list_head blocks;
+	/** @used_visible_size: How many CPU visible bytes this resource is using */
+	u64 used_visible_size;
 	/** @flags: flags associated with the resource */
 	unsigned long flags;
 };
Signature · 1 line
2.39.2
#7 lore raw

Re: [Intel-xe] [PATCH v2 5/6] drm/xe/buddy: add visible tracking

Quoted 174 lines · Matthew Auld

Replace the allocation code with the i915 version. This simplifies the code a little, and importantly we get the accounting at the mgr level, which is useful for debug (and maybe userspace), plus per resource tracking so we can easily check if a resource is using one or pages in the mappable part of vram (useful for eviction), or if the resource is completely within the mappable portion (useful for checking if the resource can be safely CPU mapped).

Cc Maarten Lankhorst <[email protected]>
Cc Lucas De Marchi <[email protected]>
---
  drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c     |  18 +-
  drivers/gpu/drm/xe/xe_ttm_vram_mgr.c       | 201 ++++++++++-----------
  drivers/gpu/drm/xe/xe_ttm_vram_mgr.h       |   3 +-
  drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h |   6 +
  4 files changed, 118 insertions(+), 110 deletions(-)
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +14 -4
index e608b49072ba..35e6bc62766e 100644
@@ -158,7 +158,7 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
  {
  	struct xe_ttm_stolen_mgr *mgr = drmm_kzalloc(&xe->drm, sizeof(*mgr), GFP_KERNEL);
  	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
-	u64 stolen_size, pgsize;
+	u64 stolen_size, io_size, pgsize;
  	int err;
 
  	if (IS_DGFX(xe))
@@ -177,7 +177,17 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
  	if (pgsize < PAGE_SIZE)
  		pgsize = PAGE_SIZE;
 
-	err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, stolen_size, pgsize);
+	/*
+	 * We don't try to attempt partial visible support for stolen vram,
+	 * since stolen is always at the end of vram, and the BAR size is pretty
+	 * much always 256M, with small-bar.
+	 */
+	io_size = 0;
+	if (!xe_ttm_stolen_cpu_inaccessible(xe))
+		io_size = stolen_size;
+
+	err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, stolen_size,
+				     io_size, pgsize);
  	if (err) {
  		drm_dbg_kms(&xe->drm, "Stolen mgr init failed: %i\n", err);
  		return;
@@ -186,8 +196,8 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
  	drm_dbg_kms(&xe->drm, "Initialized stolen memory support with %llu bytes\n",
  		    stolen_size);
 
-	if (!xe_ttm_stolen_cpu_inaccessible(xe))
-		mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, stolen_size);
+	if (io_size)
+		mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, io_size);
  }
 
  u64 xe_ttm_stolen_io_offset(struct xe_bo *bo, u32 offset)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +13 -70
index e3ac8c6d3978..f703e962f499 100644
@@ -49,45 +49,26 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man,
  			       const struct ttm_place *place,
  			       struct ttm_resource **res)
  {
-	u64 max_bytes, cur_size, min_block_size;
  	struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
  	struct xe_ttm_vram_mgr_resource *vres;
-	u64 size, remaining_size, lpfn, fpfn;
  	struct drm_buddy *mm = &mgr->mm;
-	unsigned long pages_per_block;
-	int r;
-
-	lpfn = (u64)place->lpfn << PAGE_SHIFT;
-	if (!lpfn || lpfn > man->size)
-		lpfn = man->size;
-
-	fpfn = (u64)place->fpfn << PAGE_SHIFT;
+	u64 size, remaining_size, min_page_size;
+	unsigned long lpfn;
+	int err;
 
-	max_bytes = mgr->manager.size;
-	if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
-		pages_per_block = ~0ul;
-	} else {
-#ifdef CONFIG_TRANSPARENT_HUGEPAGE
-		pages_per_block = HPAGE_PMD_NR;
-#else
-		/* default to 2MB */
-		pages_per_block = 2UL << (20UL - PAGE_SHIFT);
-#endif
-
-		pages_per_block = max_t(uint32_t, pages_per_block,
-					tbo->page_alignment);
-	}
+	lpfn = place->lpfn;
+	if (!lpfn || lpfn > man->size >> PAGE_SHIFT)
+		lpfn = man->size >> PAGE_SHIFT;
 
  	vres = kzalloc(sizeof(*vres), GFP_KERNEL);
  	if (!vres)
  		return -ENOMEM;
 
  	ttm_resource_init(tbo, place, &vres->base);
-	remaining_size = vres->base.size;
 
  	/* bail out quickly if there's likely not enough VRAM for this BO */
-	if (ttm_resource_manager_usage(man) > max_bytes) {
-		r = -ENOSPC;
+	if (ttm_resource_manager_usage(man) > man->size) {
+		err = -ENOSPC;
  		goto error_fini;
  	}
 
@@ -96,95 +77,91 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man,
  	if (place->flags & TTM_PL_FLAG_TOPDOWN)
  		vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
 
-	if (fpfn || lpfn != man->size)
-		/* Allocate blocks in desired range */
+	if (place->fpfn || lpfn != man->size >> PAGE_SHIFT)
  		vres->flags |= DRM_BUDDY_RANGE_ALLOCATION;
 
-	mutex_lock(&mgr->lock);
-	while (remaining_size) {
-		if (tbo->page_alignment)
-			min_block_size = tbo->page_alignment << PAGE_SHIFT;
-		else
-			min_block_size = mgr->default_page_size;
-
-		XE_BUG_ON(min_block_size < mm->chunk_size);
-
-		/* Limit maximum size to 2GiB due to SG table limitations */
-		size = min(remaining_size, 2ULL << 30);
-
-		if (size >= pages_per_block << PAGE_SHIFT)
-			min_block_size = pages_per_block << PAGE_SHIFT;
-
-		cur_size = size;
-
-		if (fpfn + size != place->lpfn << PAGE_SHIFT) {
-			/*
-			 * Except for actual range allocation, modify the size and
-			 * min_block_size conforming to continuous flag enablement
-			 */
-			if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
-				size = roundup_pow_of_two(size);
-				min_block_size = size;
-			/*
-			 * Modify the size value if size is not
-			 * aligned with min_block_size
-			 */
-			} else if (!IS_ALIGNED(size, min_block_size)) {
-				size = round_up(size, min_block_size);
-			}
-		}
+	XE_BUG_ON(!vres->base.size);
+	size = vres->base.size;
 
-		r = drm_buddy_alloc_blocks(mm, fpfn,
-					   lpfn,
-					   size,
-					   min_block_size,
-					   &vres->blocks,
-					   vres->flags);
-		if (unlikely(r))
-			goto error_free_blocks;
+	min_page_size = mgr->default_page_size;
+	if (tbo->page_alignment)

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 93

Quoted 10 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +5 -4
+		min_page_size = tbo->page_alignment << PAGE_SHIFT;
 
-		if (size > remaining_size)
-			remaining_size = 0;
-		else
-			remaining_size -= size;
+	XE_BUG_ON(min_page_size < mm->chunk_size);
+	XE_BUG_ON(min_page_size > SZ_2G); /* FIXME: sg limit */
+	XE_BUG_ON(size > SZ_2G &&
+		  (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS));

Hi Matt,
What scenario is the purpose of testing? Is the purpose of reporting an error when it is a small bar case at the current stage?

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 94

Quoted 1 line
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +1 -0
+	XE_BUG_ON(!IS_ALIGNED(size, min_page_size));

If it is not aligned, can't we increase it to the aligned size and allocate it?

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 103

Quoted 9 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +9 -0
+
+	if (place->fpfn + (vres->base.size >> PAGE_SHIFT) != place->lpfn &&
+	    place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+		unsigned long pages;
+
+		size = roundup_pow_of_two(size);
+		min_page_size = size;
+
+		pages = size >> ilog2(mm->chunk_size);

Why did you use ilog2(mm->chunk_size) instead of PAGE_SHIFT here?

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 108

Quoted 11 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +3 -6
+		if (pages > lpfn)
+			lpfn = pages;
  	}
-	mutex_unlock(&mgr->lock);
 
-	if (cur_size != size) {
-		struct drm_buddy_block *block;
-		struct list_head *trim_list;
-		u64 original_size;
-		LIST_HEAD(temp);
+	if (size > lpfn << PAGE_SHIFT) {

In case of DRM_BUDDY_RANGE_ALLOCATION, shouldn't it be compared with size > (lpfn - fpfn) << PAGE_SHIFT?

Br,

G.G.

Quoted 188 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +65 -25
+		err = -E2BIG; /* don't trigger eviction */
+		goto error_fini;
+	}
 
-		trim_list = &vres->blocks;
-		original_size = vres->base.size;
+	mutex_lock(&mgr->lock);
+	if (lpfn <= mgr->visible_size && size > mgr->visible_avail) {
+		mutex_unlock(&mgr->lock);
+		err = -ENOSPC;
+		goto error_fini;
+	}
 
+	remaining_size = size;
+	do {
  		/*
-		 * If size value is rounded up to min_block_size, trim the last
-		 * block to the required size
+		 * Limit maximum size to 2GiB due to SG table limitations.
+		 * FIXME: Should maybe be handled as part of sg construction.
  		 */
-		if (!list_is_singular(&vres->blocks)) {
-			block = list_last_entry(&vres->blocks, typeof(*block), link);
-			list_move_tail(&block->link, &temp);
-			trim_list = &temp;
-			/*
-			 * Compute the original_size value by subtracting the
-			 * last block size with (aligned size - original size)
-			 */
-			original_size = drm_buddy_block_size(mm, block) -
-				(size - cur_size);
-		}
+		u64 alloc_size = min_t(u64, remaining_size, SZ_2G);
+
+		err = drm_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT,
+					     (u64)lpfn << PAGE_SHIFT,
+					     alloc_size,
+					     min_page_size,
+					     &vres->blocks,
+					     vres->flags);
+		if (err)
+			goto error_free_blocks;
 
-		mutex_lock(&mgr->lock);
-		drm_buddy_block_trim(mm,
-				     original_size,
-				     trim_list);
-		mutex_unlock(&mgr->lock);
+		remaining_size -= alloc_size;
+	} while (remaining_size);
 
-		if (!list_empty(&temp))
-			list_splice_tail(trim_list, &vres->blocks);
+	if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+		if (!drm_buddy_block_trim(mm, vres->base.size, &vres->blocks))
+			size = vres->base.size;
  	}
 
+	if (lpfn <= mgr->visible_size >> PAGE_SHIFT) {
+		vres->used_visible_size = size;
+	} else {
+		struct drm_buddy_block *block;
+
+		list_for_each_entry(block, &vres->blocks, link) {
+			u64 start = drm_buddy_block_offset(block);
+
+			if (start < mgr->visible_size) {
+				u64 end = start + drm_buddy_block_size(mm, block);
+
+				vres->used_visible_size +=
+					min(end, mgr->visible_size) - start;
+			}
+		}
+	}
+
+	mgr->visible_avail -= vres->used_visible_size;
+	mutex_unlock(&mgr->lock);
+
  	if (!(vres->base.placement & TTM_PL_FLAG_CONTIGUOUS) &&
  	    xe_is_vram_mgr_blocks_contiguous(mm, &vres->blocks))
  		vres->base.placement |= TTM_PL_FLAG_CONTIGUOUS;
@@ -213,7 +190,7 @@ static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man,
  	ttm_resource_fini(man, &vres->base);
  	kfree(vres);
 
-	return r;
+	return err;
  }
 
  static void xe_ttm_vram_mgr_del(struct ttm_resource_manager *man,
@@ -226,6 +203,7 @@ static void xe_ttm_vram_mgr_del(struct ttm_resource_manager *man,
 
  	mutex_lock(&mgr->lock);
  	drm_buddy_free_list(mm, &vres->blocks);
+	mgr->visible_avail += vres->used_visible_size;
  	mutex_unlock(&mgr->lock);
 
  	ttm_resource_fini(man, res);
@@ -240,6 +218,13 @@ static void xe_ttm_vram_mgr_debug(struct ttm_resource_manager *man,
  	struct drm_buddy *mm = &mgr->mm;
 
  	mutex_lock(&mgr->lock);
+	drm_printf(printer, "default_page_size: %lluKiB\n",
+		   mgr->default_page_size >> 10);
+	drm_printf(printer, "visible_avail: %lluMiB\n",
+		   (u64)mgr->visible_avail >> 20);
+	drm_printf(printer, "visible_size: %lluMiB\n",
+		   (u64)mgr->visible_size >> 20);
+
  	drm_buddy_print(mm, printer);
  	mutex_unlock(&mgr->lock);
  	drm_printf(printer, "man size:%llu\n", man->size);
@@ -262,6 +247,8 @@ static void ttm_vram_mgr_fini(struct drm_device *dev, void *arg)
  	if (ttm_resource_manager_evict_all(&xe->ttm, man))
  		return;
 
+	WARN_ON_ONCE(mgr->visible_avail != mgr->visible_size);
+
  	drm_buddy_fini(&mgr->mm);
 
  	ttm_resource_manager_cleanup(&mgr->manager);
@@ -270,7 +257,8 @@ static void ttm_vram_mgr_fini(struct drm_device *dev, void *arg)
  }
 
  int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
-			   u32 mem_type, u64 size, u64 default_page_size)
+			   u32 mem_type, u64 size, u64 io_size,
+			   u64 default_page_size)
  {
  	struct ttm_resource_manager *man = &mgr->manager;
  	int err;
@@ -279,6 +267,8 @@ int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
  	mgr->mem_type = mem_type;
  	mutex_init(&mgr->lock);
  	mgr->default_page_size = default_page_size;
+	mgr->visible_size = io_size;
+	mgr->visible_avail = io_size;
 
  	ttm_resource_manager_init(man, &xe->ttm, size);
  	err = drm_buddy_init(&mgr->mm, man->size, default_page_size);
@@ -298,7 +288,8 @@ int xe_ttm_vram_mgr_init(struct xe_gt *gt, struct xe_ttm_vram_mgr *mgr)
  	mgr->gt = gt;
 
  	return __xe_ttm_vram_mgr_init(xe, mgr, XE_PL_VRAM0 + gt->info.vram_id,
-				      gt->mem.vram.size, PAGE_SIZE);
+				      gt->mem.vram.size, gt->mem.vram.io_size,
+				      PAGE_SIZE);
  }
 
  int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe,
drivers/gpu/drm/xe/xe_ttm_vram_mgr.h +2 -1
index 78f332d26224..35e5367a79fb 100644
@@ -13,7 +13,8 @@ struct xe_device;
  struct xe_gt;
 
  int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
-			   u32 mem_type, u64 size, u64 default_page_size);
+			   u32 mem_type, u64 size, u64 io_size,
+			   u64 default_page_size);
  int xe_ttm_vram_mgr_init(struct xe_gt *gt, struct xe_ttm_vram_mgr *mgr);
  int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe,
  			      struct ttm_resource *res,
drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h +6 -0
index 39aa2ec1b968..3d9417ff7434 100644
@@ -23,6 +23,10 @@ struct xe_ttm_vram_mgr {
  	struct ttm_resource_manager manager;
  	/** @mm: DRM buddy allocator which manages the VRAM */
  	struct drm_buddy mm;
+	/** @visible_size: Proped size of the CPU visible portion */
+	u64 visible_size;
+	/** @visible_avail: CPU visible portion still unallocated */
+	u64 visible_avail;
  	/** @default_page_size: default page size */
  	u64 default_page_size;
  	/** @lock: protects allocations of VRAM */
@@ -39,6 +43,8 @@ struct xe_ttm_vram_mgr_resource {
  	struct ttm_resource base;
  	/** @blocks: list of DRM buddy blocks */
  	struct list_head blocks;
+	/** @used_visible_size: How many CPU visible bytes this resource is using */
+	u64 used_visible_size;
  	/** @flags: flags associated with the resource */
  	unsigned long flags;
  };
#8 lore raw

Re: [Intel-xe] [PATCH v2 5/6] drm/xe/buddy: add visible tracking

Quoted 175 lines · Gwan-gyeong Mun
Quoted 172 lines · Matthew Auld

Replace the allocation code with the i915 version. This simplifies the code a little, and importantly we get the accounting at the mgr level, which is useful for debug (and maybe userspace), plus per resource tracking so we can easily check if a resource is using one or pages in the mappable part of vram (useful for eviction), or if the resource is completely within the mappable portion (useful for checking if the resource can be safely CPU mapped).

Cc Maarten Lankhorst <[email protected]>
Cc Lucas De Marchi <[email protected]>

---
  drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c     |  18 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr.c       | 201 ++++++++++----------- drivers/gpu/drm/xe/xe_ttm_vram_mgr.h       |   3 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h |   6 +

  4 files changed, 118 insertions(+), 110 deletions(-)
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +4 -2
index e608b49072ba..35e6bc62766e 100644
@@ -158,7 +158,7 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
   {
       struct xe_ttm_stolen_mgr *mgr = drmm_kzalloc(&xe->drm, sizeof(*mgr), GFP_KERNEL);
       struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
-    u64 stolen_size, pgsize;
+    u64 stolen_size, io_size, pgsize;
       int err;
       if (IS_DGFX(xe))
@@ -177,7 +177,17 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
       if (pgsize < PAGE_SIZE)
           pgsize = PAGE_SIZE;
-    err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, 
 stolen_size, pgsize);
+    /*
+     * We don't try to attempt partial visible support for stolen vram,
+     * since stolen is always at the end of vram, and the BAR size is 

pretty
+     * much always 256M, with small-bar.
+     */
+    io_size = 0;
+    if (!xe_ttm_stolen_cpu_inaccessible(xe))
+        io_size = stolen_size;
+
+    err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, stolen_size,
+                     io_size, pgsize);
      if (err) {
          drm_dbg_kms(&xe->drm, "Stolen mgr init failed: %i\n", err); return;

drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +2 -2
@@ -186,8 +196,8 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
       drm_dbg_kms(&xe->drm, "Initialized stolen memory support with %llu bytes\n",
               stolen_size);
-    if (!xe_ttm_stolen_cpu_inaccessible(xe))
-        mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, 
 stolen_size);
+    if (io_size)
+        mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, 
 io_size);
   }
   u64 xe_ttm_stolen_io_offset(struct xe_bo *bo, u32 offset)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +14 -72
index e3ac8c6d3978..f703e962f499 100644
@@ -49,45 +49,26 @@ static int xe_ttm_vram_mgr_new(struct 
 ttm_resource_manager *man,
                      const struct ttm_place *place,
                      struct ttm_resource **res)
   {
-    u64 max_bytes, cur_size, min_block_size;
       struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
       struct xe_ttm_vram_mgr_resource *vres;
-    u64 size, remaining_size, lpfn, fpfn;
       struct drm_buddy *mm = &mgr->mm;
-    unsigned long pages_per_block;
-    int r;
-
-    lpfn = (u64)place->lpfn << PAGE_SHIFT;
-    if (!lpfn || lpfn > man->size)
-        lpfn = man->size;
-
-    fpfn = (u64)place->fpfn << PAGE_SHIFT;
+    u64 size, remaining_size, min_page_size;
+    unsigned long lpfn;
+    int err;
-    max_bytes = mgr->manager.size;
-    if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
-        pages_per_block = ~0ul;
-    } else {
-#ifdef CONFIG_TRANSPARENT_HUGEPAGE
-        pages_per_block = HPAGE_PMD_NR;
-#else
-        /* default to 2MB */
-        pages_per_block = 2UL << (20UL - PAGE_SHIFT);
-#endif
-
-        pages_per_block = max_t(uint32_t, pages_per_block,
-                    tbo->page_alignment);
-    }
+    lpfn = place->lpfn;
+    if (!lpfn || lpfn > man->size >> PAGE_SHIFT)
+        lpfn = man->size >> PAGE_SHIFT;
       vres = kzalloc(sizeof(*vres), GFP_KERNEL);
       if (!vres)
           return -ENOMEM;
       ttm_resource_init(tbo, place, &vres->base);
-    remaining_size = vres->base.size;
       /* bail out quickly if there's likely not enough VRAM for this BO */
-    if (ttm_resource_manager_usage(man) > max_bytes) {
-        r = -ENOSPC;
+    if (ttm_resource_manager_usage(man) > man->size) {
+        err = -ENOSPC;
           goto error_fini;
       }
@@ -96,95 +77,91 @@ static int xe_ttm_vram_mgr_new(struct 
 ttm_resource_manager *man,
       if (place->flags & TTM_PL_FLAG_TOPDOWN)
           vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
-    if (fpfn || lpfn != man->size)
-        /* Allocate blocks in desired range */
+    if (place->fpfn || lpfn != man->size >> PAGE_SHIFT)
           vres->flags |= DRM_BUDDY_RANGE_ALLOCATION;
-    mutex_lock(&mgr->lock);
-    while (remaining_size) {
-        if (tbo->page_alignment)
-            min_block_size = tbo->page_alignment << PAGE_SHIFT;
-        else
-            min_block_size = mgr->default_page_size;
-
-        XE_BUG_ON(min_block_size < mm->chunk_size);
-
-        /* Limit maximum size to 2GiB due to SG table limitations */
-        size = min(remaining_size, 2ULL << 30);
-
-        if (size >= pages_per_block << PAGE_SHIFT)
-            min_block_size = pages_per_block << PAGE_SHIFT;
-
-        cur_size = size;
-
-        if (fpfn + size != place->lpfn << PAGE_SHIFT) {
-            /*
-             * Except for actual range allocation, modify the size and
-             * min_block_size conforming to continuous flag enablement
-             */
-            if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
-                size = roundup_pow_of_two(size);
-                min_block_size = size;
-            /*
-             * Modify the size value if size is not
-             * aligned with min_block_size
-             */
-            } else if (!IS_ALIGNED(size, min_block_size)) {
-                size = round_up(size, min_block_size);
-            }
-        }
+    XE_BUG_ON(!vres->base.size);
+    size = vres->base.size;
-        r = drm_buddy_alloc_blocks(mm, fpfn,
-                       lpfn,
-                       size,
-                       min_block_size,
-                       &vres->blocks,
-                       vres->flags);
-        if (unlikely(r))
-            goto error_free_blocks;
+    min_page_size = mgr->default_page_size;
+    if (tbo->page_alignment)
+        min_page_size = tbo->page_alignment << PAGE_SHIFT;
-        if (size > remaining_size)
-            remaining_size = 0;
Quoted 8 lines

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 93

Quoted 6 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +4 -2
-        else
-            remaining_size -= size;
+    XE_BUG_ON(min_page_size < mm->chunk_size);
+    XE_BUG_ON(min_page_size > SZ_2G); /* FIXME: sg limit */
+    XE_BUG_ON(size > SZ_2G &&
+          (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS));

Hi Matt,
What scenario is the purpose of testing? Is the purpose of reporting an error when it is a small bar case at the current stage?

XE_BUG_ON(min_page_size < mm->chunk_size) - This one is just a general sanity check, which seemed good to add. The chunk_size is the minimum sized chunk of memory that we can allocate, and so if we ask for something smaller then likely that's a bug.

XE_BUG_ON(min_page_size > SZ_2G) - This is also not small-bar related, but an existing limitation. If you look below the allocation is split into a maximum allocation size of 2G (so that is can always fit in an sg entry without overflowing). If someone in the future asks for page_size > 2G, then the alignment might not match, due to this splitting, hence better treat that as an error. This one has a FIXME, since the code that constructs the sg table could be improved to handle the limitation there, instead of leaking it into the buddy code.

XE_BUG_ON(size > SZ_2G && (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS)) - And this is basically the same as above. We can't have larger than 2G for one chunk AFAICT, so if someone asks for CONTIG for such a case, the underlying allocation might not be contiguous, since we need to make at least two separate allocation requests. But again, I don't think anyone currently needs such a thing, but best to just document/assert such limitations.

Quoted 2 lines

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 94

Quoted 1 line
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +1 -0
+    XE_BUG_ON(!IS_ALIGNED(size, min_page_size));

If it is not aligned, can't we increase it to the aligned size and allocate it?

Yeah, that's one possibility. It's just that the existing behaviour is to leave that to the responsibility of the caller. AFAICT this is for now mostly interesting on platforms where we need 64K min page size for VRAM, and there the object size is meant to be rounded up, so we don't currently expect anyone to trigger this, unless there is a bug.

Quoted 10 lines

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 103

Quoted 9 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +9 -0
+
+    if (place->fpfn + (vres->base.size >> PAGE_SHIFT) != place->lpfn &&
+        place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+        unsigned long pages;
+
+        size = roundup_pow_of_two(size);
+        min_page_size = size;
+
+        pages = size >> ilog2(mm->chunk_size);

Why did you use ilog2(mm->chunk_size) instead of PAGE_SHIFT here?

Yeah, it looks like the existing i915 code seems to mix chunk_size and PAGE_SHIFT. I think back in the day the buddy allocator just accepted the order, but now is happy with the number of bytes, so doesn't make much sense. Will fix. Thanks for pointing this out.

Quoted 11 lines

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 108

Quoted 10 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +3 -6
+        if (pages > lpfn)
+            lpfn = pages;
       }
-    mutex_unlock(&mgr->lock);
-    if (cur_size != size) {
-        struct drm_buddy_block *block;
-        struct list_head *trim_list;
-        u64 original_size;
-        LIST_HEAD(temp);
+    if (size > lpfn << PAGE_SHIFT) {

In case of DRM_BUDDY_RANGE_ALLOCATION, shouldn't it be compared with size > (lpfn - fpfn) << PAGE_SHIFT?

Yeah, that makes more sense. Also this should be higher up. Thanks for reviewing.

Quoted 184 lines

Br,

G.G.

Quoted 180 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +48 -22
+        err = -E2BIG; /* don't trigger eviction */
+        goto error_fini;
+    }
-        trim_list = &vres->blocks;
-        original_size = vres->base.size;
+    mutex_lock(&mgr->lock);
+    if (lpfn <= mgr->visible_size && size > mgr->visible_avail) {
+        mutex_unlock(&mgr->lock);
+        err = -ENOSPC;
+        goto error_fini;
+    }
+    remaining_size = size;
+    do {
           /*
-         * If size value is rounded up to min_block_size, trim the last
-         * block to the required size
+         * Limit maximum size to 2GiB due to SG table limitations.
+         * FIXME: Should maybe be handled as part of sg construction.
            */
-        if (!list_is_singular(&vres->blocks)) {
-            block = list_last_entry(&vres->blocks, typeof(*block), 
 link);
-            list_move_tail(&block->link, &temp);
-            trim_list = &temp;
-            /*
-             * Compute the original_size value by subtracting the
-             * last block size with (aligned size - original size)
-             */
-            original_size = drm_buddy_block_size(mm, block) -
-                (size - cur_size);
-        }
+        u64 alloc_size = min_t(u64, remaining_size, SZ_2G);
+
+        err = drm_buddy_alloc_blocks(mm, (u64)place->fpfn << PAGE_SHIFT,
+                         (u64)lpfn << PAGE_SHIFT,
+                         alloc_size,
+                         min_page_size,
+                         &vres->blocks,
+                         vres->flags);
+        if (err)
+            goto error_free_blocks;
-        mutex_lock(&mgr->lock);
-        drm_buddy_block_trim(mm,
-                     original_size,
-                     trim_list);
-        mutex_unlock(&mgr->lock);
+        remaining_size -= alloc_size;
+    } while (remaining_size);
-        if (!list_empty(&temp))
-            list_splice_tail(trim_list, &vres->blocks);
+    if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+        if (!drm_buddy_block_trim(mm, vres->base.size, &vres->blocks))
+            size = vres->base.size;
       }
+    if (lpfn <= mgr->visible_size >> PAGE_SHIFT) {
+        vres->used_visible_size = size;
+    } else {
+        struct drm_buddy_block *block;
+
+        list_for_each_entry(block, &vres->blocks, link) {
+            u64 start = drm_buddy_block_offset(block);
+
+            if (start < mgr->visible_size) {
+                u64 end = start + drm_buddy_block_size(mm, block);
+
+                vres->used_visible_size +=
+                    min(end, mgr->visible_size) - start;
+            }
+        }
+    }
+
+    mgr->visible_avail -= vres->used_visible_size;
+    mutex_unlock(&mgr->lock);
+

      if (!(vres->base.placement & TTM_PL_FLAG_CONTIGUOUS) && xe_is_vram_mgr_blocks_contiguous(mm, &vres->blocks)) vres->base.placement |= TTM_PL_FLAG_CONTIGUOUS;

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +17 -3
@@ -213,7 +190,7 @@ static int xe_ttm_vram_mgr_new(struct 
 ttm_resource_manager *man,
       ttm_resource_fini(man, &vres->base);
       kfree(vres);
-    return r;
+    return err;
   }
   static void xe_ttm_vram_mgr_del(struct ttm_resource_manager *man,
@@ -226,6 +203,7 @@ static void xe_ttm_vram_mgr_del(struct 
 ttm_resource_manager *man,
       mutex_lock(&mgr->lock);
       drm_buddy_free_list(mm, &vres->blocks);
+    mgr->visible_avail += vres->used_visible_size;
       mutex_unlock(&mgr->lock);
       ttm_resource_fini(man, res);
@@ -240,6 +218,13 @@ static void xe_ttm_vram_mgr_debug(struct 
 ttm_resource_manager *man,
       struct drm_buddy *mm = &mgr->mm;
       mutex_lock(&mgr->lock);
+    drm_printf(printer, "default_page_size: %lluKiB\n",
+           mgr->default_page_size >> 10);
+    drm_printf(printer, "visible_avail: %lluMiB\n",
+           (u64)mgr->visible_avail >> 20);
+    drm_printf(printer, "visible_size: %lluMiB\n",
+           (u64)mgr->visible_size >> 20);
+
       drm_buddy_print(mm, printer);
       mutex_unlock(&mgr->lock);
       drm_printf(printer, "man size:%llu\n", man->size);
@@ -262,6 +247,8 @@ static void ttm_vram_mgr_fini(struct drm_device 
 *dev, void *arg)
       if (ttm_resource_manager_evict_all(&xe->ttm, man))
           return;
+    WARN_ON_ONCE(mgr->visible_avail != mgr->visible_size);
+
       drm_buddy_fini(&mgr->mm);
       ttm_resource_manager_cleanup(&mgr->manager);
@@ -270,7 +257,8 @@ static void ttm_vram_mgr_fini(struct drm_device 
 *dev, void *arg)
   }
   int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
-               u32 mem_type, u64 size, u64 default_page_size)
+               u32 mem_type, u64 size, u64 io_size,
+               u64 default_page_size)
   {
       struct ttm_resource_manager *man = &mgr->manager;
       int err;
@@ -279,6 +267,8 @@ int __xe_ttm_vram_mgr_init(struct xe_device *xe, 
 struct xe_ttm_vram_mgr *mgr,
       mgr->mem_type = mem_type;
       mutex_init(&mgr->lock);
       mgr->default_page_size = default_page_size;
+    mgr->visible_size = io_size;
+    mgr->visible_avail = io_size;
       ttm_resource_manager_init(man, &xe->ttm, size);
       err = drm_buddy_init(&mgr->mm, man->size, default_page_size);
@@ -298,7 +288,8 @@ int xe_ttm_vram_mgr_init(struct xe_gt *gt, struct 
 xe_ttm_vram_mgr *mgr)
       mgr->gt = gt;
       return __xe_ttm_vram_mgr_init(xe, mgr, XE_PL_VRAM0 + gt->info.vram_id,
-                      gt->mem.vram.size, PAGE_SIZE);
+                      gt->mem.vram.size, gt->mem.vram.io_size,
+                      PAGE_SIZE);
   }
   int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe,
drivers/gpu/drm/xe/xe_ttm_vram_mgr.h +2 -1
index 78f332d26224..35e5367a79fb 100644
@@ -13,7 +13,8 @@ struct xe_device;
   struct xe_gt;
   int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
-               u32 mem_type, u64 size, u64 default_page_size);
+               u32 mem_type, u64 size, u64 io_size,
+               u64 default_page_size);
   int xe_ttm_vram_mgr_init(struct xe_gt *gt, struct xe_ttm_vram_mgr *mgr);
   int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe,
                     struct ttm_resource *res,
drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h +5 -0
index 39aa2ec1b968..3d9417ff7434 100644
@@ -23,6 +23,10 @@ struct xe_ttm_vram_mgr {
       struct ttm_resource_manager manager;
       /** @mm: DRM buddy allocator which manages the VRAM */
       struct drm_buddy mm;
+    /** @visible_size: Proped size of the CPU visible portion */
+    u64 visible_size;
+    /** @visible_avail: CPU visible portion still unallocated */
+    u64 visible_avail;
       /** @default_page_size: default page size */
       u64 default_page_size;
       /** @lock: protects allocations of VRAM */
@@ -39,6 +43,8 @@ struct xe_ttm_vram_mgr_resource {
       struct ttm_resource base;
       /** @blocks: list of DRM buddy blocks */
       struct list_head blocks;
+    /** @used_visible_size: How many CPU visible bytes this resource 

is using */
+    u64 used_visible_size;
      /** @flags: flags associated with the resource */ unsigned long flags;
  };

#9 lore raw

Re: [Intel-xe] [PATCH v2 5/6] drm/xe/buddy: add visible tracking

Quoted 221 lines · Matthew Auld
Quoted 175 lines · Gwan-gyeong Mun
Quoted 172 lines · Matthew Auld

Replace the allocation code with the i915 version. This simplifies the code a little, and importantly we get the accounting at the mgr level, which is useful for debug (and maybe userspace), plus per resource tracking so we can easily check if a resource is using one or pages in the mappable part of vram (useful for eviction), or if the resource is completely within the mappable portion (useful for checking if the resource can be safely CPU mapped).

Cc Maarten Lankhorst <[email protected]>
Cc Lucas De Marchi <[email protected]>

---
  drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c     |  18 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr.c       | 201 ++++++++++----------- drivers/gpu/drm/xe/xe_ttm_vram_mgr.h       |   3 +- drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h |   6 +

  4 files changed, 118 insertions(+), 110 deletions(-)
drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +4 -2
index e608b49072ba..35e6bc62766e 100644
@@ -158,7 +158,7 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
   {
       struct xe_ttm_stolen_mgr *mgr = drmm_kzalloc(&xe->drm, sizeof(*mgr), GFP_KERNEL);
       struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
-    u64 stolen_size, pgsize;
+    u64 stolen_size, io_size, pgsize;
       int err;
       if (IS_DGFX(xe))
@@ -177,7 +177,17 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
       if (pgsize < PAGE_SIZE)
           pgsize = PAGE_SIZE;
-    err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, 
 stolen_size, pgsize);
+    /*
+     * We don't try to attempt partial visible support for stolen vram,
+     * since stolen is always at the end of vram, and the BAR size 

is pretty
+     * much always 256M, with small-bar.
+     */
+    io_size = 0;
+    if (!xe_ttm_stolen_cpu_inaccessible(xe))
+        io_size = stolen_size;
+
+    err = __xe_ttm_vram_mgr_init(xe, &mgr->base, XE_PL_STOLEN, stolen_size,
+                     io_size, pgsize);
      if (err) {
          drm_dbg_kms(&xe->drm, "Stolen mgr init failed: %i\n", err); return;

drivers/gpu/drm/xe/xe_ttm_stolen_mgr.c +2 -2
@@ -186,8 +196,8 @@ void xe_ttm_stolen_mgr_init(struct xe_device *xe)
       drm_dbg_kms(&xe->drm, "Initialized stolen memory support with %llu bytes\n",
               stolen_size);
-    if (!xe_ttm_stolen_cpu_inaccessible(xe))
-        mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, 
 stolen_size);
+    if (io_size)
+        mgr->mapping = devm_ioremap_wc(&pdev->dev, mgr->io_base, 
 io_size);
   }
   u64 xe_ttm_stolen_io_offset(struct xe_bo *bo, u32 offset)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +14 -72
index e3ac8c6d3978..f703e962f499 100644
@@ -49,45 +49,26 @@ static int xe_ttm_vram_mgr_new(struct 
 ttm_resource_manager *man,
                      const struct ttm_place *place,
                      struct ttm_resource **res)
   {
-    u64 max_bytes, cur_size, min_block_size;
       struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
       struct xe_ttm_vram_mgr_resource *vres;
-    u64 size, remaining_size, lpfn, fpfn;
       struct drm_buddy *mm = &mgr->mm;
-    unsigned long pages_per_block;
-    int r;
-
-    lpfn = (u64)place->lpfn << PAGE_SHIFT;
-    if (!lpfn || lpfn > man->size)
-        lpfn = man->size;
-
-    fpfn = (u64)place->fpfn << PAGE_SHIFT;
+    u64 size, remaining_size, min_page_size;
+    unsigned long lpfn;
+    int err;
-    max_bytes = mgr->manager.size;
-    if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
-        pages_per_block = ~0ul;
-    } else {
-#ifdef CONFIG_TRANSPARENT_HUGEPAGE
-        pages_per_block = HPAGE_PMD_NR;
-#else
-        /* default to 2MB */
-        pages_per_block = 2UL << (20UL - PAGE_SHIFT);
-#endif
-
-        pages_per_block = max_t(uint32_t, pages_per_block,
-                    tbo->page_alignment);
-    }
+    lpfn = place->lpfn;
+    if (!lpfn || lpfn > man->size >> PAGE_SHIFT)
+        lpfn = man->size >> PAGE_SHIFT;
       vres = kzalloc(sizeof(*vres), GFP_KERNEL);
       if (!vres)
           return -ENOMEM;
       ttm_resource_init(tbo, place, &vres->base);
-    remaining_size = vres->base.size;
       /* bail out quickly if there's likely not enough VRAM for this BO */
-    if (ttm_resource_manager_usage(man) > max_bytes) {
-        r = -ENOSPC;
+    if (ttm_resource_manager_usage(man) > man->size) {
+        err = -ENOSPC;
           goto error_fini;
       }
@@ -96,95 +77,91 @@ static int xe_ttm_vram_mgr_new(struct 
 ttm_resource_manager *man,
       if (place->flags & TTM_PL_FLAG_TOPDOWN)
           vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;
-    if (fpfn || lpfn != man->size)
-        /* Allocate blocks in desired range */
+    if (place->fpfn || lpfn != man->size >> PAGE_SHIFT)
           vres->flags |= DRM_BUDDY_RANGE_ALLOCATION;
-    mutex_lock(&mgr->lock);
-    while (remaining_size) {
-        if (tbo->page_alignment)
-            min_block_size = tbo->page_alignment << PAGE_SHIFT;
-        else
-            min_block_size = mgr->default_page_size;
-
-        XE_BUG_ON(min_block_size < mm->chunk_size);
-
-        /* Limit maximum size to 2GiB due to SG table limitations */
-        size = min(remaining_size, 2ULL << 30);
-
-        if (size >= pages_per_block << PAGE_SHIFT)
-            min_block_size = pages_per_block << PAGE_SHIFT;
-
-        cur_size = size;
-
-        if (fpfn + size != place->lpfn << PAGE_SHIFT) {
-            /*
-             * Except for actual range allocation, modify the size and
-             * min_block_size conforming to continuous flag enablement
-             */
-            if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
-                size = roundup_pow_of_two(size);
-                min_block_size = size;
-            /*
-             * Modify the size value if size is not
-             * aligned with min_block_size
-             */
-            } else if (!IS_ALIGNED(size, min_block_size)) {
-                size = round_up(size, min_block_size);
-            }
-        }
+    XE_BUG_ON(!vres->base.size);
+    size = vres->base.size;
-        r = drm_buddy_alloc_blocks(mm, fpfn,
-                       lpfn,
-                       size,
-                       min_block_size,
-                       &vres->blocks,
-                       vres->flags);
-        if (unlikely(r))
-            goto error_free_blocks;
+    min_page_size = mgr->default_page_size;
+    if (tbo->page_alignment)
+        min_page_size = tbo->page_alignment << PAGE_SHIFT;
-        if (size > remaining_size)
-            remaining_size = 0;
Quoted 8 lines

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 93

Quoted 6 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +4 -2
-        else
-            remaining_size -= size;
+    XE_BUG_ON(min_page_size < mm->chunk_size);
+    XE_BUG_ON(min_page_size > SZ_2G); /* FIXME: sg limit */
+    XE_BUG_ON(size > SZ_2G &&
+          (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS));

Hi Matt,
What scenario is the purpose of testing? Is the purpose of reporting an error when it is a small bar case at the current stage?

XE_BUG_ON(min_page_size < mm->chunk_size) - This one is just a general sanity check, which seemed good to add. The chunk_size is the minimum sized chunk of memory that we can allocate, and so if we ask for something smaller then likely that's a bug.

XE_BUG_ON(min_page_size > SZ_2G) - This is also not small-bar related, but an existing limitation. If you look below the allocation is split into a maximum allocation size of 2G (so that is can always fit in an sg entry without overflowing). If someone in the future asks for page_size

Quoted 1 line

2G, then the alignment might not match, due to this splitting, hence

better treat that as an error. This one has a FIXME, since the code that constructs the sg table could be improved to handle the limitation there, instead of leaking it into the buddy code.

XE_BUG_ON(size > SZ_2G && (vres->base.placement & TTM_PL_FLAG_CONTIGUOUS)) - And this is basically the same as above. We can't have larger than 2G for one chunk AFAICT, so if someone asks for CONTIG for such a case, the underlying allocation might not be contiguous, since we need to make at least two separate allocation requests. But again, I don't think anyone currently needs such a thing, but best to just document/assert such limitations.

Quoted 2 lines

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 94

Quoted 1 line
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +1 -0
+    XE_BUG_ON(!IS_ALIGNED(size, min_page_size));

If it is not aligned, can't we increase it to the aligned size and allocate it?

Yeah, that's one possibility. It's just that the existing behaviour is to leave that to the responsibility of the caller. AFAICT this is for now mostly interesting on platforms where we need 64K min page size for VRAM, and there the object size is meant to be rounded up, so we don't currently expect anyone to trigger this, unless there is a bug.

Quoted 10 lines

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static int xe_ttm_vram_mgr_new(struct ttm_resource_manager *man, · line 103

Quoted 9 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +9 -0
+
+    if (place->fpfn + (vres->base.size >> PAGE_SHIFT) != place->lpfn &&
+        place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+        unsigned long pages;
+
+        size = roundup_pow_of_two(size);
+        min_page_size = size;
+
+        pages = size >> ilog2(mm->chunk_size);

Why did you use ilog2(mm->chunk_size) instead of PAGE_SHIFT here?

Yeah, it looks like the existing i915 code seems to mix chunk_size and PAGE_SHIFT. I think back in the day the buddy allocator just accepted the order, but now is happy with the number of bytes, so doesn't make much sense. Will fix. Thanks for pointing this out.

Quoted 10 lines
Quoted 10 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +3 -6
+        if (pages > lpfn)
+            lpfn = pages;
       }
-    mutex_unlock(&mgr->lock);
-    if (cur_size != size) {
-        struct drm_buddy_block *block;
-        struct list_head *trim_list;
-        u64 original_size;
-        LIST_HEAD(temp);
+    if (size > lpfn << PAGE_SHIFT) {
Quoted 3 lines
Quoted 1 line

In case of DRM_BUDDY_RANGE_ALLOCATION, shouldn't it be compared with size > (lpfn - fpfn) << PAGE_SHIFT?

Yeah, that makes more sense. Also this should be higher up. Thanks for reviewing.

Thanks for comments.
And I should have replied to the v4 patch, but I replied to v2. Please review the emailed reply as a reply to v4. Br,
G.G.

Quoted 186 lines
Quoted 186 lines

Br,

G.G.

Quoted 181 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +48 -22
+        err = -E2BIG; /* don't trigger eviction */
+        goto error_fini;
+    }
-        trim_list = &vres->blocks;
-        original_size = vres->base.size;
+    mutex_lock(&mgr->lock);
+    if (lpfn <= mgr->visible_size && size > mgr->visible_avail) {
+        mutex_unlock(&mgr->lock);
+        err = -ENOSPC;
+        goto error_fini;
+    }
+    remaining_size = size;
+    do {
           /*
-         * If size value is rounded up to min_block_size, trim the last
-         * block to the required size
+         * Limit maximum size to 2GiB due to SG table limitations.
+         * FIXME: Should maybe be handled as part of sg construction.
            */
-        if (!list_is_singular(&vres->blocks)) {
-            block = list_last_entry(&vres->blocks, typeof(*block), 
 link);
-            list_move_tail(&block->link, &temp);
-            trim_list = &temp;
-            /*
-             * Compute the original_size value by subtracting the
-             * last block size with (aligned size - original size)
-             */
-            original_size = drm_buddy_block_size(mm, block) -
-                (size - cur_size);
-        }
+        u64 alloc_size = min_t(u64, remaining_size, SZ_2G);
+
+        err = drm_buddy_alloc_blocks(mm, (u64)place->fpfn << 
 PAGE_SHIFT,
+                         (u64)lpfn << PAGE_SHIFT,
+                         alloc_size,
+                         min_page_size,
+                         &vres->blocks,
+                         vres->flags);
+        if (err)
+            goto error_free_blocks;
-        mutex_lock(&mgr->lock);
-        drm_buddy_block_trim(mm,
-                     original_size,
-                     trim_list);
-        mutex_unlock(&mgr->lock);
+        remaining_size -= alloc_size;
+    } while (remaining_size);
-        if (!list_empty(&temp))
-            list_splice_tail(trim_list, &vres->blocks);
+    if (place->flags & TTM_PL_FLAG_CONTIGUOUS) {
+        if (!drm_buddy_block_trim(mm, vres->base.size, &vres->blocks))
+            size = vres->base.size;
       }
+    if (lpfn <= mgr->visible_size >> PAGE_SHIFT) {
+        vres->used_visible_size = size;
+    } else {
+        struct drm_buddy_block *block;
+
+        list_for_each_entry(block, &vres->blocks, link) {
+            u64 start = drm_buddy_block_offset(block);
+
+            if (start < mgr->visible_size) {
+                u64 end = start + drm_buddy_block_size(mm, block);
+
+                vres->used_visible_size +=
+                    min(end, mgr->visible_size) - start;
+            }
+        }
+    }
+
+    mgr->visible_avail -= vres->used_visible_size;
+    mutex_unlock(&mgr->lock);
+

      if (!(vres->base.placement & TTM_PL_FLAG_CONTIGUOUS) && xe_is_vram_mgr_blocks_contiguous(mm, &vres->blocks)) vres->base.placement |= TTM_PL_FLAG_CONTIGUOUS;

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +17 -3
@@ -213,7 +190,7 @@ static int xe_ttm_vram_mgr_new(struct 
 ttm_resource_manager *man,
       ttm_resource_fini(man, &vres->base);
       kfree(vres);
-    return r;
+    return err;
   }
   static void xe_ttm_vram_mgr_del(struct ttm_resource_manager *man,
@@ -226,6 +203,7 @@ static void xe_ttm_vram_mgr_del(struct 
 ttm_resource_manager *man,
       mutex_lock(&mgr->lock);
       drm_buddy_free_list(mm, &vres->blocks);
+    mgr->visible_avail += vres->used_visible_size;
       mutex_unlock(&mgr->lock);
       ttm_resource_fini(man, res);
@@ -240,6 +218,13 @@ static void xe_ttm_vram_mgr_debug(struct 
 ttm_resource_manager *man,
       struct drm_buddy *mm = &mgr->mm;
       mutex_lock(&mgr->lock);
+    drm_printf(printer, "default_page_size: %lluKiB\n",
+           mgr->default_page_size >> 10);
+    drm_printf(printer, "visible_avail: %lluMiB\n",
+           (u64)mgr->visible_avail >> 20);
+    drm_printf(printer, "visible_size: %lluMiB\n",
+           (u64)mgr->visible_size >> 20);
+
       drm_buddy_print(mm, printer);
       mutex_unlock(&mgr->lock);
       drm_printf(printer, "man size:%llu\n", man->size);
@@ -262,6 +247,8 @@ static void ttm_vram_mgr_fini(struct drm_device 
 *dev, void *arg)
       if (ttm_resource_manager_evict_all(&xe->ttm, man))
           return;
+    WARN_ON_ONCE(mgr->visible_avail != mgr->visible_size);
+
       drm_buddy_fini(&mgr->mm);
       ttm_resource_manager_cleanup(&mgr->manager);
@@ -270,7 +257,8 @@ static void ttm_vram_mgr_fini(struct drm_device 
 *dev, void *arg)
   }
   int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
-               u32 mem_type, u64 size, u64 default_page_size)
+               u32 mem_type, u64 size, u64 io_size,
+               u64 default_page_size)
   {
       struct ttm_resource_manager *man = &mgr->manager;
       int err;
@@ -279,6 +267,8 @@ int __xe_ttm_vram_mgr_init(struct xe_device *xe, 
 struct xe_ttm_vram_mgr *mgr,
       mgr->mem_type = mem_type;
       mutex_init(&mgr->lock);
       mgr->default_page_size = default_page_size;
+    mgr->visible_size = io_size;
+    mgr->visible_avail = io_size;
       ttm_resource_manager_init(man, &xe->ttm, size);
       err = drm_buddy_init(&mgr->mm, man->size, default_page_size);
@@ -298,7 +288,8 @@ int xe_ttm_vram_mgr_init(struct xe_gt *gt, struct 
 xe_ttm_vram_mgr *mgr)
       mgr->gt = gt;
       return __xe_ttm_vram_mgr_init(xe, mgr, XE_PL_VRAM0 + gt->info.vram_id,
-                      gt->mem.vram.size, PAGE_SIZE);
+                      gt->mem.vram.size, gt->mem.vram.io_size,
+                      PAGE_SIZE);
   }
   int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe,
drivers/gpu/drm/xe/xe_ttm_vram_mgr.h +2 -1
index 78f332d26224..35e5367a79fb 100644
@@ -13,7 +13,8 @@ struct xe_device;
   struct xe_gt;
   int __xe_ttm_vram_mgr_init(struct xe_device *xe, struct xe_ttm_vram_mgr *mgr,
-               u32 mem_type, u64 size, u64 default_page_size);
+               u32 mem_type, u64 size, u64 io_size,
+               u64 default_page_size);
   int xe_ttm_vram_mgr_init(struct xe_gt *gt, struct xe_ttm_vram_mgr *mgr);
   int xe_ttm_vram_mgr_alloc_sgt(struct xe_device *xe,
                     struct ttm_resource *res,
drivers/gpu/drm/xe/xe_ttm_vram_mgr_types.h +5 -0
index 39aa2ec1b968..3d9417ff7434 100644
@@ -23,6 +23,10 @@ struct xe_ttm_vram_mgr {
       struct ttm_resource_manager manager;
       /** @mm: DRM buddy allocator which manages the VRAM */
       struct drm_buddy mm;
+    /** @visible_size: Proped size of the CPU visible portion */
+    u64 visible_size;
+    /** @visible_avail: CPU visible portion still unallocated */
+    u64 visible_avail;
       /** @default_page_size: default page size */
       u64 default_page_size;
       /** @lock: protects allocations of VRAM */
@@ -39,6 +43,8 @@ struct xe_ttm_vram_mgr_resource {
       struct ttm_resource base;
       /** @blocks: list of DRM buddy blocks */
       struct list_head blocks;
+    /** @used_visible_size: How many CPU visible bytes this resource 

is using */
+    u64 used_visible_size;
      /** @flags: flags associated with the resource */ unsigned long flags;
  };

#10 lore raw

PATCH v2 6/6 drm/xe/buddy: add compatible and intersects hooks

In reply to Matthew Auld

Copy this from i915. We need .compatible for lmem -> lmem transfers, so they don't just get nooped by ttm, if need to move something from mappable to non-mappble or vice versa. The .intersects is needed for eviction, to determine if a victim resource is worth eviction. e.g if we need mappable space there is no point in evicting a resource that has zero mappable pages.

---
 drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 62 ++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +62 -0
index f703e962f499..8dd33ac65499 100644
@@ -230,9 +230,71 @@ static void xe_ttm_vram_mgr_debug(struct ttm_resource_manager *man,
 	drm_printf(printer, "man size:%llu\n", man->size);
 }
 
+static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager *man,
+				       struct ttm_resource *res,
+				       const struct ttm_place *place,
+				       size_t size)
+{
+	struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+	struct xe_ttm_vram_mgr_resource *vres =
+		to_xe_ttm_vram_mgr_resource(res);
+	struct drm_buddy *mm = &mgr->mm;
+	struct drm_buddy_block *block;
+
+	if (!place->fpfn && !place->lpfn)
+		return true;
+
+	if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+		return vres->used_visible_size > 0;
+
+	list_for_each_entry(block, &vres->blocks, link) {
+		unsigned long fpfn =
+			drm_buddy_block_offset(block) >> PAGE_SHIFT;
+		unsigned long lpfn = fpfn +
+			(drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+		if (place->fpfn < lpfn && place->lpfn > fpfn)
+			return true;
+	}
+
+	return false;
+}
+
+static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager *man,
+				       struct ttm_resource *res,
+				       const struct ttm_place *place,
+				       size_t size)
+{
+	struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+	struct xe_ttm_vram_mgr_resource *vres =
+		to_xe_ttm_vram_mgr_resource(res);
+	struct drm_buddy *mm = &mgr->mm;
+	struct drm_buddy_block *block;
+
+	if (!place->fpfn && !place->lpfn)
+		return true;
+
+	if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+		return vres->used_visible_size == size;
+
+	list_for_each_entry(block, &vres->blocks, link) {
+		unsigned long fpfn =
+			drm_buddy_block_offset(block) >> PAGE_SHIFT;
+		unsigned long lpfn = fpfn +
+			(drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+		if (fpfn < place->fpfn || lpfn > place->lpfn)
+			return false;
+	}
+
+	return true;
+}
+
 static const struct ttm_resource_manager_func xe_ttm_vram_mgr_func = {
 	.alloc	= xe_ttm_vram_mgr_new,
 	.free	= xe_ttm_vram_mgr_del,
+	.intersects = xe_ttm_vram_mgr_intersects,
+	.compatible = xe_ttm_vram_mgr_compatible,
 	.debug	= xe_ttm_vram_mgr_debug
 };
 
Signature · 1 line
2.39.2
#11 lore raw

Re: [Intel-xe] [PATCH v2 6/6] drm/xe/buddy: add compatible and intersects hooks

Quoted 26 lines · Matthew Auld

Copy this from i915. We need .compatible for lmem -> lmem transfers, so they don't just get nooped by ttm, if need to move something from mappable to non-mappble or vice versa. The .intersects is needed for eviction, to determine if a victim resource is worth eviction. e.g if we need mappable space there is no point in evicting a resource that has zero mappable pages.

---
  drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 62 ++++++++++++++++++++++++++++
  1 file changed, 62 insertions(+)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +4 -0
index f703e962f499..8dd33ac65499 100644
@@ -230,9 +230,71 @@ static void xe_ttm_vram_mgr_debug(struct ttm_resource_manager *man,
  	drm_printf(printer, "man size:%llu\n", man->size);
  }
 
+static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager *man,
+				       struct ttm_resource *res,
+				       const struct ttm_place *place,
+				       size_t size)

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static void xe_ttm_vram_mgr_debug(struct ttm_resource_manager *man, · line 246

Quoted 10 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +10 -0
+{
+	struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+	struct xe_ttm_vram_mgr_resource *vres =
+		to_xe_ttm_vram_mgr_resource(res);
+	struct drm_buddy *mm = &mgr->mm;
+	struct drm_buddy_block *block;
+
+	if (!place->fpfn && !place->lpfn)
+		return true;
+Hi Matt,

I understand that ttm_resource_intersects() returns true in the following case,

if (!place || !man->func->intersects)

		return true;

so this line can handle it like this, but in a real scenario, is it possible to have a situation where place->fpfn==0 and place->lpfn==0?

Except for the routine that does the same check in xe_ttm_vram_mgr_compatible(), the rest of it looks good.

br,
G.G.

Quoted 54 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +48 -0
+	if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+		return vres->used_visible_size > 0;
+
+	list_for_each_entry(block, &vres->blocks, link) {
+		unsigned long fpfn =
+			drm_buddy_block_offset(block) >> PAGE_SHIFT;
+		unsigned long lpfn = fpfn +
+			(drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+		if (place->fpfn < lpfn && place->lpfn > fpfn)
+			return true;
+	}
+
+	return false;
+}
+
+static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager *man,
+				       struct ttm_resource *res,
+				       const struct ttm_place *place,
+				       size_t size)
+{
+	struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+	struct xe_ttm_vram_mgr_resource *vres =
+		to_xe_ttm_vram_mgr_resource(res);
+	struct drm_buddy *mm = &mgr->mm;
+	struct drm_buddy_block *block;
+
+	if (!place->fpfn && !place->lpfn)
+		return true;
+
+	if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+		return vres->used_visible_size == size;
+
+	list_for_each_entry(block, &vres->blocks, link) {
+		unsigned long fpfn =
+			drm_buddy_block_offset(block) >> PAGE_SHIFT;
+		unsigned long lpfn = fpfn +
+			(drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+		if (fpfn < place->fpfn || lpfn > place->lpfn)
+			return false;
+	}
+
+	return true;
+}
+
  static const struct ttm_resource_manager_func xe_ttm_vram_mgr_func = {
  	.alloc	= xe_ttm_vram_mgr_new,
  	.free	= xe_ttm_vram_mgr_del,
+	.intersects = xe_ttm_vram_mgr_intersects,
+	.compatible = xe_ttm_vram_mgr_compatible,
  	.debug	= xe_ttm_vram_mgr_debug
  };
 
#12 lore raw

Re: [Intel-xe] [PATCH v2 6/6] drm/xe/buddy: add compatible and intersects hooks

Quoted 41 lines · Gwan-gyeong Mun
Quoted 26 lines · Matthew Auld

Copy this from i915. We need .compatible for lmem -> lmem transfers, so they don't just get nooped by ttm, if need to move something from mappable to non-mappble or vice versa. The .intersects is needed for eviction, to determine if a victim resource is worth eviction. e.g if we need mappable space there is no point in evicting a resource that has zero mappable pages.

---
  drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 62 ++++++++++++++++++++++++++++

  1 file changed, 62 insertions(+)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +4 -0
index f703e962f499..8dd33ac65499 100644
@@ -230,9 +230,71 @@ static void xe_ttm_vram_mgr_debug(struct 
 ttm_resource_manager *man,
       drm_printf(printer, "man size:%llu\n", man->size);
   }
+static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager *man,
+                       struct ttm_resource *res,
+                       const struct ttm_place *place,
+                       size_t size)

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static void xe_ttm_vram_mgr_debug(struct · line 246

Quoted 10 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +10 -0
+{
+    struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+    struct xe_ttm_vram_mgr_resource *vres =
+        to_xe_ttm_vram_mgr_resource(res);
+    struct drm_buddy *mm = &mgr->mm;
+    struct drm_buddy_block *block;
+
+    if (!place->fpfn && !place->lpfn)
+        return true;
+Hi Matt,

I understand that ttm_resource_intersects() returns true in the following case,

Quoted 4 lines

if (!place || !man->func->intersects)
        return true;

so this line can handle it like this, but in a real scenario, is it possible to have a situation where place->fpfn==0 and place->lpfn==0?

Yeah, fpfn = 0 and lpfn = 0 is the common case, where the user doesn't care specifically where it is placed in VRAM. Therefore everything intersects (potentially valuable to evict), and is also always going to be compatible, so we just always return true.

Quoted 58 lines

Except for the routine that does the same check in xe_ttm_vram_mgr_compatible(), the rest of it looks good.

br,
G.G.

Quoted 53 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +48 -0
+    if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+        return vres->used_visible_size > 0;
+
+    list_for_each_entry(block, &vres->blocks, link) {
+        unsigned long fpfn =
+            drm_buddy_block_offset(block) >> PAGE_SHIFT;
+        unsigned long lpfn = fpfn +
+            (drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+        if (place->fpfn < lpfn && place->lpfn > fpfn)
+            return true;
+    }
+
+    return false;
+}
+
+static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager *man,
+                       struct ttm_resource *res,
+                       const struct ttm_place *place,
+                       size_t size)
+{
+    struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+    struct xe_ttm_vram_mgr_resource *vres =
+        to_xe_ttm_vram_mgr_resource(res);
+    struct drm_buddy *mm = &mgr->mm;
+    struct drm_buddy_block *block;
+
+    if (!place->fpfn && !place->lpfn)
+        return true;
+
+    if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+        return vres->used_visible_size == size;
+
+    list_for_each_entry(block, &vres->blocks, link) {
+        unsigned long fpfn =
+            drm_buddy_block_offset(block) >> PAGE_SHIFT;
+        unsigned long lpfn = fpfn +
+            (drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+        if (fpfn < place->fpfn || lpfn > place->lpfn)
+            return false;
+    }
+
+    return true;
+}
+
   static const struct ttm_resource_manager_func xe_ttm_vram_mgr_func = {
       .alloc    = xe_ttm_vram_mgr_new,
       .free    = xe_ttm_vram_mgr_del,
+    .intersects = xe_ttm_vram_mgr_intersects,
+    .compatible = xe_ttm_vram_mgr_compatible,

      .debug    = xe_ttm_vram_mgr_debug
  };

Reviewed-by
#13 lore raw

Re: [Intel-xe] [PATCH v2 6/6] drm/xe/buddy: add compatible and intersects hooks

Quoted 43 lines · Matthew Auld
Quoted 42 lines · Gwan-gyeong Mun
Quoted 27 lines · Matthew Auld

Copy this from i915. We need .compatible for lmem -> lmem transfers, so they don't just get nooped by ttm, if need to move something from mappable to non-mappble or vice versa. The .intersects is needed for eviction, to determine if a victim resource is worth eviction. e.g if we need mappable space there is no point in evicting a resource that has zero mappable pages.

---
  drivers/gpu/drm/xe/xe_ttm_vram_mgr.c | 62 ++++++++++++++++++++++++++++

  1 file changed, 62 insertions(+)
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +4 -0
index f703e962f499..8dd33ac65499 100644
@@ -230,9 +230,71 @@ static void xe_ttm_vram_mgr_debug(struct 
 ttm_resource_manager *man,
       drm_printf(printer, "man size:%llu\n", man->size);
   }
+static bool xe_ttm_vram_mgr_intersects(struct ttm_resource_manager 
 *man,
+                       struct ttm_resource *res,
+                       const struct ttm_place *place,
+                       size_t size)

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c static void xe_ttm_vram_mgr_debug(struct · line 247

Quoted 10 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +10 -0
+{
+    struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+    struct xe_ttm_vram_mgr_resource *vres =
+        to_xe_ttm_vram_mgr_resource(res);
+    struct drm_buddy *mm = &mgr->mm;
+    struct drm_buddy_block *block;
+
+    if (!place->fpfn && !place->lpfn)
+        return true;
+Hi Matt,

I understand that ttm_resource_intersects() returns true in the following case,

Quoted 7 lines
Quoted 4 lines

if (!place || !man->func->intersects)
         return true;

so this line can handle it like this, but in a real scenario, is it possible to have a situation where place->fpfn==0 and place->lpfn==0?

Yeah, fpfn = 0 and lpfn = 0 is the common case, where the user doesn't care specifically where it is placed in VRAM. Therefore everything intersects (potentially valuable to evict), and is also always going to be compatible, so we just always return true.

Thanks for the detailed explanation.

Br,
G.G.

Quoted 59 lines
Quoted 59 lines

Except for the routine that does the same check in xe_ttm_vram_mgr_compatible(), the rest of it looks good.

br,
G.G.

Quoted 54 lines
drivers/gpu/drm/xe/xe_ttm_vram_mgr.c +48 -0
+    if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+        return vres->used_visible_size > 0;
+
+    list_for_each_entry(block, &vres->blocks, link) {
+        unsigned long fpfn =
+            drm_buddy_block_offset(block) >> PAGE_SHIFT;
+        unsigned long lpfn = fpfn +
+            (drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+        if (place->fpfn < lpfn && place->lpfn > fpfn)
+            return true;
+    }
+
+    return false;
+}
+
+static bool xe_ttm_vram_mgr_compatible(struct ttm_resource_manager 
 *man,
+                       struct ttm_resource *res,
+                       const struct ttm_place *place,
+                       size_t size)
+{
+    struct xe_ttm_vram_mgr *mgr = to_xe_ttm_vram_mgr(man);
+    struct xe_ttm_vram_mgr_resource *vres =
+        to_xe_ttm_vram_mgr_resource(res);
+    struct drm_buddy *mm = &mgr->mm;
+    struct drm_buddy_block *block;
+
+    if (!place->fpfn && !place->lpfn)
+        return true;
+
+    if (!place->fpfn && place->lpfn == mgr->visible_size >> PAGE_SHIFT)
+        return vres->used_visible_size == size;
+
+    list_for_each_entry(block, &vres->blocks, link) {
+        unsigned long fpfn =
+            drm_buddy_block_offset(block) >> PAGE_SHIFT;
+        unsigned long lpfn = fpfn +
+            (drm_buddy_block_size(mm, block) >> PAGE_SHIFT);
+
+        if (fpfn < place->fpfn || lpfn > place->lpfn)
+            return false;
+    }
+
+    return true;
+}
+
   static const struct ttm_resource_manager_func xe_ttm_vram_mgr_func = {
       .alloc    = xe_ttm_vram_mgr_new,
       .free    = xe_ttm_vram_mgr_del,
+    .intersects = xe_ttm_vram_mgr_intersects,
+    .compatible = xe_ttm_vram_mgr_compatible,

      .debug    = xe_ttm_vram_mgr_debug
  };