Fix handling of external memory blocks

OS handles are not suitable for equality
checking as they can be reused.

Author: hyazinthh

src/Aardvark.Rendering.GL/Core/Context.fs

@@ -373,7 +373,7 @@ type Context(runtime : IRuntime, createContext : ContextHandle option -> Context
             GL.GetInteger(unbox<GetPName> 0x9318)
         )
 
-    member internal x.ImportMemoryBlock(external : ExternalMemoryBlock) =
+    member internal x.ImportMemoryBlock(external : IExternalMemoryBlock) =
         sharedMemoryManager.Import external
 
     /// <summary>

src/Aardvark.Rendering.GL/Core/SharedMemory.fs

@@ -9,7 +9,7 @@ open System.Collections.Generic
 [<AutoOpen>]
 module internal SharedMemory =
 
-    type SharedMemoryBlock(manager : SharedMemoryManager, handle : int, external : ExternalMemoryBlock) =
+    type SharedMemoryBlock(manager : SharedMemoryManager, handle : int, external : IExternalMemoryBlock) =
         let mutable refCount = 1
 
         member x.Handle = handle
@@ -44,7 +44,7 @@ module internal SharedMemory =
                 GL.Check "DeleteMemoryObject"
             )
 
-        member x.Import(external : ExternalMemoryBlock) =
+        member x.Import(external : IExternalMemoryBlock) =
             lock blocks (fun _ ->
                 match blocks.TryGetValue external.Handle with
                 | (true, shared) ->

src/Aardvark.Rendering.Vulkan/Core/Memory/DevicePtr.fs

@@ -15,18 +15,21 @@ type DevicePtr =
     val mutable private allocation : VmaAllocation
     val private allocationInfo : VmaAllocationInfo2
     val private hostVisible : bool
-    val mutable private externalHandle : IExternalMemoryHandle
+    val mutable private externalBlock : ExternalMemoryBlock
 
     internal new (device: IDevice, allocator: VmaAllocator, allocation: VmaAllocation, hostVisible: bool, export: bool) =
         let mutable info = VmaAllocationInfo2.Empty
         Vma.getAllocationInfo2(allocator, allocation, &&info)
 
-        let externalHandle =
+        let externalBlock =
             if export then
-                if RuntimeInformation.IsOSPlatform OSPlatform.Windows then
-                    ExternalMemory.Win32.getHandle allocator allocation
-                else
-                    ExternalMemory.Posix.getHandle device.Handle info.allocationInfo.deviceMemory
+                let handle =
+                    if RuntimeInformation.IsOSPlatform OSPlatform.Windows then
+                        ExternalMemory.Win32.getHandle allocator allocation
+                    else
+                        ExternalMemory.Posix.getHandle device.Handle info.allocationInfo.deviceMemory
+
+                new ExternalMemoryBlock(handle, info.allocationInfo.deviceMemory, info.blockSize)
             else
                 null
 
@@ -35,22 +38,21 @@ type DevicePtr =
           allocation     = allocation
           allocationInfo = info
           hostVisible    = hostVisible
-          externalHandle = externalHandle }
+          externalBlock  = externalBlock }
 
     internal new (device: IDevice) =
         { device         = device
           allocator      = VmaAllocator.Zero
           allocation     = VmaAllocation.Zero
           allocationInfo = VmaAllocationInfo2.Empty
           hostVisible    = false
-          externalHandle = null }
+          externalBlock  = null }
 
-    member this.ExternalBlock =
-        if isNull this.externalHandle then
+    member this.ExternalBlock : IExternalMemoryBlock =
+        if isNull this.externalBlock then
             raise <| NotSupportedException("[Vulkan] Cannot access external handle of unexported memory allocation.")
 
-        { Handle      = this.externalHandle
-          SizeInBytes = int64 this.allocationInfo.blockSize }
+        this.externalBlock
 
     member this.Block = this.allocationInfo.allocationInfo.deviceMemory
     member this.BlockSize = this.allocationInfo.blockSize
@@ -115,9 +117,9 @@ type DevicePtr =
 
     member this.Dispose() =
         if this.allocation <> 0n then
-            if this.externalHandle <> null then
-                this.externalHandle.Dispose()
-                this.externalHandle <- null
+            if this.externalBlock <> null then
+                this.externalBlock.Dispose()
+                this.externalBlock <- null
 
             Vma.freeMemory(this.allocator, this.allocation)
             this.allocation <- 0n

src/Aardvark.Rendering.Vulkan/Core/Memory/ExternalMemory.fs

@@ -2,10 +2,39 @@
 
 open Aardvark.Rendering
 open Aardvark.Rendering.Vulkan
+open System
 open Vulkan11
 
 #nowarn "51"
 
+[<AllowNullLiteral>]
+type internal ExternalMemoryBlock(handle: IExternalMemoryHandle, memory: VkDeviceMemory, sizeInBytes: uint64) =
+    member _.Handle = handle
+    member _.Memory = memory
+    member _.SizeInBytes = sizeInBytes
+
+    member _.Dispose() =
+        handle.Dispose()
+
+    member inline private _.Equals(other: ExternalMemoryBlock) =
+        memory = other.Memory
+
+    override this.Equals(obj) =
+        match obj with
+        | :? ExternalMemoryBlock as other -> this.Equals(other)
+        | _ -> false
+
+    override this.GetHashCode() =
+        hash memory.Handle
+
+    interface IEquatable<ExternalMemoryBlock> with
+        member this.Equals(other) = this.Equals(other)
+
+    interface IExternalMemoryBlock with
+        member this.Handle = this.Handle
+        member this.SizeInBytes = int64 this.SizeInBytes
+        member this.Dispose() = this.Dispose()
+
 module internal ExternalMemory =
 
     module Win32 =

src/Aardvark.Rendering.Vulkan/Resources/Buffers/Buffer.fs

@@ -52,17 +52,18 @@ type Buffer =
 type internal ExportedBuffer =
     class
         inherit Buffer
-
-        member x.ExternalMemory =
-            { Block  = x.Memory.ExternalBlock
-              Offset = int64 x.Memory.Offset
-              Size   = int64 x.Memory.Size }
+        val public ExternalMemory : ExternalMemory
 
         interface IExportedBackendBuffer with
             member x.Memory = x.ExternalMemory
 
-        new(device, handle, memory, size, usage) =
-            { inherit Buffer(device, handle, memory, size, usage) }
+        new(device, handle, memory: DevicePtr, size, usage) =
+            let externalMemory =
+                { Block  = memory.ExternalBlock
+                  Offset = int64 memory.Offset
+                  Size   = int64 memory.Size }
+
+            { inherit Buffer(device, handle, memory, size, usage); ExternalMemory = externalMemory }
     end
 
 type BufferView =

src/Aardvark.Rendering.Vulkan/Resources/Image/Image.fs

@@ -204,11 +204,7 @@ and internal ExportedImage =
     class
         inherit Image
         val public PreferArray : bool
-
-        member x.ExternalMemory =
-            { Block  = x.Memory.ExternalBlock
-              Offset = int64 x.Memory.Offset
-              Size   = int64 x.Memory.Size }
+        val public ExternalMemory : ExternalMemory
 
         member x.IsArray =
             x.Count > 1 || x.PreferArray
@@ -217,12 +213,19 @@ and internal ExportedImage =
             member x.IsArray = x.IsArray
             member x.Memory = x.ExternalMemory
 
-        new(device, handle, size, levels, layers, samples, dimension, format, preferArray, memory, layout,
+        new(device, handle, size, levels, layers, samples, dimension, format, preferArray, memory: DevicePtr, layout,
             [<Optional; DefaultParameterValue(VkImageLayout.ShaderReadOnlyOptimal)>] samplerLayout : VkImageLayout,
             [<Optional; DefaultParameterValue(null : VkImage[])>] peerHandles : VkImage[]) =
+
+            let externalMemory =
+                { Block  = memory.ExternalBlock
+                  Offset = int64 memory.Offset
+                  Size   = int64 memory.Size }
+
             {
                 inherit Image(device, handle, size, levels, layers, samples, dimension, format, memory, layout, samplerLayout, peerHandles)
                 PreferArray = preferArray
+                ExternalMemory = externalMemory
             }
 
     end

src/Aardvark.Rendering/Resources/Buffers/ExternalMemory.fs

@@ -6,11 +6,17 @@ open System.Threading
 open System.Runtime.InteropServices
 
 /// Interface for external memory handles.
-[<AllowNullLiteral>]
 type IExternalMemoryHandle =
     inherit IDisposable
     abstract member IsValid : bool
 
+/// Interface for blocks of external memory.
+[<AllowNullLiteral>]
+type IExternalMemoryBlock =
+    inherit IDisposable
+    abstract member Handle : IExternalMemoryHandle
+    abstract member SizeInBytes : int64
+
 [<AutoOpen>]
 module NativePlatformHandles =
 
@@ -25,7 +31,7 @@ module NativePlatformHandles =
         extern int close(int fd)
 
     [<AbstractClass>]
-    type NativeHandle<'T when 'T : equality>(handle : 'T) =
+    type NativeHandle<'T>(handle : 'T) =
         let mutable isValid = 1
 
         member x.IsValid = isValid = 1
@@ -45,17 +51,6 @@ module NativePlatformHandles =
                 if not <| x.CloseHandle() then
                     Log.warn "Could not close external memory handle."
 
-        override x.Equals(other : obj) =
-            match other with
-            | :? NativeHandle<'T> as o -> handle = o.Handle
-            | _ -> false
-
-        override x.GetHashCode() =
-            hash handle
-
-        interface IEquatable<NativeHandle<'T>> with
-            member x.Equals(o) = handle = o.Handle
-
         interface IExternalMemoryHandle with
             member x.IsValid = x.IsValid
             member x.Dispose() = x.Dispose()
@@ -70,28 +65,12 @@ module NativePlatformHandles =
 
         override x.CloseHandle() = Posix.close handle = 0
 
-
-/// Represents a block of external memory.
-type ExternalMemoryBlock =
-    {
-        /// The handle of the memory block.
-        Handle : IExternalMemoryHandle
-
-        /// The size of the memory block (in bytes).
-        SizeInBytes : int64
-    }
-
-    member x.Dispose() =
-        x.Handle.Dispose()
-
-    interface IDisposable with
-        member x.Dispose() = x.Dispose()
-
 /// Represents a region of an external memory block.
+[<Struct>]
 type ExternalMemory =
     {
         /// The external memory block.
-        Block : ExternalMemoryBlock
+        Block : IExternalMemoryBlock
 
         /// Start offset of the memory region (in bytes).
         Offset : int64