Change return type from unique_ptr to vector

In some of the drm functions there is a pattern to store array in unique_ptr and pass it's length as an argument. This commit simplifies this. Signed-off-by: Szymon Morek <szymon.morek@intel.com>
2026-01-05 09:09:04 +08:00 · 2021-12-22 14:25:53 +00:00
parent 9be5efe4f7
commit d9f6757378
25 changed files with 187 additions and 228 deletions
--- a/shared/source/os_interface/linux/drm_neo.cpp
+++ b/shared/source/os_interface/linux/drm_neo.cpp
@@ -600,7 +600,7 @@ bool Drm::isi915Version(int fileDescriptor) {
    return strcmp(name, "i915") == 0;
 }

-std::unique_ptr<uint8_t[]> Drm::query(uint32_t queryId, uint32_t queryItemFlags, int32_t &length) {
+std::vector<uint8_t> Drm::query(uint32_t queryId, uint32_t queryItemFlags) {
    drm_i915_query query{};
    drm_i915_query_item queryItem{};
    queryItem.query_id = queryId;
@@ -608,23 +608,19 @@ std::unique_ptr<uint8_t[]> Drm::query(uint32_t queryId, uint32_t queryItemFlags,
    queryItem.flags = queryItemFlags;
    query.items_ptr = reinterpret_cast<__u64>(&queryItem);
    query.num_items = 1;
-    length = 0;

    auto ret = this->ioctl(DRM_IOCTL_I915_QUERY, &query);
    if (ret != 0 || queryItem.length <= 0) {
-        return nullptr;
+        return {};
    }

-    auto data = std::make_unique<uint8_t[]>(queryItem.length);
-    memset(data.get(), 0, queryItem.length);
-    queryItem.data_ptr = castToUint64(data.get());
+    auto data = std::vector<uint8_t>(queryItem.length, 0);
+    queryItem.data_ptr = castToUint64(data.data());

    ret = this->ioctl(DRM_IOCTL_I915_QUERY, &query);
    if (ret != 0 || queryItem.length <= 0) {
-        return nullptr;
+        return {};
    }
-
-    length = queryItem.length;
    return data;
 }

@@ -915,16 +911,13 @@ int Drm::waitUserFence(uint32_t ctxId, uint64_t address, uint64_t value, ValueWi
 }

 bool Drm::querySystemInfo() {
-    auto length = 0;
    auto request = IoctlHelper::get(this)->getHwConfigIoctlVal();
-    auto deviceBlobQuery = this->query(request, DrmQueryItemFlags::empty, length);
-    auto deviceBlob = reinterpret_cast<uint32_t *>(deviceBlobQuery.get());
-    if (!deviceBlob) {
+    auto deviceBlobQuery = this->query(request, DrmQueryItemFlags::empty);
+    if (deviceBlobQuery.empty()) {
        PRINT_DEBUG_STRING(DebugManager.flags.PrintDebugMessages.get(), stdout, "%s", "INFO: System Info query failed!\n");
        return false;
    }
-    this->systemInfo.reset(new SystemInfo(deviceBlob, length));
-
+    this->systemInfo.reset(new SystemInfo(deviceBlobQuery));
    return true;
 }

--- a/shared/source/os_interface/linux/drm_neo.h
+++ b/shared/source/os_interface/linux/drm_neo.h
@@ -249,7 +249,7 @@ class Drm : public DriverModel {
    uint32_t getPciDomain() {
        return pciDomain;
    }
-    MOCKABLE_VIRTUAL std::unique_ptr<uint8_t[]> getMemoryRegions();
+    MOCKABLE_VIRTUAL std::vector<uint8_t> getMemoryRegions();

  protected:
    Drm(std::unique_ptr<HwDeviceIdDrm> &&hwDeviceIdIn, RootDeviceEnvironment &rootDeviceEnvironment);
@@ -260,7 +260,7 @@ class Drm : public DriverModel {
    std::string generateUUID();
    std::string generateElfUUID(const void *data);
    std::string getSysFsPciPath();
-    std::unique_ptr<uint8_t[]> query(uint32_t queryId, uint32_t queryItemFlags, int32_t &length);
+    std::vector<uint8_t> query(uint32_t queryId, uint32_t queryItemFlags);
    void printIoctlStatistics();

 #pragma pack(1)
--- a/shared/source/os_interface/linux/drm_query.cpp
+++ b/shared/source/os_interface/linux/drm_query.cpp
@@ -33,27 +33,24 @@ std::string getIoctlParamStringRemaining(int param) {
 } // namespace IoctlToStringHelper

 bool Drm::queryEngineInfo(bool isSysmanEnabled) {
-    auto length = 0;
-    auto dataQuery = this->query(DRM_I915_QUERY_ENGINE_INFO, DrmQueryItemFlags::empty, length);
-    auto data = reinterpret_cast<drm_i915_query_engine_info *>(dataQuery.get());
-    if (data) {
-        this->engineInfo.reset(new EngineInfoImpl(data->engines, data->num_engines));
-        return true;
+    auto dataQuery = this->query(DRM_I915_QUERY_ENGINE_INFO, DrmQueryItemFlags::empty);
+    if (dataQuery.empty()) {
+        return false;
    }
-    return false;
+    auto data = reinterpret_cast<drm_i915_query_engine_info *>(dataQuery.data());
+    this->engineInfo.reset(new EngineInfoImpl(data->engines, data->num_engines));
+    return true;
 }

-std::unique_ptr<uint8_t[]> Drm::getMemoryRegions() {
-    return nullptr;
+std::vector<uint8_t> Drm::getMemoryRegions() {
+    return {};
 }

 bool Drm::queryMemoryInfo() {
-    auto length = 0;
-    auto dataQuery = this->query(DRM_I915_QUERY_MEMORY_REGIONS, DrmQueryItemFlags::empty, length);
-    if (dataQuery) {
-        auto numRegions = 0u;
-        auto memRegions = IoctlHelper::get(this)->translateToMemoryRegions(dataQuery.get(), length, numRegions);
-        this->memoryInfo.reset(new MemoryInfo(memRegions.get(), numRegions));
+    auto dataQuery = this->query(DRM_I915_QUERY_MEMORY_REGIONS, DrmQueryItemFlags::empty);
+    if (!dataQuery.empty()) {
+        auto memRegions = IoctlHelper::get(this)->translateToMemoryRegions(dataQuery);
+        this->memoryInfo.reset(new MemoryInfo(memRegions));
        return true;
    }
    return false;
@@ -77,13 +74,11 @@ int Drm::createDrmVirtualMemory(uint32_t &drmVmId) {
 }

 bool Drm::queryTopology(const HardwareInfo &hwInfo, QueryTopologyData &topologyData) {
-    int32_t length;
-    auto dataQuery = this->query(DRM_I915_QUERY_TOPOLOGY_INFO, DrmQueryItemFlags::topology, length);
-    auto data = reinterpret_cast<drm_i915_query_topology_info *>(dataQuery.get());
-
-    if (!data) {
+    auto dataQuery = this->query(DRM_I915_QUERY_TOPOLOGY_INFO, DrmQueryItemFlags::topology);
+    if (dataQuery.empty()) {
        return false;
    }
+    auto data = reinterpret_cast<drm_i915_query_topology_info *>(dataQuery.data());

    topologyData.maxSliceCount = data->max_slices;
    topologyData.maxSubSliceCount = data->max_subslices;
--- a/shared/source/os_interface/linux/ioctl_helper.h
+++ b/shared/source/os_interface/linux/ioctl_helper.h
@@ -11,6 +11,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <vector>

 namespace NEO {
 class Drm;
@@ -36,8 +37,8 @@ class IoctlHelper {
    static IoctlHelper *get(Drm *drm);
    static uint32_t ioctl(Drm *drm, unsigned long request, void *arg);

-    virtual uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) = 0;
-    virtual std::unique_ptr<MemoryRegion[]> translateToMemoryRegions(uint8_t *dataQuery, uint32_t length, uint32_t &numRegions) = 0;
+    virtual uint32_t createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) = 0;
+    virtual std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) = 0;
    virtual CacheRegion closAlloc(Drm *drm) = 0;
    virtual uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) = 0;
    virtual CacheRegion closFree(Drm *drm, CacheRegion closIndex) = 0;
@@ -52,8 +53,8 @@ class IoctlHelper {

 class IoctlHelperUpstream : public IoctlHelper {
  public:
-    uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override;
-    std::unique_ptr<MemoryRegion[]> translateToMemoryRegions(uint8_t *dataQuery, uint32_t length, uint32_t &numRegions) override;
+    uint32_t createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) override;
+    std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
    CacheRegion closAlloc(Drm *drm) override;
    uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;
    CacheRegion closFree(Drm *drm, CacheRegion closIndex) override;
@@ -73,14 +74,14 @@ class IoctlHelperImpl : public IoctlHelperUpstream {
        static IoctlHelperImpl<gfxProduct> instance;
        return &instance;
    }
-    uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override;
-    std::unique_ptr<MemoryRegion[]> translateToMemoryRegions(uint8_t *dataQuery, uint32_t length, uint32_t &numRegions) override;
+    uint32_t createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) override;
+    std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
 };

 class IoctlHelperPrelim20 : public IoctlHelper {
  public:
-    uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override;
-    std::unique_ptr<MemoryRegion[]> translateToMemoryRegions(uint8_t *dataQuery, uint32_t length, uint32_t &numRegions) override;
+    uint32_t createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) override;
+    std::vector<MemoryRegion> translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) override;
    CacheRegion closAlloc(Drm *drm) override;
    uint16_t closAllocWays(Drm *drm, CacheRegion closIndex, uint16_t cacheLevel, uint16_t numWays) override;
    CacheRegion closFree(Drm *drm, CacheRegion closIndex) override;
--- a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp
+++ b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp
@@ -18,9 +18,15 @@

 namespace NEO {

-uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) {
+uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) {
+    uint32_t regionsSize = static_cast<uint32_t>(memClassInstances.size());
+    prelim_drm_i915_gem_memory_class_instance data[regionsSize];
+    for (uint32_t i = 0; i < regionsSize; i++) {
+        data[i].memory_class = memClassInstances[i].memoryClass;
+        data[i].memory_instance = memClassInstances[i].memoryInstance;
+    }
    prelim_drm_i915_gem_object_param regionParam{};
-    regionParam.size = dataSize;
+    regionParam.size = regionsSize;
    regionParam.data = reinterpret_cast<uintptr_t>(data);
    regionParam.param = PRELIM_I915_OBJECT_PARAM | PRELIM_I915_PARAM_MEMORY_REGIONS;

@@ -36,7 +42,7 @@ uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, void *data, uint32_t dataSi
                     allocSize, regionParam.param);

    if (DebugManager.flags.PrintBOCreateDestroyResult.get()) {
-        for (uint32_t i = 0; i < dataSize; i++) {
+        for (uint32_t i = 0; i < regionsSize; i++) {
            auto region = reinterpret_cast<prelim_drm_i915_gem_memory_class_instance *>(data)[i];
            printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, ", memory class: %d, memory instance: %d",
                             region.memory_class, region.memory_instance);
@@ -51,16 +57,15 @@ uint32_t IoctlHelperPrelim20::createGemExt(Drm *drm, void *data, uint32_t dataSi
    return ret;
 }

-std::unique_ptr<MemoryRegion[]> IoctlHelperPrelim20::translateToMemoryRegions(uint8_t *dataQuery, uint32_t length, uint32_t &numRegions) {
-    auto *data = reinterpret_cast<prelim_drm_i915_query_memory_regions *>(dataQuery);
-    auto memRegions = std::make_unique<MemoryRegion[]>(data->num_regions);
+std::vector<MemoryRegion> IoctlHelperPrelim20::translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) {
+    auto *data = reinterpret_cast<const prelim_drm_i915_query_memory_regions *>(regionInfo.data());
+    auto memRegions = std::vector<MemoryRegion>(data->num_regions);
    for (uint32_t i = 0; i < data->num_regions; i++) {
        memRegions[i].probedSize = data->regions[i].probed_size;
        memRegions[i].unallocatedSize = data->regions[i].unallocated_size;
        memRegions[i].region.memoryClass = data->regions[i].region.memory_class;
        memRegions[i].region.memoryInstance = data->regions[i].region.memory_instance;
    }
-    numRegions = data->num_regions;
    return memRegions;
 }

--- a/shared/source/os_interface/linux/ioctl_helper_upstream.cpp
+++ b/shared/source/os_interface/linux/ioctl_helper_upstream.cpp
@@ -13,9 +13,15 @@

 namespace NEO {

-uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) {
+uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) {
+    uint32_t regionsSize = static_cast<uint32_t>(memClassInstances.size());
+    drm_i915_gem_memory_class_instance data[regionsSize];
+    for (uint32_t i = 0; i < regionsSize; i++) {
+        data[i].memory_class = memClassInstances[i].memoryClass;
+        data[i].memory_instance = memClassInstances[i].memoryInstance;
+    }
    drm_i915_gem_create_ext_memory_regions memRegions{};
-    memRegions.num_regions = dataSize;
+    memRegions.num_regions = regionsSize;
    memRegions.regions = reinterpret_cast<uintptr_t>(data);
    memRegions.base.name = I915_GEM_CREATE_EXT_MEMORY_REGIONS;

@@ -27,7 +33,7 @@ uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, void *data, uint32_t dataSi
                     allocSize);

    if (DebugManager.flags.PrintBOCreateDestroyResult.get()) {
-        for (uint32_t i = 0; i < dataSize; i++) {
+        for (uint32_t i = 0; i < regionsSize; i++) {
            auto region = reinterpret_cast<drm_i915_gem_memory_class_instance *>(data)[i];
            printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, ", memory class: %d, memory instance: %d",
                             region.memory_class, region.memory_instance);
@@ -42,16 +48,15 @@ uint32_t IoctlHelperUpstream::createGemExt(Drm *drm, void *data, uint32_t dataSi
    return ret;
 }

-std::unique_ptr<MemoryRegion[]> IoctlHelperUpstream::translateToMemoryRegions(uint8_t *dataQuery, uint32_t length, uint32_t &numRegions) {
-    auto *data = reinterpret_cast<drm_i915_query_memory_regions *>(dataQuery);
-    auto memRegions = std::make_unique<MemoryRegion[]>(data->num_regions);
+std::vector<MemoryRegion> IoctlHelperUpstream::translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) {
+    auto *data = reinterpret_cast<const drm_i915_query_memory_regions *>(regionInfo.data());
+    auto memRegions = std::vector<MemoryRegion>(data->num_regions);
    for (uint32_t i = 0; i < data->num_regions; i++) {
        memRegions[i].probedSize = data->regions[i].probed_size;
        memRegions[i].unallocatedSize = data->regions[i].unallocated_size;
        memRegions[i].region.memoryClass = data->regions[i].region.memory_class;
        memRegions[i].region.memoryInstance = data->regions[i].region.memory_instance;
    }
-    numRegions = data->num_regions;
    return memRegions;
 }

--- a/shared/source/os_interface/linux/local/dg1/drm_tip_helper.cpp
+++ b/shared/source/os_interface/linux/local/dg1/drm_tip_helper.cpp
@@ -13,26 +13,10 @@

 namespace NEO {

-uint32_t createGemExtMemoryRegions(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) {
-    drm_i915_gem_create_ext_memory_regions extRegions{};
-    extRegions.base.name = I915_GEM_CREATE_EXT_MEMORY_REGIONS;
-    extRegions.num_regions = dataSize;
-    extRegions.regions = reinterpret_cast<uintptr_t>(data);
-
-    drm_i915_gem_create_ext createExt{};
-    createExt.size = allocSize;
-    createExt.extensions = reinterpret_cast<uintptr_t>(&extRegions);
-
-    auto ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
-
-    handle = createExt.handle;
-    return ret;
-}
-
-bool isQueryDrmTip(uint8_t *dataQuery, int32_t length) {
-    auto dataOnDrmTip = reinterpret_cast<drm_i915_query_memory_regions *>(dataQuery);
-    auto lengthOnDrmTip = static_cast<int32_t>(sizeof(drm_i915_query_memory_regions) + dataOnDrmTip->num_regions * sizeof(drm_i915_memory_region_info));
-    return length == lengthOnDrmTip;
+bool isQueryDrmTip(const std::vector<uint8_t> &queryInfo) {
+    auto dataOnDrmTip = reinterpret_cast<const drm_i915_query_memory_regions *>(queryInfo.data());
+    auto lengthOnDrmTip = static_cast<uint32_t>(sizeof(drm_i915_query_memory_regions) + dataOnDrmTip->num_regions * sizeof(drm_i915_memory_region_info));
+    return static_cast<uint32_t>(queryInfo.size()) == lengthOnDrmTip;
 }

 namespace PROD_DG1 {
@@ -41,11 +25,11 @@ namespace PROD_DG1 {
 #include "third_party/uapi/dg1/drm/i915_drm.h"
 } // namespace PROD_DG1

-std::unique_ptr<uint8_t[]> translateToDrmTip(uint8_t *dataQuery) {
-    auto dataOnProdDrm = reinterpret_cast<PROD_DG1::drm_i915_query_memory_regions *>(dataQuery);
+std::vector<uint8_t> translateToDrmTip(const uint8_t *dataQuery) {
+    auto dataOnProdDrm = reinterpret_cast<const PROD_DG1::drm_i915_query_memory_regions *>(dataQuery);
    auto lengthTranslated = static_cast<int32_t>(sizeof(drm_i915_query_memory_regions) + dataOnProdDrm->num_regions * sizeof(drm_i915_memory_region_info));
-    auto dataQueryTranslated = std::make_unique<uint8_t[]>(lengthTranslated);
-    auto dataTranslated = reinterpret_cast<drm_i915_query_memory_regions *>(dataQueryTranslated.get());
+    auto dataQueryTranslated = std::vector<uint8_t>(lengthTranslated, 0u);
+    auto dataTranslated = reinterpret_cast<drm_i915_query_memory_regions *>(dataQueryTranslated.data());
    dataTranslated->num_regions = dataOnProdDrm->num_regions;
    for (uint32_t i = 0; i < dataTranslated->num_regions; i++) {
        dataTranslated->regions[i].region.memory_class = dataOnProdDrm->regions[i].region.memory_class;
--- a/shared/source/os_interface/linux/local/dg1/ioctl_helper_dg1.cpp
+++ b/shared/source/os_interface/linux/local/dg1/ioctl_helper_dg1.cpp
@@ -14,31 +14,26 @@
 namespace NEO {
 constexpr static auto gfxProduct = IGFX_DG1;

-extern uint32_t createGemExtMemoryRegions(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle);
-extern bool isQueryDrmTip(uint8_t *dataQuery, int32_t length);
-extern std::unique_ptr<uint8_t[]> translateToDrmTip(uint8_t *dataQuery);
+extern bool isQueryDrmTip(const std::vector<uint8_t> &queryInfo);
+extern std::vector<uint8_t> translateToDrmTip(const uint8_t *dataQuery);

 template <>
-uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) {
-    printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "Performing GEM_CREATE_EXT with { size: %lu", allocSize);
-
-    if (DebugManager.flags.PrintBOCreateDestroyResult.get()) {
-        for (uint32_t i = 0; i < dataSize; i++) {
-            auto region = reinterpret_cast<drm_i915_gem_memory_class_instance *>(data)[i];
-            printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, ", memory class: %d, memory instance: %d",
-                             region.memory_class, region.memory_instance);
-        }
-        printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "%s", " }\n");
-    }
-
-    if (createGemExtMemoryRegions(drm, data, dataSize, allocSize, handle) == 0) {
-        printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT with EXT_MEMORY_REGIONS has returned: %d BO-%u with size: %lu\n", 0, handle, allocSize);
-        return 0;
+uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) {
+    auto ret = IoctlHelperUpstream::createGemExt(drm, memClassInstances, allocSize, handle);
+    if (ret == 0) {
+        return ret;
    }
+    //fallback to PROD_DG1 kernel
    handle = 0u;
+    uint32_t regionsSize = static_cast<uint32_t>(memClassInstances.size());
+    drm_i915_gem_memory_class_instance data[regionsSize];
+    for (auto i = 0u; i < regionsSize; i++) {
+        data[i].memory_class = memClassInstances[i].memoryClass;
+        data[i].memory_instance = memClassInstances[i].memoryInstance;
+    }

    drm_i915_gem_object_param regionParam{};
-    regionParam.size = dataSize;
+    regionParam.size = regionsSize;
    regionParam.data = reinterpret_cast<uintptr_t>(data);
    regionParam.param = I915_OBJECT_PARAM | I915_PARAM_MEMORY_REGIONS;

@@ -50,7 +45,7 @@ uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, void *data, uint32_
    createExt.size = allocSize;
    createExt.extensions = reinterpret_cast<uintptr_t>(&setparamRegion);

-    auto ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);
+    ret = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CREATE_EXT, &createExt);

    handle = createExt.handle;
    printDebugString(DebugManager.flags.PrintBOCreateDestroyResult.get(), stdout, "GEM_CREATE_EXT with EXT_SETPARAM has returned: %d BO-%u with size: %lu\n", ret, createExt.handle, createExt.size);
@@ -58,12 +53,12 @@ uint32_t IoctlHelperImpl<gfxProduct>::createGemExt(Drm *drm, void *data, uint32_
 }

 template <>
-std::unique_ptr<MemoryRegion[]> IoctlHelperImpl<gfxProduct>::translateToMemoryRegions(uint8_t *dataQuery, uint32_t length, uint32_t &numRegions) {
-    if (!isQueryDrmTip(dataQuery, length)) {
-        auto translated = translateToDrmTip(dataQuery);
-        return IoctlHelperUpstream::translateToMemoryRegions(translated.get(), length, numRegions);
+std::vector<MemoryRegion> IoctlHelperImpl<gfxProduct>::translateToMemoryRegions(const std::vector<uint8_t> &regionInfo) {
+    if (!isQueryDrmTip(regionInfo)) {
+        auto translated = translateToDrmTip(regionInfo.data());
+        return IoctlHelperUpstream::translateToMemoryRegions(translated);
    }
-    return IoctlHelperUpstream::translateToMemoryRegions(dataQuery, length, numRegions);
+    return IoctlHelperUpstream::translateToMemoryRegions(regionInfo);
 }

 template class IoctlHelperImpl<gfxProduct>;
--- a/shared/source/os_interface/linux/memory_info.cpp
+++ b/shared/source/os_interface/linux/memory_info.cpp
@@ -15,8 +15,8 @@

 namespace NEO {

-uint32_t MemoryInfo::createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) {
-    return IoctlHelper::get(drm)->createGemExt(drm, data, dataSize, allocSize, handle);
+uint32_t MemoryInfo::createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) {
+    return IoctlHelper::get(drm)->createGemExt(drm, memClassInstances, allocSize, handle);
 }

 MemoryClassInstance MemoryInfo::getMemoryRegionClassAndInstance(uint32_t memoryBank, const HardwareInfo &hwInfo) {
@@ -66,7 +66,8 @@ void MemoryInfo::printRegionSizes() {
 uint32_t MemoryInfo::createGemExtWithSingleRegion(Drm *drm, uint32_t memoryBanks, size_t allocSize, uint32_t &handle) {
    auto pHwInfo = drm->getRootDeviceEnvironment().getHardwareInfo();
    auto regionClassAndInstance = getMemoryRegionClassAndInstance(memoryBanks, *pHwInfo);
-    auto ret = createGemExt(drm, &regionClassAndInstance, 1, allocSize, handle);
+    std::vector<MemoryClassInstance> region = {regionClassAndInstance};
+    auto ret = createGemExt(drm, region, allocSize, handle);
    return ret;
 }

--- a/shared/source/os_interface/linux/memory_info.h
+++ b/shared/source/os_interface/linux/memory_info.h
@@ -22,11 +22,11 @@ class MemoryInfo {

    virtual ~MemoryInfo(){};

-    MemoryInfo(const MemoryRegion *regionInfo, size_t count);
+    MemoryInfo(const RegionContainer &regionInfo);

    void assignRegionsFromDistances(const void *distanceInfosPtr, size_t size);

-    MOCKABLE_VIRTUAL uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle);
+    MOCKABLE_VIRTUAL uint32_t createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle);

    MemoryClassInstance getMemoryRegionClassAndInstance(uint32_t memoryBank, const HardwareInfo &hwInfo);

--- a/shared/source/os_interface/linux/memory_info_extended.cpp
+++ b/shared/source/os_interface/linux/memory_info_extended.cpp
@@ -15,8 +15,8 @@

 namespace NEO {

-MemoryInfo::MemoryInfo(const MemoryRegion *regionInfo, size_t count)
-    : drmQueryRegions(regionInfo, regionInfo + count), systemMemoryRegion(drmQueryRegions[0]) {
+MemoryInfo::MemoryInfo(const RegionContainer &regionInfo)
+    : drmQueryRegions(regionInfo), systemMemoryRegion(drmQueryRegions[0]) {
    UNRECOVERABLE_IF(systemMemoryRegion.region.memoryClass != I915_MEMORY_CLASS_SYSTEM);
    std::copy_if(drmQueryRegions.begin(), drmQueryRegions.end(), std::back_inserter(localMemoryRegions),
                 [](const MemoryRegion &memoryRegionInfo) {
--- a/shared/source/os_interface/linux/system_info.cpp
+++ b/shared/source/os_interface/linux/system_info.cpp
@@ -15,14 +15,15 @@

 namespace NEO {

-SystemInfo::SystemInfo(const uint32_t *blobData, int32_t blobSize) {
-    this->parseDeviceBlob(blobData, blobSize);
+SystemInfo::SystemInfo(const std::vector<uint8_t> &inputData) {
+    this->parseDeviceBlob(inputData);
 }

-void SystemInfo::parseDeviceBlob(const uint32_t *data, int32_t size) {
-
+void SystemInfo::parseDeviceBlob(const std::vector<uint8_t> &inputData) {
+    auto data = reinterpret_cast<const uint32_t *>(inputData.data());
+    auto dataSize = inputData.size() / sizeof(uint32_t);
    uint32_t i = 0;
-    while (i < (size / sizeof(uint32_t))) {
+    while (i + 2 < dataSize) {
        DEBUG_BREAK_IF(data[i + 1] < 1);

        /* Attribute IDs range */
--- a/shared/source/os_interface/linux/system_info.h
+++ b/shared/source/os_interface/linux/system_info.h
@@ -7,13 +7,14 @@

 #pragma once
 #include <cstdint>
+#include <vector>

 namespace NEO {
 struct HardwareInfo;

 struct SystemInfo {

-    SystemInfo(const uint32_t *blobData, int32_t blobSize);
+    SystemInfo(const std::vector<uint8_t> &inputData);

    ~SystemInfo() = default;

@@ -37,7 +38,7 @@ struct SystemInfo {
    void checkSysInfoMismatch(HardwareInfo *hwInfo);

  protected:
-    void parseDeviceBlob(const uint32_t *data, int32_t size);
+    void parseDeviceBlob(const std::vector<uint8_t> &inputData);
    void extendParseDeviceBlob(const uint32_t *data, uint32_t element);

    uint32_t maxSlicesSupported = 0;
--- a/shared/test/common/os_interface/linux/drm_memory_manager_tests.h
+++ b/shared/test/common/os_interface/linux/drm_memory_manager_tests.h
@@ -146,13 +146,13 @@ class DrmMemoryManagerWithLocalMemoryFixture : public DrmMemoryManagerFixture {
 };

 struct MockedMemoryInfo : public NEO::MemoryInfo {
-    MockedMemoryInfo(const MemoryRegion *regionInfo, size_t count) : MemoryInfo(regionInfo, count) {}
+    MockedMemoryInfo(const std::vector<MemoryRegion> &regionInfo) : MemoryInfo(regionInfo) {}
    ~MockedMemoryInfo() override{};

    size_t getMemoryRegionSize(uint32_t memoryBank) override {
        return 1024u;
    }
-    uint32_t createGemExt(Drm *drm, void *data, uint32_t dataSize, size_t allocSize, uint32_t &handle) override {
+    uint32_t createGemExt(Drm *drm, const std::vector<MemoryClassInstance> &memClassInstances, size_t allocSize, uint32_t &handle) override {
        if (allocSize == 0) {
            return EINVAL;
        }
@@ -191,12 +191,12 @@ class DrmMemoryManagerFixtureWithoutQuietIoctlExpectation {
            i++;
        }
        mock = static_cast<DrmMockCustom *>(executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->osInterface->getDriverModel()->as<Drm>());
-        MemoryRegion regionInfo[2] = {};
+        std::vector<MemoryRegion> regionInfo(2);
        regionInfo[0].region = {I915_MEMORY_CLASS_SYSTEM, 0};
        regionInfo[0].probedSize = 8 * GB;
        regionInfo[1].region = {I915_MEMORY_CLASS_DEVICE, 0};
        regionInfo[1].probedSize = 16 * GB;
-        mock->memoryInfo.reset(new MockedMemoryInfo(regionInfo, 2));
+        mock->memoryInfo.reset(new MockedMemoryInfo(regionInfo));
        executionEnvironment->rootDeviceEnvironments[0]->memoryOperationsInterface = DrmMemoryOperationsHandler::create(*mock, 0u);
        memoryManager.reset(new TestedDrmMemoryManager(enableLocalMem, false, false, *executionEnvironment));

--- a/shared/test/common/os_interface/linux/drm_mock_device_blob.h
+++ b/shared/test/common/os_interface/linux/drm_mock_device_blob.h
@@ -128,3 +128,6 @@ static constexpr uint32_t dummyDeviceBlobData[] = {
    1,
    0x2C,
 };
+
+const std::vector<uint8_t> inputBlobData(reinterpret_cast<const uint8_t *>(dummyDeviceBlobData),
+                                         reinterpret_cast<const uint8_t *>(dummyDeviceBlobData) + sizeof(dummyDeviceBlobData));
--- a/shared/test/unit_test/os_interface/linux/drm_query_tests.cpp
+++ b/shared/test/unit_test/os_interface/linux/drm_query_tests.cpp
@@ -140,5 +140,5 @@ TEST(DrmQueryTest, givenDrmWhenGettingMemoryRegionsThenReturnNull) {
    executionEnvironment->prepareRootDeviceEnvironments(1);
    DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};

-    EXPECT_EQ(drm.getMemoryRegions(), nullptr);
-}
+    EXPECT_TRUE(drm.getMemoryRegions().empty());
+}