SWDEV-322620 - Virtual Memory Management

Implement map/unmap for PAL backend
Create commands since PAL uses the IQueue to map/unmap

Change-Id: I97e26a7d28ae5e10774c9ca65307153100945621

rocclr/device/device.hpp

@@ -91,6 +91,7 @@ class SvmUnmapMemoryCommand;
 class SvmPrefetchAsyncCommand;
 class TransferBufferFileCommand;
 class StreamOperationCommand;
+class VirtualMapCommand;
 class ExternalSemaphoreCmd;
 class HwDebugManager;
 class Isa;
@@ -1236,6 +1237,7 @@ class VirtualDevice : public amd::HeapObject {
     ShouldNotReachHere();
   }
   virtual void submitStreamOperation(amd::StreamOperationCommand& cmd) { ShouldNotReachHere(); }
+  virtual void submitVirtualMap(amd::VirtualMapCommand& cmd) { ShouldNotReachHere(); }
 
   virtual void profilerAttach(bool enable) = 0;
 
@@ -1736,23 +1738,6 @@ class Device : public RuntimeObject {
    */
   virtual void virtualFree(void* addr) = 0;
 
-  /**
-   * Map a memory to a VA range
-   *
-   * @param addr Start address of the range
-   * @param mem Backing store
-   * @param size Size to be mapped in bytes
-   */
-  virtual void virtualMap(void* addr, Memory& mem, size_t size) = 0;
-
-  /**
-   * Unmap a memory from a VA
-   *
-   * @param addr Address of the VA range
-   * @param size Size of the range to be unmapped in bytes
-   */
-  virtual void virtualUnmap(void* addr, size_t size) = 0;
-
   /**
    * @return True if the device successfully applied the SVM attributes in HMM for device memory
    */

rocclr/device/pal/paldevice.cpp

@@ -2262,21 +2262,13 @@ void* Device::virtualAlloc(void* addr, size_t size, size_t alignment)
 
 void Device::virtualFree(void* addr)
 {
-  amd::Memory* svmMem = amd::MemObjMap::FindMemObj(addr);
-  if (nullptr != svmMem && (svmMem->getMemFlags() & CL_MEM_VA_RANGE_AMD)) {
-    svmMem->release();
+  amd::Memory* va = amd::MemObjMap::FindMemObj(addr);
+  if (nullptr != va && (va->getMemFlags() & CL_MEM_VA_RANGE_AMD)) {
+    va->release();
     amd::MemObjMap::RemoveMemObj(addr);
   }
 }
 
-void Device::virtualMap(void* addr, amd::Memory& mem, size_t size)
-{
-}
-
-void Device::virtualUnmap(void* addr, size_t size)
-{
-}
-
 bool Device::AcquireExclusiveGpuAccess() {
   // Lock the virtual GPU list
   vgpusAccess().lock();

rocclr/device/pal/paldevice.hpp

@@ -146,8 +146,6 @@ class NullDevice : public amd::Device {
   virtual void svmFree(void* ptr) const { return; }
   virtual void* virtualAlloc(void* addr, size_t size, size_t alignment) { return nullptr; };
   virtual void virtualFree(void* addr) { };
-  virtual void virtualMap(void* addr, amd::Memory& mem, size_t size) { };
-  virtual void virtualUnmap(void* addr, size_t size) { };
 
   virtual bool importExtSemaphore(void** extSemaphore,const amd::Os::FileDesc& handle) { return false; }
   virtual void DestroyExtSemaphore(void* extSemaphore) { }
@@ -529,8 +527,6 @@ class Device : public NullDevice {
 
   virtual void* virtualAlloc(void* addr, size_t size, size_t alignment);
   virtual void virtualFree(void* addr);
-  virtual void virtualMap(void* addr, amd::Memory& mem, size_t size);
-  virtual void virtualUnmap(void* addr, size_t size);
 
   //! Returns SRD manger object
   SrdManager& srds() const { return *srdManager_; }

rocclr/device/pal/palvirtual.cpp

@@ -2124,6 +2124,30 @@ void VirtualGPU::submitSvmFreeMemory(amd::SvmFreeMemoryCommand& vcmd) {
   profilingEnd(vcmd);
 }
 
+void VirtualGPU::submitVirtualMap(amd::VirtualMapCommand& vcmd) {
+  // Make sure VirtualGPU has an exclusive access to the resources
+  amd::ScopedLock lock(execution());
+
+  profilingBegin(vcmd);
+  amd::Memory* va = amd::MemObjMap::FindMemObj(vcmd.ptr());
+  if (va == nullptr || !(va->getMemFlags() & CL_MEM_VA_RANGE_AMD)) {
+    profilingEnd(vcmd);
+    return;
+  }
+  pal::Memory* vaRange = dev().getGpuMemory(va);
+  Pal::IGpuMemory* memory = (vcmd.memory() == nullptr)? nullptr : dev().getGpuMemory(vcmd.memory())->iMem();
+  Pal::VirtualMemoryRemapRange range{
+    vaRange->iMem(),
+    0,
+    memory,
+    0,
+    vcmd.size(),
+    Pal::VirtualGpuMemAccessMode::NoAccess
+  };
+  Pal::Result result = queue(MainEngine).iQueue_->RemapVirtualMemoryPages(1, &range, false, nullptr);
+  profilingEnd(vcmd);
+}
+
 // ================================================================================================
 void VirtualGPU::PrintChildren(const HSAILKernel& hsaKernel, VirtualGPU* gpuDefQueue) {
   AmdAqlWrap* wraps = (AmdAqlWrap*)(&((AmdVQueueHeader*)gpuDefQueue->virtualQueue_->data())[1]);

rocclr/device/pal/palvirtual.hpp

@@ -348,6 +348,7 @@ class VirtualGPU : public device::VirtualDevice {
   virtual void submitSvmMapMemory(amd::SvmMapMemoryCommand& cmd);
   virtual void submitSvmUnmapMemory(amd::SvmUnmapMemoryCommand& cmd);
   virtual void submitTransferBufferFromFile(amd::TransferBufferFileCommand& cmd);
+  virtual void submitVirtualMap(amd::VirtualMapCommand& cmd);
 
   void submitExternalSemaphoreCmd(amd::ExternalSemaphoreCmd& cmd);
 

rocclr/device/rocm/rocdevice.cpp

@@ -2287,15 +2287,6 @@ void Device::virtualFree(void* addr)
 {
 }
 
-void Device::virtualMap(void* addr, amd::Memory& mem, size_t size)
-{
-}
-
-void Device::virtualUnmap(void* addr, size_t size)
-{
-}
-
-
 // ================================================================================================
 bool Device::SetSvmAttributesInt(const void* dev_ptr, size_t count,
                               amd::MemoryAdvice advice, bool first_alloc, bool use_cpu) const {

rocclr/device/rocm/rocdevice.hpp

@@ -217,16 +217,6 @@ class NullDevice : public amd::Device {
     return;
   }
 
-  virtual void virtualMap(void* addr, amd::Memory& mem, size_t size) {
-    ShouldNotReachHere();
-    return;
-  }
-
-  virtual void virtualUnmap(void* addr, size_t size) {
-    ShouldNotReachHere();
-    return;
-  }
-
   //! Determine if we can use device memory for SVM
   const bool forceFineGrain(amd::Memory* memory) const {
     return !settings().enableCoarseGrainSVM_ || (memory->getContext().devices().size() > 1);
@@ -461,8 +451,6 @@ class Device : public NullDevice {
 
   virtual void* virtualAlloc(void* addr, size_t size, size_t alignment);
   virtual void virtualFree(void* addr);
-  virtual void virtualMap(void* addr, amd::Memory& mem, size_t size);
-  virtual void virtualUnmap(void* addr, size_t size);
 
   virtual bool SetClockMode(const cl_set_device_clock_mode_input_amd setClockModeInput,
                             cl_set_device_clock_mode_output_amd* pSetClockModeOutput);

rocclr/platform/command.hpp

@@ -1699,6 +1699,45 @@ class SvmPrefetchAsyncCommand : public Command {
   size_t cpu_access() const { return cpu_access_; }
 };
 
+/*! \brief  A virtual map memory command.
+ *
+ */
+
+class VirtualMapCommand : public Command {
+ private:
+  const void* ptr_;     //!< Virtual address to map to the memory
+  size_t size_;         //!< Size of the mapping in bytes
+  Memory* memory_;      //!< Memory to map, nullptr means unmap
+
+ public:
+  //! Construct a new VirtualMapCommand
+  VirtualMapCommand(HostQueue& queue, const EventWaitList& eventWaitList,
+                   void* ptr, size_t size, Memory* memory)
+      : Command(queue, 1, eventWaitList),
+        ptr_(ptr),
+        size_(size),
+        memory_(memory) {
+    // Sanity checks
+    assert(size > 0 && "invalid");
+    if (memory_) memory_->retain();
+  }
+
+  virtual void releaseResources() {
+    if (memory_) memory_->release();
+    DEBUG_ONLY(memory_ = nullptr);
+    Command::releaseResources();
+  }
+
+  virtual void submit(device::VirtualDevice& device) { device.submitVirtualMap(*this); }
+
+  //! Read the memory object
+  Memory* memory() const { return memory_; }
+  //! Read the size
+  size_t size() const { return size_; }
+  //! Read the pointer
+  const void* ptr() const { return ptr_; }
+};
+
 /*! @}
  *  @}
  */