Make IBuffer.ToArray robust to out-of-range arguments

This change makes it possible to retrieve all elements from
a BufferView without knowing the count beforehand.

Author: hyazinthh

RELEASE_NOTES.md

@@ -1,5 +1,6 @@
 - Fixed support for 64-bit attributes and uniforms
 - [Sg] Fixed broken Ag rule for `FaceVertexCount`
+- Made `IBuffer.ToArray` and `BufferView.download` robust to out-of-range arguments
 
 ### 5.6.4
 - [GL] Dispose MultimediaTimer in LodRenderer to avoid resource exhaustion

src/Aardvark.Rendering/Resources/Adaptive/BufferView.fs

@@ -153,9 +153,15 @@ module BufferView =
                 int ((sizeInBytes - uint64 view.Offset) / uint64 view.ElementType.CLRSize)
             )
 
+    /// Retrieves up to count elements from the given buffer view as an array starting at startIndex.
+    /// If count < 0, all available elements are retrieved.
     let download (startIndex : int) (count : int) (view : BufferView) : aval<Array> =
+        let startIndex = max startIndex 0
+
         match view.SingleValue with
         | Some value ->
+            let count = if count < 0 then 1 else count
+
             value.Accept {
                 new IAdaptiveValueVisitor<_> with
                     member _.Visit(value) = value |> AVal.map (fun value -> Array.replicate count value :> Array)

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

@@ -342,6 +342,10 @@ type IBufferRangeExtensions private() =
 [<AbstractClass; Sealed; Extension>]
 type IBufferExtensions private() =
 
+    static let getAvailableCount (elementSize: uint64) (stride: uint64) (offset: uint64) (totalSize: uint64) =
+        let availableSize = if offset <= totalSize then totalSize - offset else 0UL
+        if availableSize >= elementSize then 1UL + (availableSize - elementSize) / stride else 0UL
+
     static let copyToArray (elementType: Type) (elementSize: uint64) (stride: uint64) (offset: uint64) (count: uint64) (src: nativeint) =
         let array = Array.CreateInstance(elementType, int64 count)
         let sizeInBytes = count * elementSize
@@ -369,30 +373,27 @@ type IBufferExtensions private() =
     ///<summary>Returns elements of a buffer as an array.</summary>
     ///<param name="buffer">The buffer from which to retrieve elements.</param>
     ///<param name="elementType">The element type of the buffer and resulting array.</param>
-    ///<param name="count">The number of elements to retrieve.</param>
+    ///<param name="count">The maximum number of elements to retrieve. Default is UInt64.MaxValue.</param>
     ///<param name="offset">Offset (in bytes) into the buffer. Default is 0.</param>
     ///<param name="stride">Number of bytes between elements or 0 for tightly packed data. Default is 0.</param>
     ///<returns>An array containing the buffer elements.</returns>
     [<Extension>]
-    static member ToArray(buffer: IBuffer, elementType: Type, count: uint64,
+    static member ToArray(buffer: IBuffer, elementType: Type,
+                          [<Optional; DefaultParameterValue(UInt64.MaxValue)>] count: uint64,
                           [<Optional; DefaultParameterValue(0UL)>] offset: uint64,
                           [<Optional; DefaultParameterValue(0UL)>] stride: uint64) : Array =
         let elementSize = uint64 elementType.CLRSize
         let stride = if stride = 0UL then elementSize else stride
-        let copySize = if count = 0UL then 0UL else stride * (count - 1UL) + elementSize
 
         match buffer with
-        | :? ArrayBuffer as buffer ->
-            if buffer.ElementType <> elementType then
-                raise <| InvalidCastException($"Expected ArrayBuffer with element type {elementType} but got {buffer.ElementType}.")
+        | :? ArrayBuffer as buffer when buffer.ElementType = elementType ->
+            let totalSize = uint64 buffer.Data.Length * elementSize
+            let available = getAvailableCount elementSize stride offset totalSize
+            let count = min available count
 
             if count = uint64 buffer.Data.Length && offset = 0UL && stride = elementSize then
                 buffer.Data
             else
-                let totalSize = uint64 buffer.Data.Length * elementSize
-                if copySize > totalSize - offset then
-                    raise <| ArgumentOutOfRangeException($"Cannot copy {copySize} bytes from ArrayBuffer with size {totalSize} starting at offset {offset}.")
-
                 if stride = elementSize && offset % elementSize = 0UL then
                     let result = Array.CreateInstance(elementType, int64 count)
                     Array.Copy(buffer.Data, int64 (offset / elementSize), result, 0L, int64 count)
@@ -401,14 +402,13 @@ type IBufferExtensions private() =
                     buffer.Data |> NativeInt.pin (copyToArray elementType elementSize stride offset count)
 
         | :? INativeBuffer as buffer ->
-            if copySize > buffer.SizeInBytes - offset then
-                raise <| ArgumentOutOfRangeException($"Cannot copy {copySize} bytes from INativeBuffer with size {buffer.SizeInBytes} starting at offset {offset}.")
-
+            let available = getAvailableCount elementSize stride offset buffer.SizeInBytes
+            let count = min available count
             buffer.Use(copyToArray elementType elementSize stride offset count)
 
         | :? IBackendBuffer as buffer ->
-            if copySize > buffer.SizeInBytes - offset then
-                raise <| ArgumentOutOfRangeException($"Cannot copy {copySize} bytes from IBackendBuffer with size {buffer.SizeInBytes} starting at offset {offset}.")
+            let available = getAvailableCount elementSize stride offset buffer.SizeInBytes
+            let count = min available count
 
             if stride = elementSize then
                 let result = Array.CreateInstance(elementType, int64 count)
@@ -417,6 +417,7 @@ type IBufferExtensions private() =
                 )
                 result
             else
+                let copySize = if count = 0UL then 0UL else stride * (count - 1UL) + elementSize
                 let tmp = Marshal.AllocHGlobal(nativeint copySize)
                 try
                     buffer.Download(offset, tmp, copySize)
@@ -429,12 +430,13 @@ type IBufferExtensions private() =
 
     ///<summary>Returns elements of a buffer as an array.</summary>
     ///<param name="buffer">The buffer from which to retrieve elements.</param>
-    ///<param name="count">The number of elements to retrieve.</param>
+    ///<param name="count">The maximum number of elements to retrieve. Default is UInt64.MaxValue.</param>
     ///<param name="offset">Offset (in bytes) into the buffer. Default is 0.</param>
     ///<param name="stride">Number of bytes between elements or 0 for tightly packed data. Default is 0.</param>
     ///<returns>An array containing the buffer elements.</returns>
     [<Extension>]
-    static member inline ToArray<'T when 'T : unmanaged>(buffer: IBuffer, count: uint64,
+    static member inline ToArray<'T when 'T : unmanaged>(buffer: IBuffer,
+                                                         [<Optional; DefaultParameterValue(UInt64.MaxValue)>] count: uint64,
                                                          [<Optional; DefaultParameterValue(0UL)>] offset: uint64,
                                                          [<Optional; DefaultParameterValue(0UL)>] stride: uint64) : 'T[] =
         buffer.ToArray(typeof<'T>, count, offset, stride) :?> 'T[]

src/Tests/Aardvark.Rendering.Tests/Tests/Buffer/ToArray.fs

@@ -28,71 +28,110 @@ module BufferToArray =
             Expect.throwsT<ArgumentOutOfRangeException> (fun _ -> buffer.ToArray(buffer.ElementType, 4UL, offset = 1UL * elementSize) |> ignore) "Expected out-of-range"
             Expect.throwsT<ArgumentOutOfRangeException> (fun _ -> buffer.ToArray(buffer.ElementType, 2UL, offset = 1UL * elementSize, stride = 3UL * elementSize) |> ignore) "Expected out-of-range"
 
-        let testToArray (referenceEqual: bool) (expected: 'T[]) (offset: uint64) (stride: uint64) (buffer: IBuffer) =
-            let result = buffer.ToArray<'T>(uint64 expected.Length, offset = offset, stride = stride)
+        let testToArray (referenceEqual: bool) (expected: 'T[]) (offset: uint64) (stride: uint64) (count: uint64) (buffer: IBuffer) =
+            let result = buffer.ToArray<'T>(count = count, offset = offset, stride = stride)
             Expect.equal result expected "Result not equal"
             Expect.equal (obj.ReferenceEquals(result, expected)) referenceEqual "Unexpected reference equality"
 
         let arrayBufferFull (_: IRuntime) =
             let array = [| 0; 2; 4; 8 |]
-            ArrayBuffer array |> testToArray true array 0UL 0UL
+            ArrayBuffer array |> testToArray true array 0UL 0UL 42UL
 
         let arrayBufferRange (_: IRuntime) =
             let buffer = ArrayBuffer [| 0; 2; 4; 8 |]
             let elementSize = uint64 buffer.ElementType.CLRSize
-            buffer |> testToArray false [| 2; 4 |] (1UL * elementSize) 0UL
+            buffer |> testToArray false [| 2; 4 |] (1UL * elementSize) 0UL 2UL
 
         let arrayBufferStrided (_: IRuntime) =
             let buffer = ArrayBuffer [| 0; 2; 4; 8 |]
             let elementSize = uint64 buffer.ElementType.CLRSize
-            buffer |> testToArray false [| 2; 8 |] (1UL * elementSize) (2UL * elementSize)
+            buffer |> testToArray false [| 2; 8 |] (1UL * elementSize) (2UL * elementSize) 2UL
+
+        let arrayBufferOutOfRange (_: IRuntime) =
+            let buffer = ArrayBuffer [| 0; 2; 4; 8 |]
+            let elementSize = uint64 buffer.ElementType.CLRSize
+            buffer |> testToArray false Array.empty<int> (4UL * elementSize) elementSize 1UL
+            buffer |> testToArray false [| 4 |] (2UL * elementSize) (2UL * elementSize) 2UL
+
+        let arrayBufferReinterpreted (_: IRuntime) =
+            let input = [| 0; 2; 4; 8 |]
+            let output = input |> Array.map Fun.FloatFromBits
+            ArrayBuffer input |> testToArray false output 0UL 0UL 42UL
 
         let nativeBufferFull (_: IRuntime) =
             let array = [| 0; 2; 4; 8 |]
-            NativeArrayBuffer array |> testToArray false array 0UL 0UL
+            NativeArrayBuffer array |> testToArray false array 0UL 0UL 42UL
 
         let nativeBufferRange (_: IRuntime) =
             let buffer = NativeArrayBuffer [| 0; 2; 4; 8 |]
             let elementSize = uint64 buffer.ElementType.CLRSize
-            buffer |> testToArray false [| 2; 4 |] (1UL * elementSize) 0UL
+            buffer |> testToArray false [| 2; 4 |] (1UL * elementSize) 0UL 2UL
 
         let nativeBufferStrided (_: IRuntime) =
             let buffer = NativeArrayBuffer [| 0; 2; 4; 8 |]
             let elementSize = uint64 buffer.ElementType.CLRSize
-            buffer |> testToArray false [| 2; 8 |] (1UL * elementSize) (2UL * elementSize)
+            buffer |> testToArray false [| 2; 8 |] (1UL * elementSize) (2UL * elementSize) 2UL
+
+        let nativeBufferOutOfRange (_: IRuntime) =
+            let buffer = NativeArrayBuffer [| 0; 2; 4; 8 |]
+            let elementSize = uint64 buffer.ElementType.CLRSize
+            buffer |> testToArray false Array.empty<int> (4UL * elementSize) elementSize 1UL
+            buffer |> testToArray false [| 4 |] (2UL * elementSize) (2UL * elementSize) 2UL
+
+        let nativeBufferReinterpreted (_: IRuntime) =
+            let input = [| 0; 2; 4; 8 |]
+            let output = input |> Array.map Fun.FloatFromBits
+            NativeArrayBuffer input |> testToArray false output 0UL 0UL 42UL
 
         let backendBufferFull (runtime: IRuntime) =
             let array = [| 0; 2; 4; 8; 16; 32 |]
             use buffer = runtime.PrepareBuffer(ArrayBuffer array)
-            buffer |> testToArray false array 0UL 0UL
+            buffer |> testToArray false array 0UL 0UL 42UL
 
         let backendBufferRange (runtime: IRuntime) =
             let array = ArrayBuffer [| 0; 2; 4; 8; 16; 32 |]
             let elementSize = uint64 array.ElementType.CLRSize
             use buffer = runtime.PrepareBuffer(array)
-            buffer |> testToArray false [| 8; 16 |] (3UL * elementSize) 0UL
+            buffer |> testToArray false [| 8; 16 |] (3UL * elementSize) 0UL 2UL
 
         let backendBufferStrided (runtime: IRuntime) =
             let array = ArrayBuffer [| 0; 2; 4; 8; 16; 32 |]
             let elementSize = uint64 array.ElementType.CLRSize
             use buffer = runtime.PrepareBuffer(array)
-            buffer |> testToArray false [| 2; 16 |] (1UL * elementSize) (3UL * elementSize)
-
-    let tests (backend : Backend) =
-        [
-            "Invalid arguments",        Cases.invalidArgs
+            buffer |> testToArray false [| 2; 16 |] (1UL * elementSize) (3UL * elementSize) 2UL
 
-            "ArrayBuffer full",         Cases.arrayBufferFull
-            "ArrayBuffer range",        Cases.arrayBufferRange
-            "ArrayBuffer strided",      Cases.arrayBufferStrided
+        let backendBufferOutOfRange (runtime: IRuntime) =
+            let array = ArrayBuffer [| 0; 2; 4; 8; 16; 32 |]
+            let elementSize = uint64 array.ElementType.CLRSize
+            use buffer = runtime.PrepareBuffer(array)
+            buffer |> testToArray false Array.empty<int> (6UL * elementSize) elementSize 1UL
+            buffer |> testToArray false [| 4 |] (2UL * elementSize) (4UL * elementSize) 2UL
 
-            "INativeBuffer full",       Cases.nativeBufferFull
-            "INativeBuffer range",      Cases.nativeBufferRange
-            "INativeBuffer strided",    Cases.nativeBufferStrided
+        let backendBufferReinterpreted (runtime: IRuntime) =
+            let array = ArrayBuffer [| 0; 2; 4; 8; 16; 32 |]
+            use buffer = runtime.PrepareBuffer(array)
+            let output = array.Data |> unbox<int[]> |> Array.map Fun.FloatFromBits
+            buffer |> testToArray false output 0UL 0UL 42UL
 
-            "IBackendBuffer full",      Cases.backendBufferFull
-            "IBackendBuffer range",     Cases.backendBufferRange
-            "IBackendBuffer strided",   Cases.backendBufferStrided
+    let tests (backend : Backend) =
+        [
+            "ArrayBuffer full",             Cases.arrayBufferFull
+            "ArrayBuffer range",            Cases.arrayBufferRange
+            "ArrayBuffer strided",          Cases.arrayBufferStrided
+            "ArrayBuffer out-of-range",     Cases.arrayBufferOutOfRange
+            "ArrayBuffer reinterpreted",    Cases.arrayBufferReinterpreted
+
+            "INativeBuffer full",           Cases.nativeBufferFull
+            "INativeBuffer range",          Cases.nativeBufferRange
+            "INativeBuffer strided",        Cases.nativeBufferStrided
+            "INativeBuffer out-of-range",   Cases.nativeBufferOutOfRange
+            "INativeBuffer reinterpreted",  Cases.nativeBufferReinterpreted
+
+            "IBackendBuffer full",          Cases.backendBufferFull
+            "IBackendBuffer range",         Cases.backendBufferRange
+            "IBackendBuffer strided",       Cases.backendBufferStrided
+            "IBackendBuffer out-of-range",  Cases.backendBufferOutOfRange
+            "IBackendBuffer reinterpreted", Cases.backendBufferReinterpreted
 
         ]
         |> prepareCases backend "ToArray"

src/Tests/Aardvark.Rendering.Tests/Tests/Utilities.fs

@@ -334,18 +334,18 @@ module ``Expecto Extensions`` =
         let inline approxEqualAux< ^a, ^b when (^a or ^b) : (static member ApproximateEquals : ^a * ^a * float -> bool)> (_ : ^ b) (a : 'a) (b : 'a) (eps : float) =
             (((^a or ^b) : (static member ApproximateEquals : ^a * ^a * float -> bool) (a, b, eps)))
 
-        let inline approxEquals a b eps msg =
-            if not (approxEqualAux Unchecked.defaultof<Fun> a b eps) then
-                Expect.equal a b msg
+        let inline approxEquals actual expected eps msg =
+            if not (approxEqualAux Unchecked.defaultof<Fun> actual expected eps) then
+                Expect.equal actual expected msg
 
-        let inline relativeApproxEquals (a : float) (b : float) eps msg =
-            let scale = max (abs a) (abs b)
+        let inline relativeApproxEquals (actual: float) (expected: float) eps msg =
+            let scale = max (abs actual) (abs expected)
             if not (Fun.IsTiny(scale, eps)) then
-                let ra = a / scale
-                let rb = b / scale
+                let ra = actual / scale
+                let re = expected / scale
 
-                if not (Fun.ApproximateEquals(ra, rb, eps)) then
-                    Expect.equal a b msg
+                if not (Fun.ApproximateEquals(ra, re, eps)) then
+                    Expect.equal actual expected msg
 
     module ExpectoOverrides =