add: ClArray.assign tests

Author: IgorErin

src/GraphBLAS-sharp.Backend/Common/ClArray.fs

@@ -562,34 +562,34 @@ module ClArray =
     let assign<'a> (clContext: ClContext) workGroupSize =
 
         let assign =
-            <@ fun (ndRange: Range1D) startPosition appendedArrayLength (inputArray: ClArray<'a>) (result: ClArray<'a>) ->
+            <@ fun (ndRange: Range1D) targetPosition sourceArrayLength (sourceArray: ClArray<'a>) (targetArray: ClArray<'a>) ->
 
                 let gid = ndRange.GlobalID0
 
-                let resultPosition = gid + startPosition
+                let resultPosition = gid + targetPosition
 
-                if gid < appendedArrayLength then
+                if gid < sourceArrayLength then
 
-                    result.[resultPosition] <- inputArray.[gid] @>
+                    targetArray.[resultPosition] <- sourceArray.[gid] @>
 
         let kernel = clContext.Compile assign
 
-        fun (processor: MailboxProcessor<_>) (targetArray: ClArray<'a>) startPosition (appendedArray: ClArray<'a>) ->
-            if startPosition < 0 then
+        fun (processor: MailboxProcessor<_>) (sourceArray: ClArray<'a>) targetPosition (targetArray: ClArray<'a>) ->
+            if targetPosition < 0 then
                 failwith "The starting position cannot be less than zero"
 
-            if startPosition + appendedArray.Length > targetArray.Length then
+            if targetPosition + sourceArray.Length > targetArray.Length then
                 failwith "The array should fit completely"
 
             let ndRange =
-                Range1D.CreateValid(appendedArray.Length, workGroupSize)
+                Range1D.CreateValid(targetArray.Length, workGroupSize)
 
             let kernel = kernel.GetKernel()
 
             processor.Post(
                 Msg.MsgSetArguments
                     (fun () ->
-                        kernel.KernelFunc ndRange appendedArray.Length appendedArray.Length appendedArray targetArray)
+                        kernel.KernelFunc ndRange targetPosition sourceArray.Length sourceArray targetArray)
             )
 
             processor.Post(Msg.CreateRunMsg<_, _>(kernel))

tests/GraphBLAS-sharp.Tests/Common/ClArray/Assign.fs

@@ -1,4 +1,4 @@
-module GraphBLAS.FSharp.Tests.Backned.Common.ClArray.Assign
+module GraphBLAS.FSharp.Tests.Backend.Common.ClArray.Assign
 
 open Expecto
 open Brahma.FSharp
@@ -13,21 +13,20 @@ let processor = Context.defaultContext.Queue
 
 let config =
     { Utils.defaultConfig with
-          arbitrary = [ typeof<Generators.ArrayAndChunkPositions> ] }
+          arbitrary = [ typeof<Generators.AssignArray> ] }
 
-let makeTest<'a> isEqual testFun (source: 'a []) (target: 'a []) =
+let makeTest<'a> isEqual testFun (source: 'a [], target: 'a [], targetPosition: int) =
 
     if source.Length > 0
         && target.Length > 0 then
 
         let clSource = context.CreateClArray source
         let clTarget = context.CreateClArray target
-        let targetPosition = 0
 
         testFun processor clSource targetPosition clTarget
 
-        let actual = clSource.ToHostAndFree processor
-        clTarget.Free processor
+        clSource.Free processor
+        let actual = clTarget.ToHostAndFree processor
 
         // write to target --- target expected
         Array.blit source 0 target targetPosition source.Length
@@ -37,15 +36,15 @@ let makeTest<'a> isEqual testFun (source: 'a []) (target: 'a []) =
 
 let createTest<'a when 'a : equality> isEqual =
     ClArray.assign context Utils.defaultWorkGroupSize
-    |> makeTest isEqual
+    |> makeTest<'a> isEqual
     |> testPropertyWithConfig config $"test on %A{typeof<'a>}"
 
 let tests =
     [ createTest<int> (=)
 
       if Utils.isFloat64Available context.ClDevice then
-        createTest<float> (=)
+        createTest<float> Utils.floatIsEqual
 
-      createTest<float32> (=)
+      createTest<float32> Utils.float32IsEqual
       createTest<bool> (=) ]
     |> testList "Assign"

tests/GraphBLAS-sharp.Tests/Common/ClArray/ChunkBySize.fs

@@ -1,4 +1,4 @@
-module GraphBLAS.FSharp.Tests.Backend.Common.ClArray.chunkBySize
+module GraphBLAS.FSharp.Tests.Backend.Common.ClArray.ChunkBySize
 
 open Expecto
 open Brahma.FSharp

tests/GraphBLAS-sharp.Tests/Generators.fs

@@ -956,3 +956,63 @@ module Generators =
         static member BoolType() =
             arrayAndChunkPosition <| Arb.generate<bool>
             |> Arb.fromGen
+
+    type AssignArray() =
+        static let pairOfVectorsOfEqualSize (valuesGenerator: Gen<'a>) =
+            gen {
+                let! targetArrayLength = Gen.sized <| fun size -> Gen.choose (2, size)
+
+                let! targetArray = Gen.arrayOfLength targetArrayLength valuesGenerator
+
+                let! sourceArrayLength = Gen.choose (1, targetArrayLength)
+
+                let! sourceArray = Gen.arrayOfLength sourceArrayLength valuesGenerator
+
+                let! startPosition = Gen.choose (0, targetArrayLength - sourceArrayLength)
+
+                return (sourceArray, targetArray, startPosition)
+            }
+
+        static member IntType() =
+            pairOfVectorsOfEqualSize <| Arb.generate<int>
+            |> Arb.fromGen
+
+        static member FloatType() =
+            pairOfVectorsOfEqualSize
+            <| (Arb.Default.NormalFloat()
+                |> Arb.toGen
+                |> Gen.map float)
+            |> Arb.fromGen
+
+        static member Float32Type() =
+            pairOfVectorsOfEqualSize
+            <| (normalFloat32Generator <| System.Random())
+            |> Arb.fromGen
+
+        static member SByteType() =
+            pairOfVectorsOfEqualSize <| Arb.generate<sbyte>
+            |> Arb.fromGen
+
+        static member ByteType() =
+            pairOfVectorsOfEqualSize <| Arb.generate<byte>
+            |> Arb.fromGen
+
+        static member Int16Type() =
+            pairOfVectorsOfEqualSize <| Arb.generate<int16>
+            |> Arb.fromGen
+
+        static member UInt16Type() =
+            pairOfVectorsOfEqualSize <| Arb.generate<uint16>
+            |> Arb.fromGen
+
+        static member Int32Type() =
+            pairOfVectorsOfEqualSize <| Arb.generate<int32>
+            |> Arb.fromGen
+
+        static member UInt32Type() =
+            pairOfVectorsOfEqualSize <| Arb.generate<uint32>
+            |> Arb.fromGen
+
+        static member BoolType() =
+            pairOfVectorsOfEqualSize <| Arb.generate<bool>
+            |> Arb.fromGen

tests/GraphBLAS-sharp.Tests/Program.fs

@@ -95,5 +95,5 @@ open GraphBLAS.FSharp.Tests
 
 [<EntryPoint>]
 let main argv =
-    testList "lol" [ Common.Reduce.ByKey.testsSegmentsSequentialOption ]
+    testList "lol" [ Common.ClArray.Assign.tests ]
     |> runTestsWithCLIArgs [] argv