Merged branch dev from upstream repository

Author: artemgl

Directory.Build.props

@@ -9,5 +9,6 @@
         <Authors>YaccConstructor</Authors>
         <RepositoryUrl>https://github.com/YaccConstructor/GraphBLAS-sharp</RepositoryUrl>
         <!-- owners is not supported in MSBuild -->
+        <DisableFody>true</DisableFody>
     </PropertyGroup>
 </Project>

paket.dependencies

@@ -18,7 +18,7 @@ nuget System.CodeDom 4.7.0
 nuget FSharp.Quotations.Evaluator 2.1.0
 nuget FSharpx.Collections 2.1.3
 nuget FSharpx.Text.StructuredFormat 2.3.0
-nuget Brahma.FSharp.OpenCL.WorkflowBuilder
+nuget Brahma.FSharp.OpenCL.WorkflowBuilder 2.0.0-alpha4
 nuget BenchmarkDotNet
 nuget MathNet.Numerics.FSharp
 

src/GraphBLAS-sharp/Abstracts.fs

@@ -1,6 +1,9 @@
 namespace GraphBLAS.FSharp
 
+<<<<<<< HEAD
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
+=======
+>>>>>>> e5c9ed5c70dc7da1eda621582663215739e51536
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 
 [<AbstractClass>]
@@ -10,6 +13,7 @@ type Matrix<'a when 'a : struct and 'a : equality>(nrow: int, ncol: int) =
     default this.RowCount = nrow
     default this.ColumnCount = ncol
 
+<<<<<<< HEAD
     abstract Mask: Mask2D option
     abstract Complemented: Mask2D option
 
@@ -30,57 +34,109 @@ type Matrix<'a when 'a : struct and 'a : equality>(nrow: int, ncol: int) =
     abstract ReduceOut: Mask1D option -> Monoid<'a> -> Vector<'a>
     abstract Reduce: Monoid<'a> -> Scalar<'a>
     abstract T: Matrix<'a>
+=======
+    abstract Clear: unit -> OpenCLEvaluation<unit>
+    abstract Copy: unit -> OpenCLEvaluation<Matrix<'a>>
+    abstract Resize: int -> int -> OpenCLEvaluation<Matrix<'a>>
+    abstract GetNNZ: unit -> OpenCLEvaluation<int>
+    abstract GetTuples: unit -> OpenCLEvaluation<{| Rows: int[]; Columns: int[]; Values: 'a[] |}>
+    abstract GetMask: ?isComplemented: bool -> OpenCLEvaluation<Mask2D option>
+
+    abstract Extract: Mask2D option -> OpenCLEvaluation<Matrix<'a>>
+    abstract Extract: (Mask1D option * int) -> OpenCLEvaluation<Vector<'a>>
+    abstract Extract: (int * Mask1D option) -> OpenCLEvaluation<Vector<'a>>
+    abstract Extract: (int * int) -> OpenCLEvaluation<Scalar<'a>>
+    abstract Assign: Mask2D option * Matrix<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (Mask1D option * int) * Vector<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (int * Mask1D option) * Vector<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (int * int) * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: Mask2D option * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (Mask1D option * int) * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (int * Mask1D option) * Scalar<'a> -> OpenCLEvaluation<unit>
+
+    abstract Mxm: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<Matrix<'a>>
+    abstract Mxv: Vector<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract EWiseAdd: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<Matrix<'a>>
+    abstract EWiseMult: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<Matrix<'a>>
+    abstract Apply: Mask2D option -> UnaryOp<'a, 'b> -> OpenCLEvaluation<Matrix<'b>>
+    abstract Prune: Mask2D option -> UnaryOp<'a, bool> -> OpenCLEvaluation<Matrix<'a>>
+    abstract ReduceIn: Mask1D option -> Monoid<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract ReduceOut: Mask1D option -> Monoid<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract Reduce: Monoid<'a> -> OpenCLEvaluation<Scalar<'a>>
+    abstract Transpose: unit -> OpenCLEvaluation<Matrix<'a>>
+    abstract Kronecker: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<Matrix<'a>>
+>>>>>>> e5c9ed5c70dc7da1eda621582663215739e51536
 
     static member inline (+) (x: Matrix<'a>, y: Matrix<'a>) = x.EWiseAdd y
     static member inline (*) (x: Matrix<'a>, y: Matrix<'a>) = x.EWiseMult y
     static member inline (@.) (x: Matrix<'a>, y: Matrix<'a>) = x.Mxm y
     static member inline (@.) (x: Matrix<'a>, y: Vector<'a>) = x.Mxv y
 
-and [<AbstractClass>] Vector<'a when 'a : struct and 'a : equality>(length: int) =
-    abstract Length: int
-    default this.Length = length
 
-    abstract AsArray: 'a[]
-    abstract Clear: unit -> unit
+and [<AbstractClass>] Vector<'a when 'a : struct and 'a : equality>(size: int) =
+    abstract Size: int
+    default this.Size = size
 
-    abstract Mask: Mask1D option
-    abstract Complemented: Mask1D option
+    abstract Clear: unit -> OpenCLEvaluation<unit>
+    abstract Copy: unit -> OpenCLEvaluation<Vector<'a>>
+    abstract Resize: int -> OpenCLEvaluation<Vector<'a>>
+    abstract GetNNZ: unit -> OpenCLEvaluation<int>
+    abstract GetTuples: unit -> OpenCLEvaluation<{| Indices: int[]; Values: 'a[] |}>
+    abstract GetMask: ?isComplemented: bool -> OpenCLEvaluation<Mask1D option>
 
-    abstract Item: Mask1D option -> Vector<'a> with get, set
-    abstract Item: int -> Scalar<'a> with get, set
-    abstract Fill: Mask1D option -> Scalar<'a> with set
+    abstract Extract: Mask1D option -> OpenCLEvaluation<Vector<'a>>
+    abstract Extract: int -> OpenCLEvaluation<Scalar<'a>>
+    abstract Assign: Mask1D option * Vector<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: int * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: Mask1D option * Scalar<'a> -> OpenCLEvaluation<unit>
 
+<<<<<<< HEAD
     abstract Vxm: Matrix<'a> -> Mask1D option -> Semiring<'a> -> Vector<'a>
     abstract EWiseAdd: Vector<'a> -> Mask1D option -> Semiring<'a> -> Vector<'a>
     abstract EWiseMult: Vector<'a> -> Mask1D option -> Semiring<'a> -> Vector<'a>
     abstract Apply: Mask1D option -> UnaryOp<'a, 'b> -> Vector<'b>
     abstract Reduce: Monoid<'a> -> Scalar<'a>
+=======
+    abstract Vxm: Matrix<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract EWiseAdd: Vector<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract EWiseMult: Vector<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract Apply: Mask1D option -> UnaryOp<'a, 'b> -> OpenCLEvaluation<Vector<'b>>
+    abstract Prune: Mask1D option -> UnaryOp<'a, bool> -> OpenCLEvaluation<Vector<'a>>
+    abstract Reduce: Monoid<'a> -> OpenCLEvaluation<Scalar<'a>>
+>>>>>>> e5c9ed5c70dc7da1eda621582663215739e51536
 
     static member inline (+) (x: Vector<'a>, y: Vector<'a>) = x.EWiseAdd y
     static member inline (*) (x: Vector<'a>, y: Vector<'a>) = x.EWiseMult y
     static member inline (@.) (x: Vector<'a>, y: Matrix<'a>) = x.Vxm y
 
-and Mask1D(indices: int[], length: int, isComplemented: bool) =
+
+and Mask1D(indices: int[], size: int, isComplemented: bool) =
     member this.Indices = indices
-    member this.Length = length
+    member this.Size = size
     member this.IsComplemented = isComplemented
 
+<<<<<<< HEAD
     member this.Item
         with get (idx: int) : bool =
             this.Indices
             |> Array.contains idx
             |> (<>) this.IsComplemented
+=======
+>>>>>>> e5c9ed5c70dc7da1eda621582663215739e51536
 
-and Mask2D(indices: (int * int)[], rowCount: int, columnCount: int, isComplemented: bool) =
-    member this.Rows = indices |> Array.unzip |> fst
-    member this.Columns = indices |> Array.unzip |> snd
+and Mask2D(rowIndices: int[], columnIndices: int[], rowCount: int, columnCount: int, isComplemented: bool) =
+    member this.RowIndices = rowIndices
+    member this.ColumnIndices = columnIndices
     member this.RowCount = rowCount
     member this.ColumnCount = columnCount
     member this.IsComplemented = isComplemented
+<<<<<<< HEAD
 
     member this.Item
         with get (rowIdx: int, colIdx: int) : bool =
             (this.Rows, this.Columns)
             ||> Array.zip
             |> Array.contains (rowIdx, colIdx)
             |> (<>) this.IsComplemented
+=======
+>>>>>>> e5c9ed5c70dc7da1eda621582663215739e51536

src/GraphBLAS-sharp/Algorithms/BFS.fs

@@ -3,23 +3,27 @@ namespace GraphBLAS.FSharp.Algorithms
 open GraphBLAS.FSharp.Predefined
 open GraphBLAS.FSharp.Helpers
 open GraphBLAS.FSharp
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 
 [<AutoOpen>]
 module BFS =
-    let levelBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
+    let levelBFS (matrix: Matrix<bool>) (source: int) : OpenCLEvaluation<Vector<int>> =
         let vertexCount = matrix.RowCount
-        let levels = DenseVector(Array.zeroCreate vertexCount, IntegerMonoid.add)
-
-        let frontier = SparseVector(vertexCount, [source, true])
-
-        let mutable currentLevel = 1
-        while !> (frontier.Reduce BooleanMonoid.any) && currentLevel < vertexCount do
-            levels.Fill(frontier.Mask) <- Scalar currentLevel
-            frontier.Clear()
-            frontier.[levels.Complemented] <- (frontier @. matrix) levels.Complemented BooleanSemiring.anyAll
-            currentLevel <- currentLevel + 1
-
-        upcast levels
+        let levels = Vector.Dense(Array.zeroCreate vertexCount, IntegerMonoid.add)
+        let frontier = Vector.Sparse(vertexCount, [source, true])
+
+        opencl {
+            let mutable currentLevel = 1
+            while currentLevel < vertexCount do
+                let! frontierMask = frontier.GetMask()
+                do! levels.Assign(frontierMask, Scalar currentLevel)
+                let! levelsComplemented = levels.GetMask(isComplemented = true)
+                let! frontier = (frontier @. matrix) levelsComplemented BooleanSemiring.anyAll
+                currentLevel <- currentLevel + 1
+
+            return levels
+        }
 
     // let parentBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
     //     let vertexCount = matrix.RowCount

src/GraphBLAS-sharp/Algorithms/SSSP.fs

@@ -2,14 +2,19 @@ namespace GraphBLAS.FSharp.Algorithms
 
 open GraphBLAS.FSharp.Predefined
 open GraphBLAS.FSharp
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 
 [<AutoOpen>]
 module SSSP =
-    let SSSP (matrix: Matrix<float>) (source: int) : Vector<float> =
+    let SSSP (matrix: Matrix<float>) (source: int) : OpenCLEvaluation<Vector<float>> =
         let vertexCount = matrix.RowCount
-        let distance = SparseVector(vertexCount, [source, 0.])
+        let distance = Vector.Sparse(vertexCount, [source, 0.])
 
-        for _ in 1 .. vertexCount - 1 do
-            distance.[None] <- (distance @. matrix) None FloatSemiring.minAdd
+        opencl {
+            for _ in 1 .. vertexCount - 1 do
+                let! step = (distance @. matrix) None FloatSemiring.minAdd
+                do! distance.Assign(None, step)
 
-        upcast distance
+            return distance
+        }

src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs

@@ -2,13 +2,21 @@ namespace GraphBLAS.FSharp.Algorithms
 
 open GraphBLAS.FSharp.Predefined
 open GraphBLAS.FSharp
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 
 [<AutoOpen>]
 module TriangleCounting =
-    let sandiaTriangleCount (lowerTriangular: Matrix<bool>) =
+    // скорее всего, тут не скаляр возвращать нужно, а инт
+    let sandiaTriangleCount (lowerTriangular: Matrix<bool>) : OpenCLEvaluation<Scalar<int>> =
         let bool2int = function
             | true -> 1
             | false -> 0
-        let convertedMatrix = lowerTriangular.Apply None (UnaryOp <@ bool2int @>)
-        let result = (convertedMatrix @. convertedMatrix.T) lowerTriangular.Mask IntegerSemiring.addMult
-        result.Reduce IntegerMonoid.add
+
+        opencl {
+            let! convertedMatrix = lowerTriangular.Apply None (UnaryOp <@ bool2int @>)
+            let! convertedTransposed = convertedMatrix.Transpose()
+            let! lowerTriangularMask = lowerTriangular.GetMask()
+            let! result = (convertedMatrix @. convertedTransposed) lowerTriangularMask IntegerSemiring.addMult
+            return! result.Reduce IntegerMonoid.add
+        }