RawCommandQueue 2

kirillgarbar · kirillgarbar · commit 5195a86690d6 · 2024-05-10T17:27:12.000+03:00
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Algorithms/BFS.fs b/tests/GraphBLAS-sharp.Tests/Backend/Algorithms/BFS.fs
@@ -78,9 +78,9 @@ let testFixtures (testContext: TestContext) =
 
               matrix.Dispose queue
               matrixBool.Dispose queue
-              res.Dispose queue
-              resSparse.Dispose queue
-              resPushPull.Dispose queue
+              res.Dispose()
+              resSparse.Dispose()
+              resPushPull.Dispose()
 
               match resHost, resHostSparse, resHostPushPull with
               | Vector.Dense resHost, Vector.Dense resHostSparse, Vector.Dense resHostPushPull ->
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Algorithms/PageRank.fs b/tests/GraphBLAS-sharp.Tests/Backend/Algorithms/PageRank.fs
@@ -104,7 +104,7 @@ let testFixtures (testContext: TestContext) =
 
               preparedMatrix.Dispose queue
               matrix.Dispose queue
-              res.Dispose queue
+              res.Dispose()
 
               match resHost with
               | Vector.Dense resHost ->
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Algorithms/SSSP.fs b/tests/GraphBLAS-sharp.Tests/Backend/Algorithms/SSSP.fs
@@ -52,7 +52,7 @@ let testFixtures (testContext: TestContext) =
               let resHost = resDense.ToHost queue
 
               matrix.Dispose queue
-              resDense.Dispose queue
+              resDense.Dispose()
 
               match resHost with
               | Vector.Dense resHost ->
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Blit.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Blit.fs
@@ -24,7 +24,7 @@ let makeTest<'a> isEqual testFun (source: 'a [], sourceIndex, target: 'a [], tar
 
         testFun processor clSource sourceIndex clTarget targetIndex count
 
-        clSource.Free processor
+        clSource.Free()
         let actual = clTarget.ToHostAndFree processor
 
         // write to target --- target expected
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Choose.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Choose.fs
@@ -73,8 +73,8 @@ let makeTest2 testContext isEqual opMap testFun (firstArray: 'a [], secondArray:
                 testFun processor HostInterop clFirstArray clSecondArray
 
             let actual = clActual.ToHostAndFree processor
-            clFirstArray.Free processor
-            clSecondArray.Free processor
+            clFirstArray.Free()
+            clSecondArray.Free()
 
             "Results must be the same"
             |> Utils.compareArrays isEqual actual expected
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/ChunkBySize.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/ChunkBySize.fs
@@ -25,7 +25,7 @@ let makeTestGetChunk<'a when 'a: equality> testFun (array: 'a [], startPosition,
         let (clActual: ClArray<'a>) =
             testFun processor HostInterop clArray startPosition count
 
-        clArray.Free processor
+        clArray.Free()
         let actual = clActual.ToHostAndFree processor
 
         "Results must be the same"
@@ -56,7 +56,7 @@ let makeTestChunkBySize<'a when 'a: equality> isEqual testFun (array: 'a [], chu
         let clActual: ClArray<'a> [] =
             (testFun processor HostInterop chunkSize clArray)
 
-        clArray.Free processor
+        clArray.Free()
 
         let actual =
             clActual
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Concat.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Concat.fs
@@ -26,8 +26,7 @@ let makeTest<'a> isEqual testFun (arrays: 'a [] []) =
         // release
         let actual = clActual.ToHostAndFree processor
 
-        clArrays
-        |> Seq.iter (fun array -> array.Free processor)
+        clArrays |> Seq.iter (fun array -> array.Free())
 
         let expected = Seq.concat arrays |> Seq.toArray
 
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Copy.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Copy.fs
@@ -19,15 +19,18 @@ let q = Context.defaultContext.Queue
 
 let config = Utils.defaultConfig
 
-let makeTest<'a when 'a: equality> copyFun (array: array<'a>) =
+let makeTest<'a when 'a: equality>
+    (copyFun: RawCommandQueue -> AllocationFlag -> ClArray<'a> -> int -> ClArray<'a>)
+    (array: array<'a>)
+    =
     if array.Length > 0 then
-        let clArray = context.CreateClArray array
+        let clArray: ClArray<'a> = context.CreateClArray array
 
         let actual =
-            (copyFun q HostInterop clArray: ClArray<_>)
+            (copyFun q DeviceOnly clArray clArray.Length)
                 .ToHostAndFree q
 
-        clArray.Free q
+        clArray.Free()
 
         logger.debug (
             eventX "Actual is {actual}"
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/ExcludeElements.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/ExcludeElements.fs
@@ -29,8 +29,8 @@ let makeTest<'a> isEqual (zero: 'a) testFun ((array, bitmap): 'a array * int arr
             actual
             |> Option.map (fun a -> a.ToHostAndFree processor)
 
-        arrayCl.Free processor
-        bitmapCl.Free processor
+        arrayCl.Free()
+        bitmapCl.Free()
 
         let expected =
             (bitmap, array)
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Item.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Item.fs
@@ -24,7 +24,7 @@ let makeTest<'a when 'a: equality> testFun (array: 'a [], position) =
 
         let result: ClCell<'a> = testFun processor position clArray
 
-        clArray.Free processor
+        clArray.Free()
         let actual = result.ToHost processor
 
         let expected = Array.item position array
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Replicate.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/Replicate.fs
@@ -27,7 +27,7 @@ let makeTest<'a when 'a: equality> replicateFun (array: array<'a>) i =
             (replicateFun q HostInterop clArray i: ClArray<'a>)
                 .ToHostAndFree q
 
-        clArray.Free q
+        clArray.Free()
 
         logger.debug (
             eventX $"Actual is {actual}"
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/Gather.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/Gather.fs
@@ -39,8 +39,8 @@ let makeTest isEqual testFun (array: (uint * 'a * 'a) []) =
 
         testFun processor clPositions clValues clTarget
 
-        clPositions.Free processor
-        clValues.Free processor
+        clPositions.Free()
+        clValues.Free()
 
         let actual = clTarget.ToHostAndFree processor
 
@@ -81,7 +81,7 @@ let makeTestInit isEqual testFun indexMap (array: ('a * 'a) []) =
 
         testFun processor clValues clTarget
 
-        clValues.Free processor
+        clValues.Free()
 
         let actual = clTarget.ToHostAndFree processor
 
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/Reduce/Reduce.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/Reduce/Reduce.fs
@@ -19,7 +19,7 @@ let wgSize = Constants.Common.defaultWorkGroupSize
 
 let q = Context.defaultContext.Queue
 
-let makeTest (reduce: DeviceCommandQueue<_> -> ClArray<'a> -> ClCell<'a>) plus zero (array: 'a []) =
+let makeTest (reduce: RawCommandQueue -> ClArray<'a> -> ClCell<'a>) plus zero (array: 'a []) =
 
     if array.Length > 0 then
         let reduce = reduce q
@@ -33,7 +33,7 @@ let makeTest (reduce: DeviceCommandQueue<_> -> ClArray<'a> -> ClCell<'a>) plus z
             let clArray = context.CreateClArray array
             let total = reduce clArray
 
-            clArray.Free q
+            clArray.Free()
             total.ToHostAndFree q
 
         logger.debug (
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/Reduce/ReduceByKey.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/Reduce/ReduceByKey.fs
@@ -52,8 +52,8 @@ let makeTest isEqual reduce reduceOp (arrayAndKeys: (int * 'a) []) =
         let clActualValues, clActualKeys: ClArray<'a> * ClArray<int> =
             reduce processor HostInterop resultLength clKeys clValues
 
-        clValues.Free processor
-        clKeys.Free processor
+        clValues.Free()
+        clKeys.Free()
 
         let actualValues = clActualValues.ToHostAndFree processor
         let actualKeys = clActualKeys.ToHostAndFree processor
@@ -235,9 +235,9 @@ let makeTest2D isEqual reduce reduceOp (array: (int * int * 'a) []) =
         let clActualValues, clFirstActualKeys, clSecondActualKeys: ClArray<'a> * ClArray<int> * ClArray<int> =
             reduce processor HostInterop resultLength clFirstKeys clSecondKeys clValues
 
-        clValues.Free processor
-        clFirstKeys.Free processor
-        clSecondKeys.Free processor
+        clValues.Free()
+        clFirstKeys.Free()
+        clSecondKeys.Free()
 
         let actualValues = clActualValues.ToHostAndFree processor
 
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/Reduce/Sum.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/Reduce/Sum.fs
@@ -32,7 +32,7 @@ let makeTest plus zero sum (array: 'a []) =
             let clArray = context.CreateClArray array
             let (total: ClCell<_>) = sum q clArray
 
-            clArray.Free q
+            clArray.Free()
             total.ToHostAndFree q
 
         logger.debug (
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/Scan/ByKey.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/Scan/ByKey.fs
@@ -41,8 +41,8 @@ let makeTestSequentialSegments isEqual scanHost scanDevice (keysAndValues: (int
         scanDevice processor uniqueKeysCount clValues clKeys clOffsets
 
         let actual = clValues.ToHostAndFree processor
-        clKeys.Free processor
-        clOffsets.Free processor
+        clKeys.Free()
+        clOffsets.Free()
 
         let keysAndValues = Array.zip keys values
 
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/Scan/PrefixSum.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/Scan/PrefixSum.fs
@@ -29,7 +29,7 @@ let makeTest plus zero isEqual scan (array: 'a []) =
 
         let actual, actualSum =
             let clArray = context.CreateClArray array
-            let (total: ClCell<_>) = scan q clArray zero
+            let (total: ClCell<_>) = scan q clArray
 
             let actual = clArray.ToHostAndFree q
             let actualSum = total.ToHostAndFree q
@@ -45,7 +45,7 @@ let makeTest plus zero isEqual scan (array: 'a []) =
             |> Array.mapFold
                 (fun s t ->
                     let a = plus s t
-                    a, a)
+                    s, a)
                 zero
 
         logger.debug (
@@ -60,13 +60,11 @@ let makeTest plus zero isEqual scan (array: 'a []) =
         |> Tests.Utils.compareArrays isEqual actual expected
 
 let testFixtures plus plusQ zero isEqual name =
-    Common.PrefixSum.runIncludeInPlace plusQ context wgSize
+    Common.PrefixSum.runExcludeInPlace plusQ zero context wgSize
     |> makeTest plus zero isEqual
     |> testPropertyWithConfig config $"Correctness on %s{name}"
 
 let tests =
-    //q.Error.Add(fun e -> failwithf "%A" e)
-
     [ testFixtures (+) <@ (+) @> 0 (=) "int add"
       testFixtures (+) <@ (+) @> 0uy (=) "byte add"
       testFixtures max <@ max @> 0 (=) "int max"
@@ -83,4 +81,4 @@ let tests =
       testFixtures min <@ min @> System.Byte.MaxValue (=) "byte min"
       testFixtures (||) <@ (||) @> false (=) "bool logic-or"
       testFixtures (&&) <@ (&&) @> true (=) "bool logic-and" ]
-    |> testList "Backend.Common.PrefixSum tests"
+    |> testList "Backend.Common.PrefixSum tests"
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Common/Scatter.fs b/tests/GraphBLAS-sharp.Tests/Backend/Common/Scatter.fs
@@ -33,8 +33,8 @@ let makeTest<'a when 'a: equality> hostScatter scatter (array: (int * 'a) []) (r
 
             scatter q clPositions clValues clResult
 
-            clValues.Free q
-            clPositions.Free q
+            clValues.Free()
+            clPositions.Free()
             clResult.ToHostAndFree q
 
         $"Arrays should be equal."
@@ -81,7 +81,7 @@ let makeTestInit<'a when 'a: equality> hostScatter valueMap scatter (positions:
 
         scatter q clPositions clResult
 
-        clPositions.Free q
+        clPositions.Free()
         let actual = clResult.ToHostAndFree q
 
         $"Arrays should be equal."
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Matrix/Map.fs b/tests/GraphBLAS-sharp.Tests/Backend/Matrix/Map.fs
@@ -52,7 +52,7 @@ let checkResult isEqual op zero (baseMtx: 'a [,]) (actual: Matrix<'a>) =
 let correctnessGenericTest
     zero
     op
-    (addFun: DeviceCommandQueue<_> -> AllocationFlag -> ClMatrix<'a> -> ClMatrix<'b>)
+    (addFun: RawCommandQueue -> AllocationFlag -> ClMatrix<'a> -> ClMatrix<'b>)
     toCOOFun
     (isEqual: 'a -> 'a -> bool)
     q
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Matrix/Map2.fs b/tests/GraphBLAS-sharp.Tests/Backend/Matrix/Map2.fs
@@ -52,7 +52,7 @@ let checkResult isEqual op zero (baseMtx1: 'a [,]) (baseMtx2: 'a [,]) (actual: M
 let correctnessGenericTest
     zero
     op
-    (addFun: DeviceCommandQueue<_> -> AllocationFlag -> ClMatrix<'a> -> ClMatrix<'a> -> ClMatrix<'c>)
+    (addFun: RawCommandQueue -> AllocationFlag -> ClMatrix<'a> -> ClMatrix<'a> -> ClMatrix<'c>)
     toCOOFun
     (isEqual: 'a -> 'a -> bool)
     q
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Matrix/Merge.fs b/tests/GraphBLAS-sharp.Tests/Backend/Matrix/Merge.fs
@@ -190,7 +190,7 @@ let makeTestCSR isEqual zero testFun (leftArray: 'a [,], rightArray: 'a [,]) =
 
         let leftValues = clLeftValues.ToHostAndFree processor
         let rightValues = clRightValues.ToHostAndFree processor
-        clIsEndOfRow.Free processor
+        clIsEndOfRow.Free()
         let isLeft = clIsLeft.ToHostAndFree processor
 
         let actualValues =
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Matrix/SpGeMM/Expand.fs b/tests/GraphBLAS-sharp.Tests/Backend/Matrix/SpGeMM/Expand.fs
@@ -134,7 +134,7 @@ let makeExpandTest isEqual zero testFun (leftArray: 'a [,], rightArray: 'a [,])
 
             clLeftMatrix.Dispose processor
             clRightMatrix.Dispose processor
-            clSegmentPointers.Free processor
+            clSegmentPointers.Free()
 
             let actualLeftValues =
                 clActualLeftValues.ToHostAndFree processor
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/AssignByMask.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/AssignByMask.fs
@@ -50,8 +50,8 @@ let checkResult isZero isComplemented (actual: Vector<'a>) (vector: 'a []) (mask
 
 let makeTest<'a when 'a: struct and 'a: equality>
     (isZero: 'a -> bool)
-    (toDense: DeviceCommandQueue<_> -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
-    (fillVector: DeviceCommandQueue<Msg> -> AllocationFlag -> ClVector<'a> -> ClVector<'a> -> 'a -> ClVector<'a>)
+    (toDense: RawCommandQueue -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
+    (fillVector: RawCommandQueue -> AllocationFlag -> ClVector<'a> -> ClVector<'a> -> 'a -> ClVector<'a>)
     isComplemented
     case
     (vector: 'a [], mask: 'a [], value: 'a)
@@ -80,10 +80,10 @@ let makeTest<'a when 'a: struct and 'a: equality>
 
             let actual = cooClActual.ToHost q
 
-            clLeftVector.Dispose q
-            clMaskVector.Dispose q
-            clActual.Dispose q
-            cooClActual.Dispose q
+            clLeftVector.Dispose()
+            clMaskVector.Dispose()
+            clActual.Dispose()
+            cooClActual.Dispose()
 
             checkResult isZero isComplemented actual vector mask value
         with
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/Convert.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/Convert.fs
@@ -21,7 +21,7 @@ let wgSize = Constants.Common.defaultWorkGroupSize
 
 let makeTest
     formatFrom
-    (convertFun: DeviceCommandQueue<_> -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
+    (convertFun: RawCommandQueue -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
     isZero
     case
     (array: 'a [])
@@ -41,8 +41,8 @@ let makeTest
 
             let res = convertedVector.ToHost q
 
-            clVector.Dispose q
-            convertedVector.Dispose q
+            clVector.Dispose()
+            convertedVector.Dispose()
 
             res
 
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/Copy.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/Copy.fs
@@ -37,7 +37,7 @@ let checkResult (isEqual: 'a -> 'a -> bool) (actual: Vector<'a>) (expected: Vect
 let correctnessGenericTest<'a when 'a: struct>
     isEqual
     zero
-    (copy: DeviceCommandQueue<Brahma.FSharp.Msg> -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
+    (copy: RawCommandQueue -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
     (case: OperationCase<VectorFormat>)
     (array: 'a [])
     =
@@ -54,8 +54,8 @@ let correctnessGenericTest<'a when 'a: struct>
         let clVectorCopy = copy q HostInterop clVector
         let actual = clVectorCopy.ToHost q
 
-        clVector.Dispose q
-        clVectorCopy.Dispose q
+        clVector.Dispose()
+        clVectorCopy.Dispose()
 
         checkResult isEqual actual expected
 
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/Map.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/Map.fs
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/Map2.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/Map2.fs
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/Merge.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/Merge.fs
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/OfList.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/OfList.fs
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/SpMSpV.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/SpMSpV.fs
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/SpMV.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/SpMV.fs
diff --git a/tests/GraphBLAS-sharp.Tests/Backend/Vector/ZeroCreate.fs b/tests/GraphBLAS-sharp.Tests/Backend/Vector/ZeroCreate.fs
diff --git a/tests/GraphBLAS-sharp.Tests/Helpers.fs b/tests/GraphBLAS-sharp.Tests/Helpers.fs
