SWDEV-439234 - Implement Set/Get Access APIs in PAL/Windows.

Change-Id: I997c330880da70c5128b187e1ef4d9c449218880


[ROCm/clr commit: 11817b4405]

projects/clr/rocclr/device/device.cpp

@@ -83,6 +83,16 @@ bool VirtualDevice::ActiveWait() const {
 
 }
 
+static_assert(static_cast<uint32_t>(device::Memory::MemAccess::kMemAccessNone)
+            == static_cast<uint32_t>(amd::Device::VmmAccess::kNone),
+            "Mem Access Flag None mismatch between Device and Memory!");
+static_assert(static_cast<uint32_t>(device::Memory::MemAccess::kMemAccessRead)
+            == static_cast<uint32_t>(amd::Device::VmmAccess::kReadOnly),
+            "Mem Access Flag Read mismatch between Device and Memory!");
+static_assert(static_cast<uint32_t>(device::Memory::MemAccess::kMemAccessReadWrite)
+            == static_cast<uint32_t>(amd::Device::VmmAccess::kReadWrite),
+            "Mem Access Flag Read Write mismatch between Device and Memory!");
+
 namespace amd {
 
 amd::Monitor Device::lockP2P_("Lock P2P ON/OFF");

projects/clr/rocclr/device/device.hpp

@@ -726,6 +726,13 @@ class Memory : public amd::HeapObject {
     CpuWriteOnly = 0x00000002,  //!< Lock for CPU write only operation
   };
 
+  //! Memory Access flags at device level
+  enum MemAccess {
+    kMemAccessNone = 0,        //! No Access
+    kMemAccessRead = 1,        //! Read Access
+    kMemAccessReadWrite = 3    //! Read and Write Access
+  };
+
   union SyncFlags {
     struct {
       uint skipParent_ : 1;  //!< Skip parent synchronization
@@ -766,11 +773,14 @@ class Memory : public amd::HeapObject {
   Memory(amd::Memory& owner)
       : flags_(0), owner_(&owner), version_(0), mapMemory_(NULL), indirectMapCount_(0) {
     size_ = owner.getSize();
+    memAccess_ = MemAccess::kMemAccessNone;
   }
 
   //! Constructor (no owner), always eager allocation.
   Memory(size_t size)
-      : flags_(0), owner_(NULL), version_(0), mapMemory_(NULL), indirectMapCount_(0), size_(size) {}
+      : flags_(0), owner_(NULL), version_(0), mapMemory_(NULL), indirectMapCount_(0), size_(size) {
+    memAccess_ = MemAccess::kMemAccessNone;
+  }
 
   enum GLResourceOP {
     GLDecompressResource = 0,  // orders the GL driver to decompress any depth-stencil or MSAA
@@ -921,6 +931,12 @@ class Memory : public amd::HeapObject {
     }
   }
 
+  //! Set access to the memory in this device.
+  void SetAccess(MemAccess memAccess) { memAccess_ = memAccess; }
+
+  //! Get current access of the memory in device.
+  MemAccess GetAccess() const { return memAccess_; }
+
  protected:
   enum Flags {
     HostMemoryDirectAccess = 0x00000001,  //!< GPU has direct access to the host memory
@@ -934,6 +950,8 @@ class Memory : public amd::HeapObject {
   };
   uint flags_;  //!< Memory object flags
 
+  MemAccess memAccess_; //!< Memory Access flag
+
   amd::Memory* owner_;  //!< The Memory instance that we cache,
                         //!< or NULL if we're device-private workspace.
 

projects/clr/rocclr/device/pal/paldevice.cpp

@@ -2505,6 +2505,57 @@ void Device::virtualFree(void* addr) {
   }
 }
 
+// ================================================================================================
+bool Device::SetMemAccess(void* va_addr, size_t va_size, VmmAccess access_flags) {
+
+  amd::Memory* phys_mem_obj = amd::MemObjMap::FindMemObj(va_addr);
+  if (phys_mem_obj == nullptr) {
+    // If the phys_mem_obj is null, the check if this is a valid va_addr, but not-mapped,
+    // if not-mapped then print a different error message. (No functional change due to this check).
+    amd::Memory* vaddr_mem_obj = amd::MemObjMap::FindVirtualMemObj(va_addr);
+    if (vaddr_mem_obj == nullptr) {
+      LogPrintfError("Cannot find virtual address: 0x%x \n", va_addr);
+      return false;
+    }
+    LogPrintfError("Virtual address present, but not mapped yet: 0x%x \n", va_addr);
+    return false;
+  }
+
+  // Check for valid size.
+  if (va_size > phys_mem_obj->getSize()) {
+    LogPrintfError("Given size: %u cannot be greater than mem_size: %u \n", va_size,
+                    phys_mem_obj->getSize());
+    return false;
+  }
+
+  device::Memory* phys_dev_mem = phys_mem_obj->getDeviceMemory(*this);
+  phys_dev_mem->SetAccess(static_cast<device::Memory::MemAccess>(access_flags));
+
+  return true;
+}
+
+// ================================================================================================
+bool Device::GetMemAccess(void* va_addr, VmmAccess* access_flags_ptr) {
+
+  amd::Memory* phys_mem_obj = amd::MemObjMap::FindMemObj(va_addr);
+  if (phys_mem_obj == nullptr) {
+    // If the phys_mem_obj is null, the check if this is a valid va_addr, but not-mapped,
+    // if not-mapped then print a different error message. (No functional change due to this check).
+    amd::Memory* vaddr_mem_obj = amd::MemObjMap::FindVirtualMemObj(va_addr);
+    if (vaddr_mem_obj == nullptr) {
+      LogPrintfError("Cannot find virtual address: 0x%x \n", va_addr);
+      return false;
+    }
+    LogPrintfError("Virtual address present, but not mapped yet: 0x%x \n", va_addr);
+    return false;
+  }
+
+  device::Memory* phys_dev_mem = phys_mem_obj->getDeviceMemory(*this);
+  device::Memory::MemAccess mem_access = phys_dev_mem->GetAccess();
+  *access_flags_ptr = static_cast<VmmAccess>(mem_access);
+
+  return true;
+}
 // ================================================================================================
 bool Device::AcquireExclusiveGpuAccess() {
   // Lock the virtual GPU list

projects/clr/rocclr/device/pal/paldevice.hpp

@@ -555,16 +555,13 @@ class Device : public NullDevice {
   //! SVM free
   virtual void svmFree(void* ptr) const;
 
+  //! Virtual address space allocation(reservation)
   virtual void* virtualAlloc(void* addr, size_t size, size_t alignment);
   virtual void virtualFree(void* addr);
 
-  virtual bool SetMemAccess(void* va_addr, size_t va_size, VmmAccess access_flags) {
-    return true;
-  }
-
-  virtual bool GetMemAccess(void* va_addr, VmmAccess* access_flags_ptr) {
-    return true;
-  }
+  //! Set/Get memory access set by the app
+  virtual bool SetMemAccess(void* va_addr, size_t va_size, VmmAccess access_flags);
+  virtual bool GetMemAccess(void* va_addr, VmmAccess* access_flags_ptr);
 
   virtual bool ExportShareableVMMHandle(amd::Memory& amd_mem_obj, int flags, void* shareableHandle);