intel: Make memory heaps consistent between KMDs

Xe KMD reports SMEM size as half of RAM while i915 returns the whole
RAM size, so to keep it consistent here adjusting the values
returned by i915 KMD.

The free i915 SMEM also needs to be ajusted but as this is needed by
both KMDs because KMD uAPIs only reports free memory for applications
running elevated privileges, so this was moved to
intel_device_info_ajust_memory() to be shared by both KMD backends.

sram.mappable.size asserts had to be removed from i915 code paths
because of this adjustment.

anv_compute_sys_heap_size() was dropped in ANV and reduce in HASVK
because adjustments are now done in intel/dev level.

Signed-off-by: José Roberto de Souza <jose.souza@intel.com>
Reviewed-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26567>

src/intel/dev/i915/intel_device_info.c

@@ -336,7 +336,9 @@ intel_device_info_i915_query_regions(struct intel_device_info *devinfo, int fd,
       /* If the memory region uAPI query is not available, try to generate some
        * numbers out of os_* utils for sram only.
        */
-      return intel_device_info_compute_system_memory(devinfo, false);
+      bool ret = intel_device_info_compute_system_memory(devinfo, false);
+      devinfo->mem.sram.mappable.size /= 2;
+      return ret;
    }
 
    for (int i = 0; i < meminfo->num_regions; i++) {
@@ -346,18 +348,19 @@ intel_device_info_i915_query_regions(struct intel_device_info *devinfo, int fd,
          if (!update) {
             devinfo->mem.sram.mem.klass = mem->region.memory_class;
             devinfo->mem.sram.mem.instance = mem->region.memory_instance;
-            devinfo->mem.sram.mappable.size = mem->probed_size;
+            /* i915 reports the whole RAM as SRAM size but Xe KMD only reports
+             * half, so adjusting i915 to follow Xe KMD.
+             */
+            devinfo->mem.sram.mappable.size = mem->probed_size / 2;
          } else {
             assert(devinfo->mem.sram.mem.klass == mem->region.memory_class);
             assert(devinfo->mem.sram.mem.instance == mem->region.memory_instance);
-            assert(devinfo->mem.sram.mappable.size == mem->probed_size);
+            assert(devinfo->mem.sram.mappable.size == mem->probed_size / 2);
          }
-         /* The kernel uAPI only reports an accurate unallocated_size value
-          * for I915_MEMORY_CLASS_DEVICE.
+         /* if running without elevated privileges i915 reports
+          * unallocated_size == probed_size
           */
-         uint64_t available;
-         if (os_get_available_system_memory(&available))
-            devinfo->mem.sram.mappable.free = MIN2(available, mem->probed_size);
+         devinfo->mem.sram.mappable.free = mem->unallocated_size;
          break;
       }
       case I915_MEMORY_CLASS_DEVICE:

src/intel/dev/intel_device_info.c

@@ -1454,23 +1454,31 @@ intel_get_device_info_from_pci_id(int pci_id,
 bool
 intel_device_info_compute_system_memory(struct intel_device_info *devinfo, bool update)
 {
-   uint64_t total_phys;
-   if (!os_get_total_physical_memory(&total_phys))
-      return false;
+   if (!update) {
+      if (!os_get_total_physical_memory(&devinfo->mem.sram.mappable.size))
+         return false;
+   }
 
-   uint64_t available = 0;
-   os_get_available_system_memory(&available);
-
-   if (!update)
-      devinfo->mem.sram.mappable.size = total_phys;
-   else
-      assert(devinfo->mem.sram.mappable.size == total_phys);
-
-   devinfo->mem.sram.mappable.free = available;
+   os_get_available_system_memory(&devinfo->mem.sram.mappable.free);
 
    return true;
 }
 
+static void
+intel_device_info_ajust_memory(struct intel_device_info *devinfo)
+{
+   uint64_t available;
+
+   /* Applications running without elevated privileges don't report valid
+    * numbers for free sram
+    */
+   if (os_get_available_system_memory(&available)) {
+      devinfo->mem.sram.mappable.free = MIN3(devinfo->mem.sram.mappable.free,
+                                             devinfo->mem.sram.mappable.size,
+                                             available);
+   }
+}
+
 static void
 init_max_scratch_ids(struct intel_device_info *devinfo)
 {
@@ -1683,6 +1691,8 @@ intel_get_device_info_from_fd(int fd, struct intel_device_info *devinfo)
       return false;
    }
 
+   intel_device_info_ajust_memory(devinfo);
+
    /* Gfx7 and older do not support EU/Subslice info */
    assert(devinfo->subslice_total >= 1 || devinfo->ver <= 7);
    devinfo->subslice_total = MAX2(devinfo->subslice_total, 1);
@@ -1714,6 +1724,9 @@ bool intel_device_info_update_memory_info(struct intel_device_info *devinfo, int
    default:
       ret = false;
    }
+
+   if (ret)
+      intel_device_info_ajust_memory(devinfo);
    return ret;
 }
 

src/intel/dev/xe/intel_device_info.c

@@ -99,6 +99,7 @@ intel_device_info_xe_query_regions(int fd, struct intel_device_info *devinfo,
             assert(devinfo->mem.sram.mem.instance == region->instance);
             assert(devinfo->mem.sram.mappable.size == region->total_size);
          }
+         /* if running without elevated privileges Xe reports used == 0 */
          devinfo->mem.sram.mappable.free = region->total_size - region->used;
          break;
       }

src/intel/vulkan/anv_device.c

@@ -1726,30 +1726,13 @@ get_properties(const struct anv_physical_device *pdevice,
    }
 }
 
-static uint64_t
-anv_compute_sys_heap_size(struct anv_physical_device *device,
-                          uint64_t total_ram)
-{
-   /* We don't want to burn too much ram with the GPU.  If the user has 4GiB
-    * or less, we use at most half.  If they have more than 4GiB, we use 3/4.
-    */
-   uint64_t available_ram;
-   if (total_ram <= 4ull * 1024ull * 1024ull * 1024ull)
-      available_ram = total_ram / 2;
-   else
-      available_ram = total_ram * 3 / 4;
-
-   return available_ram;
-}
-
 static VkResult MUST_CHECK
 anv_init_meminfo(struct anv_physical_device *device, int fd)
 {
    const struct intel_device_info *devinfo = &device->info;
 
    device->sys.region = &devinfo->mem.sram.mem;
-   device->sys.size =
-      anv_compute_sys_heap_size(device, devinfo->mem.sram.mappable.size);
+   device->sys.size = devinfo->mem.sram.mappable.size;
    device->sys.available = devinfo->mem.sram.mappable.free;
 
    device->vram_mappable.region = &devinfo->mem.vram.mem;

src/intel/vulkan_hasvk/anv_device.c

@@ -648,18 +648,9 @@ get_features(const struct anv_physical_device *pdevice,
 
 static uint64_t
 anv_compute_sys_heap_size(struct anv_physical_device *device,
-                          uint64_t total_ram)
+                          uint64_t available_ram)
 {
-   /* We don't want to burn too much ram with the GPU.  If the user has 4GiB
-    * or less, we use at most half.  If they have more than 4GiB, we use 3/4.
-    */
-   uint64_t available_ram;
-   if (total_ram <= 4ull * 1024ull * 1024ull * 1024ull)
-      available_ram = total_ram / 2;
-   else
-      available_ram = total_ram * 3 / 4;
-
-   /* We also want to leave some padding for things we allocate in the driver,
+   /* We want to leave some padding for things we allocate in the driver,
     * so don't go over 3/4 of the GTT either.
     */
    available_ram = MIN2(available_ram, device->gtt_size * 3 / 4);