Move AllocationType enum out of GraphicsAllocation class

Signed-off-by: Bartosz Dunajski <[email protected]>

Author: BartoszDunajski

level_zero/core/source/cmdlist/cmdlist.cpp

@@ -61,7 +61,7 @@ NEO::GraphicsAllocation *CommandList::getAllocationFromHostPtrMap(const void *bu
         }
     }
     if (this->cmdListType == CommandListType::TYPE_IMMEDIATE && this->isFlushTaskSubmissionEnabled) {
-        auto allocation = this->csr->getInternalAllocationStorage()->obtainTemporaryAllocationWithPtr(bufferSize, buffer, NEO::GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR);
+        auto allocation = this->csr->getInternalAllocationStorage()->obtainTemporaryAllocationWithPtr(bufferSize, buffer, NEO::AllocationType::EXTERNAL_HOST_PTR);
         if (allocation != nullptr) {
             auto alloc = allocation.get();
             this->csr->getInternalAllocationStorage()->storeAllocation(std::move(allocation), NEO::AllocationUsage::TEMPORARY_ALLOCATION);
@@ -97,8 +97,8 @@ void CommandList::removeDeallocationContainerData() {
         if (allocData) {
             device->getDriverHandle()->getSvmAllocsManager()->removeSVMAlloc(*allocData);
         }
-        if (!((deallocation->getAllocationType() == NEO::GraphicsAllocation::AllocationType::INTERNAL_HEAP) ||
-              (deallocation->getAllocationType() == NEO::GraphicsAllocation::AllocationType::LINEAR_STREAM))) {
+        if (!((deallocation->getAllocationType() == NEO::AllocationType::INTERNAL_HEAP) ||
+              (deallocation->getAllocationType() == NEO::AllocationType::LINEAR_STREAM))) {
             memoryManager->freeGraphicsMemory(deallocation);
             eraseDeallocationContainerEntry(deallocation);
         }
@@ -141,8 +141,8 @@ void CommandList::makeResidentAndMigrate(bool performMigration) {
         csr->makeResident(*alloc);
 
         if (performMigration &&
-            (alloc->getAllocationType() == NEO::GraphicsAllocation::AllocationType::SVM_GPU ||
-             alloc->getAllocationType() == NEO::GraphicsAllocation::AllocationType::SVM_CPU)) {
+            (alloc->getAllocationType() == NEO::AllocationType::SVM_GPU ||
+             alloc->getAllocationType() == NEO::AllocationType::SVM_CPU)) {
             auto pageFaultManager = device->getDriverHandle()->getMemoryManager()->getPageFaultManager();
             pageFaultManager->moveAllocationToGpuDomain(reinterpret_cast<void *>(alloc->getGpuAddress()));
         }

level_zero/core/source/cmdlist/cmdlist_hw.inl

@@ -1512,11 +1512,11 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendMemoryFill(void *ptr,
         size_t patternAllocationSize = alignUp(patternSize, MemoryConstants::cacheLineSize);
         uint32_t patternSizeInEls = static_cast<uint32_t>(patternAllocationSize / middleElSize);
 
-        auto patternGfxAlloc = device->obtainReusableAllocation(patternAllocationSize, NEO::GraphicsAllocation::AllocationType::FILL_PATTERN);
+        auto patternGfxAlloc = device->obtainReusableAllocation(patternAllocationSize, NEO::AllocationType::FILL_PATTERN);
         if (patternGfxAlloc == nullptr) {
             patternGfxAlloc = device->getDriverHandle()->getMemoryManager()->allocateGraphicsMemoryWithProperties({device->getNEODevice()->getRootDeviceIndex(),
                                                                                                                    patternAllocationSize,
-                                                                                                                   NEO::GraphicsAllocation::AllocationType::FILL_PATTERN,
+                                                                                                                   NEO::AllocationType::FILL_PATTERN,
                                                                                                                    device->getNEODevice()->getDeviceBitfield()});
         }
         void *patternGfxAllocPtr = patternGfxAlloc->getUnderlyingBuffer();
@@ -2106,7 +2106,7 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::appendQueryKernelTimestamps(
     }
 
     size_t alignedSize = alignUp<size_t>(sizeof(EventData) * numEvents, MemoryConstants::pageSize64k);
-    NEO::GraphicsAllocation::AllocationType allocationType = NEO::GraphicsAllocation::AllocationType::GPU_TIMESTAMP_DEVICE_BUFFER;
+    NEO::AllocationType allocationType = NEO::AllocationType::GPU_TIMESTAMP_DEVICE_BUFFER;
     auto devices = device->getNEODevice()->getDeviceBitfield();
     NEO::AllocationProperties allocationProperties{device->getRootDeviceIndex(),
                                                    true,

level_zero/core/source/cmdqueue/cmdqueue.cpp

@@ -185,17 +185,17 @@ ze_command_queue_mode_t CommandQueueImp::getSynchronousMode() const {
 ze_result_t CommandQueueImp::CommandBufferManager::initialize(Device *device, size_t sizeRequested) {
     size_t alignedSize = alignUp<size_t>(sizeRequested, MemoryConstants::pageSize64k);
     NEO::AllocationProperties properties{device->getRootDeviceIndex(), true, alignedSize,
-                                         NEO::GraphicsAllocation::AllocationType::COMMAND_BUFFER,
+                                         NEO::AllocationType::COMMAND_BUFFER,
                                          (device->getNEODevice()->getNumGenericSubDevices() > 1u) /* multiOsContextCapable */,
                                          false,
                                          device->getNEODevice()->getDeviceBitfield()};
 
-    auto firstBuffer = device->obtainReusableAllocation(alignedSize, NEO::GraphicsAllocation::AllocationType::COMMAND_BUFFER);
+    auto firstBuffer = device->obtainReusableAllocation(alignedSize, NEO::AllocationType::COMMAND_BUFFER);
     if (!firstBuffer) {
         firstBuffer = device->getNEODevice()->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
     }
 
-    auto secondBuffer = device->obtainReusableAllocation(alignedSize, NEO::GraphicsAllocation::AllocationType::COMMAND_BUFFER);
+    auto secondBuffer = device->obtainReusableAllocation(alignedSize, NEO::AllocationType::COMMAND_BUFFER);
     if (!secondBuffer) {
         secondBuffer = device->getNEODevice()->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
     }

level_zero/core/source/context/context_imp.cpp

@@ -485,7 +485,7 @@ ze_result_t ContextImp::openEventPoolIpcHandle(ze_ipc_event_pool_handle_t hIpc,
     size_t alignedSize = alignUp<size_t>(numEvents * eventSize, MemoryConstants::pageSize64k);
     NEO::AllocationProperties unifiedMemoryProperties{rootDeviceIndex,
                                                       alignedSize,
-                                                      NEO::GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY,
+                                                      NEO::AllocationType::BUFFER_HOST_MEMORY,
                                                       systemMemoryBitfield};
 
     unifiedMemoryProperties.subDevicesBitfield = neoDevice->getDeviceBitfield();

level_zero/core/source/debugger/debugger_l0.cpp

@@ -33,7 +33,7 @@ void DebuggerL0::initialize() {
     sbaTrackingGpuVa = device->getMemoryManager()->reserveGpuAddress(MemoryConstants::pageSize, device->getRootDeviceIndex());
 
     NEO::AllocationProperties properties{device->getRootDeviceIndex(), true, MemoryConstants::pageSize,
-                                         NEO::GraphicsAllocation::AllocationType::DEBUG_SBA_TRACKING_BUFFER,
+                                         NEO::AllocationType::DEBUG_SBA_TRACKING_BUFFER,
                                          false,
                                          device->getDeviceBitfield()};
 
@@ -55,7 +55,7 @@ void DebuggerL0::initialize() {
         auto &hwInfo = device->getHardwareInfo();
         auto &hwHelper = NEO::HwHelper::get(hwInfo.platform.eRenderCoreFamily);
         NEO::AllocationProperties properties{device->getRootDeviceIndex(), true, MemoryConstants::pageSize64k,
-                                             NEO::GraphicsAllocation::AllocationType::DEBUG_MODULE_AREA,
+                                             NEO::AllocationType::DEBUG_MODULE_AREA,
                                              false,
                                              device->getDeviceBitfield()};
         moduleDebugArea = device->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);

level_zero/core/source/device/device.h

@@ -144,7 +144,7 @@ struct Device : _ze_device_handle_t {
     virtual SysmanDevice *getSysmanHandle() = 0;
     virtual ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) = 0;
     virtual ze_result_t getCsrForLowPriority(NEO::CommandStreamReceiver **csr) = 0;
-    virtual NEO::GraphicsAllocation *obtainReusableAllocation(size_t requiredSize, NEO::GraphicsAllocation::AllocationType type) = 0;
+    virtual NEO::GraphicsAllocation *obtainReusableAllocation(size_t requiredSize, NEO::AllocationType type) = 0;
     virtual void storeReusableAllocation(NEO::GraphicsAllocation &alloc) = 0;
 
   protected:

level_zero/core/source/device/device_imp.cpp

@@ -845,7 +845,7 @@ Device *Device::create(DriverHandle *driverHandle, NEO::Device *neoDevice, bool
         debugSurface = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
             {device->getRootDeviceIndex(), true,
              debugSurfaceSize,
-             NEO::GraphicsAllocation::AllocationType::DEBUG_CONTEXT_SAVE_AREA,
+             NEO::AllocationType::DEBUG_CONTEXT_SAVE_AREA,
              false,
              false,
              device->getNEODevice()->getDeviceBitfield()});
@@ -1009,7 +1009,7 @@ NEO::GraphicsAllocation *DeviceImp::allocateManagedMemoryFromHostPtr(void *buffe
     }
 
     allocation = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(
-        {getRootDeviceIndex(), false, size, NEO::GraphicsAllocation::AllocationType::BUFFER_HOST_MEMORY, false, neoDevice->getDeviceBitfield()},
+        {getRootDeviceIndex(), false, size, NEO::AllocationType::BUFFER_HOST_MEMORY, false, neoDevice->getDeviceBitfield()},
         buffer);
 
     if (allocation == nullptr) {
@@ -1029,7 +1029,7 @@ NEO::GraphicsAllocation *DeviceImp::allocateManagedMemoryFromHostPtr(void *buffe
 
 NEO::GraphicsAllocation *DeviceImp::allocateMemoryFromHostPtr(const void *buffer, size_t size, bool hostCopyAllowed) {
     NEO::AllocationProperties properties = {getRootDeviceIndex(), false, size,
-                                            NEO::GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR,
+                                            NEO::AllocationType::EXTERNAL_HOST_PTR,
                                             false, neoDevice->getDeviceBitfield()};
     properties.flags.flushL3RequiredForRead = properties.flags.flushL3RequiredForWrite = true;
     auto allocation = neoDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties(properties,
@@ -1044,7 +1044,7 @@ NEO::GraphicsAllocation *DeviceImp::allocateMemoryFromHostPtr(const void *buffer
     return allocation;
 }
 
-NEO::GraphicsAllocation *DeviceImp::obtainReusableAllocation(size_t requiredSize, NEO::GraphicsAllocation::AllocationType type) {
+NEO::GraphicsAllocation *DeviceImp::obtainReusableAllocation(size_t requiredSize, NEO::AllocationType type) {
     auto alloc = allocationsForReuse->detachAllocation(requiredSize, nullptr, nullptr, type);
     if (alloc == nullptr)
         return nullptr;

level_zero/core/source/device/device_imp.h

@@ -94,7 +94,7 @@ struct DeviceImp : public Device {
     SysmanDevice *getSysmanHandle() override;
     ze_result_t getCsrForOrdinalAndIndex(NEO::CommandStreamReceiver **csr, uint32_t ordinal, uint32_t index) override;
     ze_result_t getCsrForLowPriority(NEO::CommandStreamReceiver **csr) override;
-    NEO::GraphicsAllocation *obtainReusableAllocation(size_t requiredSize, NEO::GraphicsAllocation::AllocationType type) override;
+    NEO::GraphicsAllocation *obtainReusableAllocation(size_t requiredSize, NEO::AllocationType type) override;
     void storeReusableAllocation(NEO::GraphicsAllocation &alloc) override;
     NEO::Device *getActiveDevice() const;
 

level_zero/core/source/driver/driver_handle_imp.cpp

@@ -421,7 +421,7 @@ void *DriverHandleImp::importFdHandle(ze_device_handle_t hDevice, ze_ipc_memory_
     NEO::osHandle osHandle = static_cast<NEO::osHandle>(handle);
     NEO::AllocationProperties unifiedMemoryProperties{neoDevice->getRootDeviceIndex(),
                                                       MemoryConstants::pageSize,
-                                                      NEO::GraphicsAllocation::AllocationType::BUFFER,
+                                                      NEO::AllocationType::BUFFER,
                                                       neoDevice->getDeviceBitfield()};
     unifiedMemoryProperties.subDevicesBitfield = neoDevice->getDeviceBitfield();
     NEO::GraphicsAllocation *alloc =
@@ -499,7 +499,7 @@ NEO::GraphicsAllocation *DriverHandleImp::getPeerAllocation(Device *device,
 void *DriverHandleImp::importNTHandle(ze_device_handle_t hDevice, void *handle) {
     auto neoDevice = Device::fromHandle(hDevice)->getNEODevice();
 
-    auto alloc = this->getMemoryManager()->createGraphicsAllocationFromNTHandle(handle, neoDevice->getRootDeviceIndex(), NEO::GraphicsAllocation::AllocationType::SHARED_BUFFER);
+    auto alloc = this->getMemoryManager()->createGraphicsAllocationFromNTHandle(handle, neoDevice->getRootDeviceIndex(), NEO::AllocationType::SHARED_BUFFER);
 
     if (alloc == nullptr) {
         return nullptr;

level_zero/core/source/driver/host_pointer_manager.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -110,7 +110,7 @@ NEO::GraphicsAllocation *HostPointerManager::createHostPointerAllocation(uint32_
                                                                          size_t size,
                                                                          const NEO::DeviceBitfield &deviceBitfield) {
     NEO::AllocationProperties properties = {rootDeviceIndex, false, size,
-                                            NEO::GraphicsAllocation::AllocationType::EXTERNAL_HOST_PTR,
+                                            NEO::AllocationType::EXTERNAL_HOST_PTR,
                                             false, deviceBitfield};
     properties.flags.flushL3RequiredForRead = properties.flags.flushL3RequiredForWrite = true;
     auto allocation = memoryManager->allocateGraphicsMemoryWithProperties(properties,