level-zero v1.0 (3/N)

Implement residency functions

Change-Id: I69179899f2a5fd627d10b976477a6736c600b430
Signed-off-by: Maciej Dziuban <[email protected]>

Author: DziubanMaciejIntel

level_zero/api/core/CMakeLists.txt

@@ -19,7 +19,6 @@ set(L0_SRCS_API
   ${CMAKE_CURRENT_SOURCE_DIR}/ze_image.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/ze_memory.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/ze_module.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/ze_residency.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/ze_sampler.cpp
 )
 set_property(GLOBAL PROPERTY L0_SRCS_API ${L0_SRCS_API})

level_zero/api/core/ze_context.cpp

@@ -120,7 +120,7 @@ zeContextMakeMemoryResident(
     ze_device_handle_t hDevice,
     void *ptr,
     size_t size) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    return L0::Context::fromHandle(hContext)->makeMemoryResident(hDevice, ptr, size);
 }
 
 ZE_APIEXPORT ze_result_t ZE_APICALL
@@ -129,21 +129,21 @@ zeContextEvictMemory(
     ze_device_handle_t hDevice,
     void *ptr,
     size_t size) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    return L0::Context::fromHandle(hContext)->evictMemory(hDevice, ptr, size);
 }
 
 ZE_APIEXPORT ze_result_t ZE_APICALL
 zeContextMakeImageResident(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     ze_image_handle_t hImage) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    return L0::Context::fromHandle(hContext)->makeImageResident(hDevice, hImage);
 }
 
 ZE_APIEXPORT ze_result_t ZE_APICALL
 zeContextEvictImage(
     ze_context_handle_t hContext,
     ze_device_handle_t hDevice,
     ze_image_handle_t hImage) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
+    return L0::Context::fromHandle(hContext)->evictImage(hDevice, hImage);
+}

level_zero/api/core/ze_residency.cpp

@@ -38,6 +38,14 @@ struct Context : _ze_context_handle_t {
                                        size_t alignment,
                                        void **ptr) = 0;
     virtual ze_result_t freeMem(const void *ptr) = 0;
+    virtual ze_result_t makeMemoryResident(ze_device_handle_t hDevice,
+                                           void *ptr,
+                                           size_t size) = 0;
+    virtual ze_result_t evictMemory(ze_device_handle_t hDevice,
+                                    void *ptr,
+                                    size_t size) = 0;
+    virtual ze_result_t makeImageResident(ze_device_handle_t hDevice, ze_image_handle_t hImage) = 0;
+    virtual ze_result_t evictImage(ze_device_handle_t hDevice, ze_image_handle_t hImage) = 0;
     virtual ze_result_t getMemAddressRange(const void *ptr,
                                            void **pBase,
                                            size_t *pSize) = 0;

level_zero/core/source/context/context.h

@@ -7,7 +7,11 @@
 
 #include "level_zero/core/source/context/context_imp.h"
 
+#include "shared/source/memory_manager/memory_operations_handler.h"
+
 #include "level_zero/core/source/device/device.h"
+#include "level_zero/core/source/image/image.h"
+#include "level_zero/core/source/memory/memory_operations_helper.h"
 
 namespace L0 {
 
@@ -72,6 +76,48 @@ ze_result_t ContextImp::freeMem(const void *ptr) {
     return this->driverHandle->freeMem(ptr);
 }
 
+ze_result_t ContextImp::makeMemoryResident(ze_device_handle_t hDevice, void *ptr, size_t size) {
+    auto alloc = getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
+    if (alloc == nullptr) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    NEO::Device *neoDevice = L0::Device::fromHandle(hDevice)->getNEODevice();
+    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
+    auto gpuAllocation = alloc->gpuAllocations.getGraphicsAllocation(neoDevice->getRootDeviceIndex());
+    auto success = memoryOperationsIface->makeResident(neoDevice, ArrayRef<NEO::GraphicsAllocation *>(&gpuAllocation, 1));
+    return changeMemoryOperationStatusToL0ResultType(success);
+}
+
+ze_result_t ContextImp::evictMemory(ze_device_handle_t hDevice, void *ptr, size_t size) {
+    auto alloc = getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
+    if (alloc == nullptr) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    NEO::Device *neoDevice = L0::Device::fromHandle(hDevice)->getNEODevice();
+    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
+    auto success = memoryOperationsIface->evict(neoDevice, *alloc->gpuAllocations.getGraphicsAllocation(neoDevice->getRootDeviceIndex()));
+    return changeMemoryOperationStatusToL0ResultType(success);
+}
+
+ze_result_t ContextImp::makeImageResident(ze_device_handle_t hDevice, ze_image_handle_t hImage) {
+    auto alloc = Image::fromHandle(hImage)->getAllocation();
+
+    NEO::Device *neoDevice = L0::Device::fromHandle(hDevice)->getNEODevice();
+    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
+    auto success = memoryOperationsIface->makeResident(neoDevice, ArrayRef<NEO::GraphicsAllocation *>(&alloc, 1));
+    return changeMemoryOperationStatusToL0ResultType(success);
+}
+ze_result_t ContextImp::evictImage(ze_device_handle_t hDevice, ze_image_handle_t hImage) {
+    auto alloc = Image::fromHandle(hImage)->getAllocation();
+
+    NEO::Device *neoDevice = L0::Device::fromHandle(hDevice)->getNEODevice();
+    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
+    auto success = memoryOperationsIface->evict(neoDevice, *alloc);
+    return changeMemoryOperationStatusToL0ResultType(success);
+}
+
 ze_result_t ContextImp::getMemAddressRange(const void *ptr,
                                            void **pBase,
                                            size_t *pSize) {

level_zero/core/source/context/context_imp.cpp

@@ -33,6 +33,14 @@ struct ContextImp : Context {
                                size_t alignment,
                                void **ptr) override;
     ze_result_t freeMem(const void *ptr) override;
+    ze_result_t makeMemoryResident(ze_device_handle_t hDevice,
+                                   void *ptr,
+                                   size_t size) override;
+    ze_result_t evictMemory(ze_device_handle_t hDevice,
+                            void *ptr,
+                            size_t size) override;
+    ze_result_t makeImageResident(ze_device_handle_t hDevice, ze_image_handle_t hImage) override;
+    ze_result_t evictImage(ze_device_handle_t hDevice, ze_image_handle_t hImage) override;
     ze_result_t getMemAddressRange(const void *ptr,
                                    void **pBase,
                                    size_t *pSize) override;

level_zero/core/source/context/context_imp.h

@@ -52,8 +52,6 @@ struct Device : _ze_device_handle_t {
                                      ze_module_build_log_handle_t *buildLog) = 0;
     virtual ze_result_t createSampler(const ze_sampler_desc_t *pDesc,
                                       ze_sampler_handle_t *phSampler) = 0;
-    virtual ze_result_t evictImage(ze_image_handle_t hImage) = 0;
-    virtual ze_result_t evictMemory(void *ptr, size_t size) = 0;
     virtual ze_result_t getComputeProperties(ze_device_compute_properties_t *pComputeProperties) = 0;
     virtual ze_result_t getP2PProperties(ze_device_handle_t hPeerDevice,
                                          ze_device_p2p_properties_t *pP2PProperties) = 0;
@@ -62,8 +60,6 @@ struct Device : _ze_device_handle_t {
     virtual ze_result_t getMemoryAccessProperties(ze_device_memory_access_properties_t *pMemAccessProperties) = 0;
     virtual ze_result_t getProperties(ze_device_properties_t *pDeviceProperties) = 0;
     virtual ze_result_t getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) = 0;
-    virtual ze_result_t makeImageResident(ze_image_handle_t hImage) = 0;
-    virtual ze_result_t makeMemoryResident(void *ptr, size_t size) = 0;
     virtual ze_result_t setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) = 0;
     virtual ze_result_t setLastLevelCacheConfig(ze_cache_config_flags_t cacheConfig) = 0;
     virtual ze_result_t getCacheProperties(uint32_t *pCount, ze_device_cache_properties_t *pCacheProperties) = 0;

level_zero/core/source/device/device.h

@@ -20,7 +20,6 @@
 #include "shared/source/helpers/string.h"
 #include "shared/source/kernel/grf_config.h"
 #include "shared/source/memory_manager/memory_manager.h"
-#include "shared/source/memory_manager/memory_operations_handler.h"
 #include "shared/source/os_interface/os_interface.h"
 #include "shared/source/os_interface/os_time.h"
 #include "shared/source/source_level_debugger/source_level_debugger.h"
@@ -36,7 +35,6 @@
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/core/source/event/event.h"
 #include "level_zero/core/source/image/image.h"
-#include "level_zero/core/source/memory/memory_operations_helper.h"
 #include "level_zero/core/source/module/module.h"
 #include "level_zero/core/source/printf_handler/printf_handler.h"
 #include "level_zero/core/source/sampler/sampler.h"
@@ -214,23 +212,6 @@ ze_result_t DeviceImp::createModule(const ze_module_desc_t *desc, ze_module_hand
     return ZE_RESULT_SUCCESS;
 }
 
-ze_result_t DeviceImp::evictImage(ze_image_handle_t hImage) {
-    auto alloc = Image::fromHandle(hImage)->getAllocation();
-    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
-    auto success = memoryOperationsIface->evict(neoDevice, *alloc);
-    return changeMemoryOperationStatusToL0ResultType(success);
-}
-
-ze_result_t DeviceImp::evictMemory(void *ptr, size_t size) {
-    auto alloc = getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
-    if (alloc == nullptr) {
-        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
-    auto success = memoryOperationsIface->evict(neoDevice, *alloc->gpuAllocations.getGraphicsAllocation(getRootDeviceIndex()));
-    return changeMemoryOperationStatusToL0ResultType(success);
-}
-
 ze_result_t DeviceImp::getComputeProperties(ze_device_compute_properties_t *pComputeProperties) {
     const auto &deviceInfo = this->neoDevice->getDeviceInfo();
 
@@ -425,24 +406,6 @@ ze_result_t DeviceImp::getSubDevices(uint32_t *pCount, ze_device_handle_t *phSub
     return ZE_RESULT_SUCCESS;
 }
 
-ze_result_t DeviceImp::makeImageResident(ze_image_handle_t hImage) {
-    auto alloc = Image::fromHandle(hImage)->getAllocation();
-    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
-    auto success = memoryOperationsIface->makeResident(neoDevice, ArrayRef<NEO::GraphicsAllocation *>(&alloc, 1));
-    return changeMemoryOperationStatusToL0ResultType(success);
-}
-
-ze_result_t DeviceImp::makeMemoryResident(void *ptr, size_t size) {
-    auto alloc = getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(ptr);
-    if (alloc == nullptr) {
-        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    }
-    NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
-    auto gpuAllocation = alloc->gpuAllocations.getGraphicsAllocation(getRootDeviceIndex());
-    auto success = memoryOperationsIface->makeResident(neoDevice, ArrayRef<NEO::GraphicsAllocation *>(&gpuAllocation, 1));
-    return changeMemoryOperationStatusToL0ResultType(success);
-}
-
 ze_result_t DeviceImp::setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }

level_zero/core/source/device/device_imp.cpp

@@ -29,8 +29,6 @@ struct DeviceImp : public Device {
                              ze_module_build_log_handle_t *buildLog) override;
     ze_result_t createSampler(const ze_sampler_desc_t *pDesc,
                               ze_sampler_handle_t *phSampler) override;
-    ze_result_t evictImage(ze_image_handle_t hImage) override;
-    ze_result_t evictMemory(void *ptr, size_t size) override;
     ze_result_t getComputeProperties(ze_device_compute_properties_t *pComputeProperties) override;
     ze_result_t getP2PProperties(ze_device_handle_t hPeerDevice,
                                  ze_device_p2p_properties_t *pP2PProperties) override;
@@ -39,8 +37,6 @@ struct DeviceImp : public Device {
     ze_result_t getMemoryAccessProperties(ze_device_memory_access_properties_t *pMemAccessProperties) override;
     ze_result_t getProperties(ze_device_properties_t *pDeviceProperties) override;
     ze_result_t getSubDevices(uint32_t *pCount, ze_device_handle_t *phSubdevices) override;
-    ze_result_t makeImageResident(ze_image_handle_t hImage) override;
-    ze_result_t makeMemoryResident(void *ptr, size_t size) override;
     ze_result_t setIntermediateCacheConfig(ze_cache_config_flags_t cacheConfig) override;
     ze_result_t setLastLevelCacheConfig(ze_cache_config_flags_t cacheConfig) override;
     ze_result_t getCacheProperties(uint32_t *pCount, ze_device_cache_properties_t *pCacheProperties) override;

level_zero/core/source/device/device_imp.h

@@ -63,6 +63,28 @@ struct Mock<Context> : public Context {
                  size_t alignment,
                  void **ptr),
                 (override));
+    MOCK_METHOD(ze_result_t,
+                makeMemoryResident,
+                (ze_device_handle_t hDevice,
+                 void *ptr,
+                 size_t size),
+                (override));
+    MOCK_METHOD(ze_result_t,
+                evictMemory,
+                (ze_device_handle_t hDevice,
+                 void *ptr,
+                 size_t size),
+                (override));
+    MOCK_METHOD(ze_result_t,
+                makeImageResident,
+                (ze_device_handle_t hDevice,
+                 ze_image_handle_t hImage),
+                (override));
+    MOCK_METHOD(ze_result_t,
+                evictImage,
+                (ze_device_handle_t hDevice,
+                 ze_image_handle_t hImage),
+                (override));
     MOCK_METHOD(ze_result_t,
                 freeMem,
                 (const void *ptr),