Fix merge

dpanfilyonok · dpanfilyonok · commit 1cf8c186754b · 2021-05-17T17:36:12.000+03:00
diff --git a/src/GraphBLAS-sharp/Algorithms/BFS.fs b/src/GraphBLAS-sharp/Algorithms/BFS.fs
@@ -19,14 +19,16 @@ module BFS =
             let! currentLevelScalar = Scalar.create currentLevel
 
             let! frontierMask = Vector.mask frontier
-            do! Vector.fillSubVector frontierMask levels currentLevelScalar
+            do! Vector.fillSubVector levels frontierMask currentLevelScalar
 
             let! levelsComplemented = Vector.complemented levels
             do! Matrix.mxvWithMask AnyAll.bool levelsComplemented transposed frontier // q[!v] = (A' ||.&& q)' = q' ||.&& A -- replace + comp
             >>= Vector.assignVector frontier
 
-            // TODO need export or sync for scalar
-            let! (Scalar succ) = Vector.reduce AnyAll.bool frontier
+            let! succ =
+                Vector.reduce AnyAll.bool frontier
+                >>= Scalar.exportValue
+
             break' <- not succ
 
         return levels
diff --git a/src/GraphBLAS-sharp/Algorithms/BetweennessCentrality.fs b/src/GraphBLAS-sharp/Algorithms/BetweennessCentrality.fs
@@ -32,9 +32,11 @@ module BetweennessCentrality =
             do! Matrix.vxmWithMask AddMult.int pMask q matrix
             >>= Vector.assignVector q
 
-            do! Vector.reduce Add.int q
-            >>= fun (Scalar s) -> EvalGB.return' (sum <- s)
+            let! sum' =
+                Vector.reduce Add.int q
+                >>= Scalar.exportValue
 
+            sum <- sum'
             d <- d + 1
 
         let! t1 = Vector.zeroCreate<float32> n
diff --git a/src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs b/src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs
@@ -13,5 +13,5 @@ module TriangleCounting =
         let! result = (matrix', transposed) ||> Matrix.mxmWithMask AddMult.int lowerTriangularMask
         let! count = result |> Matrix.reduce Add.int
 
-        return! (Scalar.exportValue count)
+        return! Scalar.exportValue count
     }
diff --git a/src/GraphBLAS-sharp/Backend/COOVector/AssignSubVector.fs b/src/GraphBLAS-sharp/Backend/COOVector/AssignSubVector.fs
@@ -20,8 +20,8 @@ module internal AssignSubVector =
     let run (leftIndices: int[]) (leftValues: 'a[]) (rightIndices: int[]) (rightValues: 'a[]) (maskIndices: int[]) : OpenCLEvaluation<int[] * 'a[]> =
         if leftValues.Length = 0 then
             opencl {
-                let! resultIndices = Copy.run rightIndices
-                let! resultValues = Copy.run rightValues
+                let! resultIndices = Copy.copyArray rightIndices
+                let! resultValues = Copy.copyArray rightValues
 
                 return resultIndices, resultValues
             }
diff --git a/src/GraphBLAS-sharp/Backend/COOVector/FillSubVector.fs b/src/GraphBLAS-sharp/Backend/COOVector/FillSubVector.fs
@@ -18,7 +18,7 @@ module internal FillSubVector =
     let run (leftIndices: int[]) (leftValues: 'a[]) (rightIndices: int[]) (scalar: 'a[]) : OpenCLEvaluation<int[] * 'a[]> =
         if leftValues.Length = 0 then
             opencl {
-                let! resultIndices = Copy.run rightIndices
+                let! resultIndices = Copy.copyArray rightIndices
                 let! resultValues = Replicate.run rightIndices.Length scalar
 
                 return resultIndices, resultValues
diff --git a/src/GraphBLAS-sharp/Backend/COOVector/Utilities/AssignSubVector/Filter.fs b/src/GraphBLAS-sharp/Backend/COOVector/Utilities/AssignSubVector/Filter.fs
@@ -8,7 +8,7 @@ open GraphBLAS.FSharp.Backend.Common
 [<AutoOpen>]
 module internal Filter =
     let filter (leftIndices: int[]) (leftValues: 'a[]) (rightIndices: int[]) (rightValues: 'a[]) (bitmap: bool[]) : OpenCLEvaluation<int[] * 'a[] * int[]> = opencl {
-        let workGroupSize = Utils.workGroupSize
+        let workGroupSize = Utils.defaultWorkGroupSize
         let firstSide = leftValues.Length
         let secondSide = rightIndices.Length
         let sumOfSides = firstSide + secondSide
@@ -110,7 +110,7 @@ module internal Filter =
         let rawPositions = Array.create sumOfSides 1
 
         do! RunCommand merge <| fun kernelPrepare ->
-            let ndRange = _1D(Utils.workSize sumOfSides, workGroupSize)
+            let ndRange = _1D(Utils.getDefaultGlobalSize sumOfSides, workGroupSize)
             kernelPrepare
                 ndRange
                 leftIndices
diff --git a/src/GraphBLAS-sharp/Backend/COOVector/Utilities/AssignSubVector/Intersect.fs b/src/GraphBLAS-sharp/Backend/COOVector/Utilities/AssignSubVector/Intersect.fs
@@ -8,7 +8,7 @@ open GraphBLAS.FSharp.Backend.Common
 [<AutoOpen>]
 module internal Intersect =
     let intersect (leftIndices: int[]) (leftValues: 'a[]) (rightIndices: int[]) : OpenCLEvaluation<bool[] * 'a[]> = opencl {
-        let workGroupSize = Utils.workGroupSize
+        let workGroupSize = Utils.defaultWorkGroupSize
         let firstSide = leftValues.Length
         let secondSide = rightIndices.Length
         let sumOfSides = firstSide + secondSide
@@ -100,7 +100,7 @@ module internal Intersect =
         let resultValues = Array.create secondSide Unchecked.defaultof<'a>
 
         do! RunCommand merge <| fun kernelPrepare ->
-            let ndRange = _1D(Utils.workSize sumOfSides, workGroupSize)
+            let ndRange = _1D(Utils.getDefaultGlobalSize sumOfSides, workGroupSize)
             kernelPrepare
                 ndRange
                 leftIndices
diff --git a/src/GraphBLAS-sharp/Backend/COOVector/Utilities/AssignSubVector/PreparePositions.fs b/src/GraphBLAS-sharp/Backend/COOVector/Utilities/AssignSubVector/PreparePositions.fs
@@ -22,7 +22,7 @@ module internal PreparePositions =
             @>
 
         do! RunCommand preparePositions <| fun kernelPrepare ->
-            let ndRange = _1D(Utils.workSize (length - 1), Utils.workGroupSize)
+            let ndRange = _1D(Utils.getDefaultGlobalSize (length - 1), Utils.defaultWorkGroupSize)
             kernelPrepare
                 ndRange
                 allIndices
diff --git a/src/GraphBLAS-sharp/Backend/COOVector/Utilities/FillSubVector/Merge.fs b/src/GraphBLAS-sharp/Backend/COOVector/Utilities/FillSubVector/Merge.fs
@@ -9,7 +9,7 @@ open GraphBLAS.FSharp.Backend.Common
 [<AutoOpen>]
 module internal Merge =
     let merge (leftIndices: int[]) (leftValues: 'a[]) (rightIndices: int[]) (scalar: 'a[]) : OpenCLEvaluation<int[] * 'a[]> = opencl {
-        let workGroupSize = Utils.workGroupSize
+        let workGroupSize = Utils.defaultWorkGroupSize
         let firstSide = leftValues.Length
         let secondSide = rightIndices.Length
         let sumOfSides = firstSide + secondSide
@@ -105,7 +105,7 @@ module internal Merge =
         let allValues = Array.create sumOfSides Unchecked.defaultof<'a>
 
         do! RunCommand merge <| fun kernelPrepare ->
-            let ndRange = _1D(Utils.workSize sumOfSides, workGroupSize)
+            let ndRange = _1D(Utils.getDefaultGlobalSize sumOfSides, workGroupSize)
             kernelPrepare
                 ndRange
                 leftIndices
diff --git a/src/GraphBLAS-sharp/Backend/COOVector/Utilities/FillSubVector/PreparePositions.fs b/src/GraphBLAS-sharp/Backend/COOVector/Utilities/FillSubVector/PreparePositions.fs
@@ -24,7 +24,7 @@ module internal PreparePositions =
         let rawPositions = Array.create length 1
 
         do! RunCommand preparePositions <| fun kernelPrepare ->
-            let ndRange = _1D(Utils.workSize (length - 1), Utils.workGroupSize)
+            let ndRange = _1D(Utils.getDefaultGlobalSize (length - 1), Utils.defaultWorkGroupSize)
             kernelPrepare
                 ndRange
                 allIndices
diff --git a/src/GraphBLAS-sharp/Backend/Common/Replicate.fs b/src/GraphBLAS-sharp/Backend/Common/Replicate.fs
@@ -29,7 +29,7 @@ module internal rec Replicate =
         let outputArray = Array.zeroCreate outputArrayLength
 
         do! RunCommand replicate <| fun kernelPrepare ->
-            let ndRange = _1D(Utils.workSize outputArray.Length, Utils.workGroupSize)
+            let ndRange = _1D(Utils.getDefaultGlobalSize outputArray.Length, Utils.defaultWorkGroupSize)
             kernelPrepare ndRange inputArray outputArray
         return outputArray
     }
diff --git a/src/GraphBLAS-sharp/Backend/Common/Sum.fs b/src/GraphBLAS-sharp/Backend/Common/Sum.fs
@@ -12,7 +12,7 @@ module internal rec Sum =
             runNotEmpty inputArray plus zero
 
     let private runNotEmpty (inputArray: 'a[]) (plus: Expr<'a -> 'a -> 'a>) (zero: 'a) = opencl {
-        let workGroupSize = Utils.workGroupSize
+        let workGroupSize = Utils.defaultWorkGroupSize
 
         let firstVertices = Array.zeroCreate <| (inputArray.Length - 1) / workGroupSize + 1
         let secondVertices = Array.zeroCreate <| (firstVertices.Length - 1) / workGroupSize + 1
@@ -39,7 +39,7 @@ module internal rec Sum =
     }
 
     let private scan (inputArray: 'a[]) (inputArrayLength: int) (vertices: 'a[]) (plus: Expr<'a -> 'a -> 'a>) (zero: 'a) = opencl {
-        let workGroupSize = Utils.workGroupSize
+        let workGroupSize = Utils.defaultWorkGroupSize
 
         let scan =
             <@
@@ -66,7 +66,7 @@ module internal rec Sum =
             @>
 
         do! RunCommand scan <| fun kernelPrepare ->
-            let ndRange = _1D(Utils.workSize inputArrayLength, workGroupSize)
+            let ndRange = _1D(Utils.getDefaultGlobalSize inputArrayLength, workGroupSize)
             kernelPrepare
                 ndRange
                 inputArray
diff --git a/src/GraphBLAS-sharp/Objects/Matrix.fs b/src/GraphBLAS-sharp/Objects/Matrix.fs
@@ -79,9 +79,6 @@ and CSRMatrix<'a> =
             ColumnCount = columnsCount
         }
 
-    static member FromFile(pathToMatrix: string) : CSRMatrix<'a> =
-        failwith "Not Implemented yet"
-
 and COOMatrix<'a> =
     {
         RowCount: int
diff --git a/src/GraphBLAS-sharp/Objects/Scalar.fs b/src/GraphBLAS-sharp/Objects/Scalar.fs
@@ -1,7 +1,7 @@
 namespace GraphBLAS.FSharp
 
 type Scalar<'a when 'a : struct> =
-    | Scalar of ArrayScalar<'a>
+    | ScalarWrapped of ArrayScalar<'a>
 
 and ArrayScalar<'a> =
     {
diff --git a/src/GraphBLAS-sharp/Operations/Scalar.fs b/src/GraphBLAS-sharp/Operations/Scalar.fs
@@ -9,7 +9,7 @@ module Scalar =
         constructors
     *)
 
-    let create (value: 'a) : GraphblasEvaluation<Scalar<'a>> = graphblas { return Scalar { Value = [|value|] } }
+    let create (value: 'a) : GraphblasEvaluation<Scalar<'a>> = graphblas { return ScalarWrapped { Value = [| value |] } }
 
     (*
         methods
@@ -19,8 +19,8 @@ module Scalar =
 
     let synchronize (scalar: Scalar<'a>) : GraphblasEvaluation<unit> =
         match scalar with
-        | Scalar s -> opencl {
-            let! _ = ToHost s.Value
+        | ScalarWrapped scalar -> opencl {
+            let! _ = ToHost scalar.Value
 
             return ()
         }
@@ -30,12 +30,13 @@ module Scalar =
         assignment and extraction
     *)
 
-    let exportValue (scalar: Scalar<'a>) : GraphblasEvaluation<'a> =
+    let exportValue (scalar: Scalar<'a>) : GraphblasEvaluation<'a> = graphblas {
+        do! synchronize scalar
+
         match scalar with
-        | Scalar s -> graphblas {
-            do! synchronize scalar
-            return s.Value.[0]
-        }
+        | ScalarWrapped scalar ->
+            return scalar.Value.[0]
+    }
 
     let assignValue (scalar: Scalar<'a>) (target: Scalar<'a>) : GraphblasEvaluation<unit> =
         failwith "Not Implemented yet"
diff --git a/src/GraphBLAS-sharp/Operations/Vector.fs b/src/GraphBLAS-sharp/Operations/Vector.fs
@@ -46,16 +46,16 @@ module Vector =
 
     let tuples (vector: Vector<'a>) : GraphblasEvaluation<VectorTuples<'a>> =
         match vector with
-        | VectorCOO vec ->
+        | VectorCOO vector ->
             opencl {
-                if vec.Values.Length = 0 then
+                if vector.Values.Length = 0 then
                     return {
                         Indices = [||]
                         Values = [||]
                     }
                 else
-                    let! ind = Copy.copyArray vec.Indices
-                    let! vals = Copy.copyArray vec.Values
+                    let! ind = Copy.copyArray vector.Indices
+                    let! vals = Copy.copyArray vector.Values
 
                     return {
                         Indices = ind
@@ -66,29 +66,30 @@ module Vector =
 
     let mask (vector: Vector<'a>) : GraphblasEvaluation<Mask1D> =
         match vector with
-        | VectorCOO vec ->
+        | VectorCOO vector ->
             opencl {
-                let! indices = Copy.copyArray vec.Indices
-                return Mask1D(indices, vec.Size, false)
+                let! indices = Copy.copyArray vector.Indices
+                return Mask1D(indices, vector.Size, false)
             }
         |> EvalGB.fromCl
 
     let complemented (vector: Vector<'a>) : GraphblasEvaluation<Mask1D> =
         match vector with
-        | VectorCOO v ->
-            graphblas {
-                let! resultIndices = Copy.run v.Indices |> EvalGB.fromCl
-                return Mask1D(resultIndices, v.Size, true)
+        | VectorCOO vector ->
+            opencl {
+                let! resultIndices = Copy.copyArray vector.Indices
+                return Mask1D(resultIndices, vector.Size, true)
             }
+        |> EvalGB.fromCl
 
     let switch (vectorFormat: VectorFormat) (vector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
 
     let synchronize (vector: Vector<'a>) : GraphblasEvaluation<unit> =
         match vector with
-        | VectorCOO v ->
+        | VectorCOO vector ->
             opencl {
-                let! _ = ToHost v.Indices
-                let! _ = ToHost v.Values
+                let! _ = if vector.Indices.Length = 0 then opencl { return [||] } else ToHost vector.Indices
+                let! _ = if vector.Values.Length = 0 then opencl { return [||] } else ToHost vector.Values
                 return ()
             }
         |> EvalGB.fromCl
@@ -119,13 +120,15 @@ module Vector =
             if t.Size <> s.Size then
                 invalidArg "source" <| sprintf "The size of source vector must be %A. Received: %A" t.Size s.Size
 
-            if mask.IsComplemented then failwith "Not Implemented yet"
+            if mask.IsComplemented then
+                failwith "Not Implemented yet"
             else
-                graphblas {
-                    let! resultIndices, resultValues = AssignSubVector.run t.Indices t.Values s.Indices s.Values mask.Indices |> EvalGB.fromCl
+                opencl {
+                    let! (resultIndices, resultValues) = COOVector.AssignSubVector.run t.Indices t.Values s.Indices s.Values mask.Indices
                     t.Indices <- resultIndices
                     t.Values <- resultValues
                 }
+        |> EvalGB.fromCl
 
     /// t.[idx] <- value
     let assignValue (target: Vector<'a>) (idx: int) (value: Scalar<'a>) : GraphblasEvaluation<unit> =
@@ -137,14 +140,17 @@ module Vector =
 
     /// vec.[mask] <- value
     let fillSubVector (vector: Vector<'a>) (mask: Mask1D) (value: Scalar<'a>) : GraphblasEvaluation<unit> =
-        match vector with
-        | VectorCOO v ->
-            if mask.IsComplemented then failwith "Not Implemented yet" else
-                graphblas {
-                    let! resultIndices, resultValues = FillSubVector.run v.Indices v.Values mask.Indices scalar.Value |> EvalGB.fromCl
-                    v.Indices <- resultIndices
-                    v.Values <- resultValues
+        match vector, value with
+        | VectorCOO vector, ScalarWrapped scalar ->
+            if mask.IsComplemented then
+                failwith "Not Implemented yet"
+            else
+                opencl {
+                    let! (resultIndices, resultValues) = COOVector.FillSubVector.run vector.Indices vector.Values mask.Indices scalar.Value
+                    vector.Indices <- resultIndices
+                    vector.Values <- resultValues
                 }
+        |> EvalGB.fromCl
 
     (*
         operations
@@ -157,17 +163,16 @@ module Vector =
 
     let reduce (monoid: IMonoid<'a>) (vector: Vector<'a>) : GraphblasEvaluation<Scalar<'a>> =
         match vector with
-        | VectorCOO v ->
-            graphblas {
-                let! result =
-                    opencl {
-                        let (ClosedBinaryOp plus) = monoid.Plus
-                        return! Sum.run v.Values plus monoid.Zero
-                    }
-                    |> EvalGB.fromCl
+        | VectorCOO vector ->
+            opencl {
+                let! result = opencl {
+                    let (ClosedBinaryOp plus) = monoid.Plus
+                    return! Sum.run vector.Values plus monoid.Zero
+                }
 
-                return Scalar {Value = result}
+                return ScalarWrapped { Value = result }
             }
+        |> EvalGB.fromCl
 
     let eWiseAddWithMask (monoid: IMonoid<'a>) (mask: Mask1D) (leftVector: Vector<'a>) (rightVector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
     let eWiseMultWithMask (semiring: ISemiring<'a>) (mask: Mask1D) (leftVector: Vector<'a>) (rightVector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"

Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,5 @@ module TriangleCounting =`
`13`	`13`	`let! result = (matrix', transposed) \|\|> Matrix.mxmWithMask AddMult.int lowerTriangularMask`
`14`	`14`	`let! count = result \|> Matrix.reduce Add.int`
`15`	`15`
`16`		`- return! (Scalar.exportValue count)`
	`16`	`+ return! Scalar.exportValue count`
`17`	`17`	`}`