Re: [PATCH i-g-t v3] tests/intel/xe_vm: Validate host memory for overcommit tests

["Sharma, Nishit" <nishit.sharma@intel.com>]

On 10/13/2026 1:05 PM, Sobin Thomas wrote:
> The amount of VRAM available for the overcommit tests varies
> across platforms. As a result, the host RAM space required to
> support the overcommit workload also varies based on eviction.
>
> Query the platform RAM space and visible VRAM before running
> overcommit tests. Skip if the expected eviction footprint
> exceeds 50% of available RAM.
>
> v2:
> - Base host-memory requirement based on the run time budget
> - Drop use vram and SRAM Handling; all the cases are VRAM
>
> v3:
> - Moved BO calculation at the caller side of test_vm_overcommit
> - Modified the check keeping total bo size instead of swap
>    space check and multiplier (Nishit)
>
> Signed-off-by: Sobin Thomas <sobin.thomas@intel.com>
> ---
>   tests/intel/xe_vm.c | 93 +++++++++++++++++++++++++++------------------
>   1 file changed, 55 insertions(+), 38 deletions(-)
>
> diff --git a/tests/intel/xe_vm.c b/tests/intel/xe_vm.c
> index a0a6616c3..d1157803d 100644
> --- a/tests/intel/xe_vm.c
> +++ b/tests/intel/xe_vm.c
> @@ -20,7 +20,9 @@
>   #include "xe/xe_query.h"
>   #include "xe/xe_spin.h"
>   #include <string.h>
> +
>   #define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
> +#define OVERCOMMIT_BO_SIZE SZ_64M
>   
>   enum overcommit_stage {
>   	EXPECT_NONE,
> @@ -2385,10 +2387,10 @@ static void invalid_vm_id(int fd)
>   }
>   
>   static enum overcommit_stage create_data_bos(int fd, uint32_t vm, uint32_t *bos, int num_bos,
> -					     uint64_t nf_bo_size, bool use_vram, uint64_t data_addr,
> -					     uint32_t bo_flags, int gt_id, int *num_bound_out)
> +					     uint64_t data_addr, uint32_t bo_flags, int gt_id,
> +					     int *num_bound_out)
>   {
> -	uint32_t placement = use_vram ? vram_memory(fd, gt_id) : system_memory(fd);
> +	uint32_t placement = vram_memory(fd, gt_id);
>   
>   	*num_bound_out = 0;
>   
> @@ -2397,7 +2399,7 @@ static enum overcommit_stage create_data_bos(int fd, uint32_t vm, uint32_t *bos,
>   		int create_ret = 0;
>   
>   		/* Create BO using the case's create function */
> -		create_ret = __xe_bo_create(fd, vm, nf_bo_size, placement,
> +		create_ret = __xe_bo_create(fd, vm, OVERCOMMIT_BO_SIZE, placement,
>   					    bo_flags, NULL, &bos[i]);
>   
>   		if (create_ret) {
> @@ -2411,7 +2413,8 @@ static enum overcommit_stage create_data_bos(int fd, uint32_t vm, uint32_t *bos,
>   		}
>   
>   		bind_err = __xe_vm_bind_lr_sync(fd, vm, bos[i], 0, data_addr +
> -						((uint64_t)i * nf_bo_size), nf_bo_size, 0);
> +						((uint64_t)i * OVERCOMMIT_BO_SIZE),
> +						OVERCOMMIT_BO_SIZE, 0);
>   		if (bind_err) {
>   			if (errno == ENOMEM || errno == ENOSPC) {
>   				igt_debug("BO bind failed at %d/%d - error %d (%s), %d BOs bound\n",
> @@ -2425,21 +2428,21 @@ static enum overcommit_stage create_data_bos(int fd, uint32_t vm, uint32_t *bos,
>   		*num_bound_out = i + 1;
>   		igt_debug("Created and bound BO %d/%d at 0x%llx\n",
>   			  i + 1, num_bos,
> -			  (unsigned long long)(data_addr + ((uint64_t)i * nf_bo_size)));
> +			  (unsigned long long)(data_addr + ((uint64_t)i * OVERCOMMIT_BO_SIZE)));
>   	}
>   	return EXPECT_NONE;
>   }
>   
> -static void verify_bo(int fd, uint32_t *bos, int num_bos, uint64_t nf_bo_size, uint64_t stride)
> +static void verify_bo(int fd, uint32_t *bos, int num_bos, uint64_t stride)
>   {
>   	for (int i = 0; i < num_bos; i++) {
>   		uint32_t *verify_data;
>   		int errors = 0;
>   
> -		verify_data = xe_bo_map(fd, bos[i], nf_bo_size);
> +		verify_data = xe_bo_map(fd, bos[i], OVERCOMMIT_BO_SIZE);
>   		igt_assert(verify_data);
>   
> -		for (int off = 0; off < nf_bo_size; off += stride) {
> +		for (int off = 0; off < OVERCOMMIT_BO_SIZE; off += stride) {
>   			uint32_t expected = 0xBB;
>   			uint32_t actual = *(uint32_t *)((char *)verify_data + off);
>   
> @@ -2451,7 +2454,7 @@ static void verify_bo(int fd, uint32_t *bos, int num_bos, uint64_t nf_bo_size, u
>   			}
>   		}
>   
> -		munmap(verify_data, nf_bo_size);
> +		munmap(verify_data, OVERCOMMIT_BO_SIZE);
>   		igt_assert_f(errors == 0, "Data verification failed for BO %d with %d errors\n",
>   			     i, errors);
>   	}
> @@ -2497,7 +2500,6 @@ struct vm_overcommit_case {
>   	const char *name;
>   	uint32_t vm_flags;
>   	uint32_t bo_flags;
> -	bool use_vram;
>   	uint64_t data_addr;
>   	int overcommit_mult;
>   	enum overcommit_stage expected_stage;
> @@ -2510,7 +2512,6 @@ static const struct vm_overcommit_case overcommit_cases[] = {
>   		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
>   		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
>   			    DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
> -		.use_vram = true,
>   		.data_addr = 0x1a0000,
>   		.overcommit_mult = 2,
>   		.expected_stage = EXPECT_BIND,
> @@ -2520,7 +2521,6 @@ static const struct vm_overcommit_case overcommit_cases[] = {
>   		.name = "vram-lr-external-nodefer",
>   		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
>   		.bo_flags = DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
> -		.use_vram = true,
>   		.data_addr = 0x1a0000,
>   		.overcommit_mult = 2,
>   		.expected_stage = EXPECT_BIND,
> @@ -2531,7 +2531,6 @@ static const struct vm_overcommit_case overcommit_cases[] = {
>   		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE |
>   			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
>   		.bo_flags = DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
> -		.use_vram = true,
>   		.data_addr = 0x300000000,
>   		.overcommit_mult = 2,
>   		.expected_stage = EXPECT_NONE,
> @@ -2541,7 +2540,6 @@ static const struct vm_overcommit_case overcommit_cases[] = {
>   		.name = "vram-no-lr",
>   		.vm_flags = 0,
>   		.bo_flags = DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
> -		.use_vram = true,
>   		.data_addr = 0x300000000,
>   		.overcommit_mult = 2,
>   		.expected_stage = EXPECT_EXEC,
> @@ -2553,7 +2551,6 @@ static const struct vm_overcommit_case overcommit_cases[] = {
>   			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
>   		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
>   			    DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
> -		.use_vram = true,
>   		.data_addr = 0x300000000,
>   		.overcommit_mult = 2,
>   		/*
> @@ -2568,17 +2565,16 @@ static const struct vm_overcommit_case overcommit_cases[] = {
>   
>   static void
>   test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
> -		   const struct vm_overcommit_case *c,
> -		   uint64_t system_size, uint64_t vram_size)
> +		   const struct vm_overcommit_case *c, int num_bos)
>   {
>   	uint32_t vm = 0, *bos, batch_bo = 0, exec_queue = 0, bind_exec_queue = 0;
>   	uint64_t sync_addr = 0x1000000000, batch_addr = 0x200000000;
> -	int i, num_bos, num_bound = 0, bind_err, create_ret, wait_ret;
> -	size_t sync_size, nf_bo_size = 64 * 1024 * 1024;
> +	int i, num_bound = 0, bind_err, create_ret, wait_ret;
>   	enum overcommit_stage actual_stage = EXPECT_NONE;
> -	uint64_t stride = 1024 * 1024, base_size;
> -	uint64_t overcommit_size, off, data_addr;
> +	uint64_t off, data_addr;
>   	int64_t timeout = 20 * NSEC_PER_SEC;
> +	uint64_t stride = SZ_1M;
> +	size_t sync_size;
>   	struct drm_xe_sync bind_sync[1] = {
>   		{
>   			.type = DRM_XE_SYNC_TYPE_USER_FENCE,
> @@ -2607,18 +2603,10 @@ test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
>   	uint64_t *user_fence_sync = NULL;
>   
>   	data_addr = c->data_addr;
> -	base_size = c->use_vram ? vram_size : system_size;
> -	overcommit_size = ALIGN((uint64_t)(base_size * c->overcommit_mult), 4096);
>   
> -	num_bos = (overcommit_size / nf_bo_size) + 1;
>   	bos = calloc(num_bos, sizeof(*bos));
>   	igt_assert(bos);
>   
> -	igt_debug("Overcommit test: allocating %d BOs of %llu MB each",
> -		  num_bos, (unsigned long long)(nf_bo_size >> 20));
> -	igt_debug("total=%llu MB, vram=%llu MB\n",
> -		  (unsigned long long)(num_bos * nf_bo_size >> 20),
> -		  (unsigned long long)(vram_size >> 20));
>   	/* Create VM with appropriate flags */
>   	vm = xe_vm_create(fd, c->vm_flags, 0);
>   	igt_assert(vm);
> @@ -2632,8 +2620,10 @@ test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
>   	exec_sync->addr = to_user_pointer(&user_fence_sync[0]);
>   
>   	/* Create and bind data BOs */
> -	actual_stage = create_data_bos(fd, vm, bos, num_bos, nf_bo_size, c->use_vram, data_addr,
> +	actual_stage = create_data_bos(fd, vm, bos, num_bos, data_addr,
>   				       c->bo_flags, eci->gt_id, &num_bound);
> +	igt_debug("Overcommit BO creation: case=%s actual_stage=%d num_bound=%d/%d\n",
> +		  c->name, actual_stage, num_bound, num_bos);
>   	/*
>   	 * On EXPECT_CREATE nothing was bound so bail out entirely.
>   	 * On EXPECT_BIND with no BOs bound there is nothing to execute either.
> @@ -2680,8 +2670,8 @@ test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
>   		igt_debug("Writing to BO %d/%d via GPU\n", i + 1, num_bos);
>   		timeout = 20 * NSEC_PER_SEC;
>   
> -		for (off = 0; off < nf_bo_size; off += stride) {
> -			uint64_t target_addr = data_addr + ((uint64_t)i * nf_bo_size) + off;
> +		for (off = 0; off < OVERCOMMIT_BO_SIZE; off += stride) {
> +			uint64_t target_addr = data_addr + ((uint64_t)i * OVERCOMMIT_BO_SIZE) + off;
>   			int b_idx = 0;
>   
>   			batch_data->batch[b_idx++] = MI_STORE_DWORD_IMM_GEN4;
> @@ -2725,7 +2715,7 @@ test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
>   
>   	/* Verify GPU writes for bound BOs */
>   	if (actual_stage == EXPECT_NONE || (actual_stage == EXPECT_BIND && num_bound > 0))
> -		verify_bo(fd, bos, num_bound, nf_bo_size, stride);
> +		verify_bo(fd, bos, num_bound, stride);
>   
>   check_and_cleanup:
>   	igt_assert_f(actual_stage == c->expected_stage, "Expected overcommit at stage %d, got %d\n",
> @@ -3499,10 +3489,37 @@ int igt_main()
>   		const char *mode = (c->vm_flags & DRM_XE_VM_CREATE_FLAG_FAULT_MODE) ?
>   					"fault" : "nonfault";
>   		igt_subtest_f("overcommit-%s-%s", mode, c->name) {
> -			igt_require(xe_has_vram(fd));
> -			igt_require(xe_visible_vram_size(fd, 0));
> -			test_vm_overcommit(fd, hwe_non_copy, c, (igt_get_avail_ram_mb() << 20),
> -					   xe_visible_vram_size(fd, 0));
> +			uint64_t vram_size, vram_mb, avail_ram_mb, ram_mb, required_mb;
> +			uint64_t overcommit_size, total_bo_size;
> +			int num_bos;
> +
> +			vram_size = xe_visible_vram_size(fd, 0);
> +			igt_require(vram_size);
> +			vram_mb = vram_size >> 20;
> +			avail_ram_mb = igt_get_avail_ram_mb();
> +			ram_mb = igt_get_total_ram_mb();
> +
> +			overcommit_size = ALIGN(vram_size * c->overcommit_mult, 4096);
> +			num_bos = overcommit_size / OVERCOMMIT_BO_SIZE + 1;
> +			total_bo_size = (uint64_t)num_bos * OVERCOMMIT_BO_SIZE;
> +
> +			igt_assert_lt_u64(vram_size, total_bo_size);
> +
> +			igt_debug("Overcommit %s-%s: mult=%d ram=%" PRIu64 "MiB\n",
> +				  mode, c->name, c->overcommit_mult, ram_mb);
> +			igt_debug("Overcommit avail_ram=%" PRIu64 "MiB vram=%" PRIu64 "MiB\n",
> +				  avail_ram_mb, vram_mb);
> +			igt_debug("Overcommit size=%" PRIu64 "MiB num_bos=%d\n",
> +				  overcommit_size >> 20, num_bos);
> +			igt_debug("Overcommit bo_size=%dMiB total=%" PRIu64 "MiB\n",
> +				  OVERCOMMIT_BO_SIZE >> 20, total_bo_size >> 20);
> +
> +			required_mb = ALIGN(DIV_ROUND_UP(total_bo_size - vram_size,
> +							 SZ_1M), 64) + 64;
> +			igt_require_f(required_mb <= avail_ram_mb * 50 / 100,
> +				      "Need %" PRIu64 "MiB, > 50%% of avail RAM %" PRIu64 "MiB\n",
> +				      required_mb, avail_ram_mb);
> +			test_vm_overcommit(fd, hwe_non_copy, c, num_bos);
>   		}
>   	}
>   

LGTM:

Reviewed-by: Nishit Sharma <nishit.sharma@intel.com>