Add sync functions for tuples

Author: dpanfilyonok

src/GraphBLAS-sharp/Algorithms/BFS.fs

@@ -10,8 +10,8 @@ open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 module BFS =
     let levelBFS (matrix: Matrix<bool>) (source: int) : GraphblasEvaluation<Vector<int>> =
         let vertexCount = Matrix.rowCount matrix
-        let levels = Vector.ofArray <| Array.zeroCreate vertexCount <| (=) 0
-        let frontier = Vector.ofTuples vertexCount [source, true]
+        let levels = Vector.ofArray <| (=) 0 <| Array.zeroCreate vertexCount
+        let frontier = Vector.ofList vertexCount [source, true]
 
         graphblas {
             let mutable currentLevel = 1

src/GraphBLAS-sharp/Algorithms/SSSP.fs

@@ -9,7 +9,7 @@ open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 module SSSP =
     let SSSP (matrix: Matrix<float>) (source: int) : GraphblasEvaluation<Vector<float>> =
         let vertexCount = Matrix.rowCount matrix
-        let distance = Vector.ofTuples vertexCount [source, 0.]
+        let distance = Vector.ofList vertexCount [source, 0.]
 
         graphblas {
             for _ in 1 .. vertexCount - 1 do

src/GraphBLAS-sharp/GraphblasEvaluation.fs

@@ -24,11 +24,10 @@ module EvalGB =
             let x = run env reader
             run env (f x)
 
-    let ret x =
+    let return' x =
         EvalGB <| fun _ -> x
 
-    // EvalGB.liftCl x === liftM EvalGB x
-    let liftCl clEvaluation =
+    let fromCl clEvaluation =
         EvalGB <| fun env ->
             runCl env.ClContext clEvaluation
 
@@ -37,11 +36,11 @@ module EvalGB =
 
 type GraphblasBuilder() =
     member this.Bind(x, f) = EvalGB.bind f x
-    member this.Return x = EvalGB.ret x
+    member this.Return x = EvalGB.return' x
     member this.ReturnFrom x = x
 
     member this.Zero() =
-        EvalGB.ret ()
+        EvalGB.return' ()
 
     member this.Combine(m1, m2) =
         EvalGB <| fun env ->

src/GraphBLAS-sharp/Methods/Matrix.fs

@@ -11,14 +11,17 @@ type MatrixTuples<'a> =
         Values: 'a[]
     }
 
-    member this.ToHost() =
+// ждём тайпклассов чтобы можно было вызывать synchronize для всех объектов,
+// для которых он реализован, не привязывая реализацию к классу (как стратегия)
+module MatrixTuples =
+    let synchronize (matrixTuples: MatrixTuples<'a>) =
         opencl {
-            let! _ = ToHost this.RowIndices
-            let! _ = ToHost this.ColumnIndices
-            let! _ = ToHost this.Values
-
-            return this
+            let! _ = ToHost matrixTuples.RowIndices
+            let! _ = ToHost matrixTuples.ColumnIndices
+            let! _ = ToHost matrixTuples.Values
+            return ()
         }
+        |> EvalGB.fromCl
 
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module Matrix =
@@ -30,7 +33,7 @@ module Matrix =
     let build (rowCount: int) (columnCount: int) (rows: int[]) (columns: int[]) (values: 'a[]) : Matrix<'a> =
         failwith "Not Implemented yet"
 
-    let ofArray2D (array: 'a[,]) (isZero: 'a -> bool) : Matrix<'a> =
+    let ofArray2D (isZero: 'a -> bool) (array: 'a[,]) : Matrix<'a> =
         failwith "Not Implemented yet"
 
     let fromFile (pathToMatrix: string) : Matrix<'a> =
@@ -55,7 +58,7 @@ module Matrix =
     let tuples (matrix: Matrix<'a>) : GraphblasEvaluation<MatrixTuples<'a>> = failwith "Not Implemented yet"
     let mask (matrix: Matrix<'a>) : GraphblasEvaluation<Mask2D option> = failwith "Not Implemented yet"
     let complemented (matrix: Matrix<'a>) : GraphblasEvaluation<Mask2D option> = failwith "Not Implemented yet"
-    // let finish \ eval \ toHost
+    let synchronize (matrix: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
 
     (*
         assignment, extraction and filling
@@ -90,7 +93,7 @@ module Matrix =
                 }
             | _ -> failwith "Not Implemented"
 
-        graphblas { return! EvalGB.liftCl operationResult }
+        graphblas { return! EvalGB.fromCl operationResult }
 
     let eWiseMult (semiring: ISemiring<'a>) (mask: Mask2D option) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
     let apply (mapper: UnaryOp<'a, 'b>) (mask: Mask2D option) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'b>> = failwith "Not Implemented yet"

src/GraphBLAS-sharp/Methods/Vector.fs

@@ -10,13 +10,14 @@ type VectorTuples<'a> =
         Values: 'a[]
     }
 
-    member this.ToHost() =
+module VectorTuples =
+    let synchronize (vectorTuples: VectorTuples<'a>) =
         opencl {
-            let! _ = ToHost this.Indices
-            let! _ = ToHost this.Values
-
-            return this
+            let! _ = ToHost vectorTuples.Indices
+            let! _ = ToHost vectorTuples.Values
+            return ()
         }
+        |> EvalGB.fromCl
 
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module Vector =
@@ -28,20 +29,19 @@ module Vector =
     let build (size: int) (indices: int[]) (values: int[]) : Vector<'a> =
         failwith "Not Implemented yet"
 
-    // ambiguous name (tuples = коллекция троек или 3 коллекции)
-    let ofTuples (size: int) (elements: (int * 'a) list) : Vector<'a> =
+    let ofList (size: int) (elements: (int * 'a) list) : Vector<'a> =
         failwith "Not Implemented yet"
 
-    let ofArray (array: 'a[]) (isZero: 'a -> bool) : Vector<'a> =
+    let ofArray (isZero: 'a -> bool) (array: 'a[]) : Vector<'a> =
         failwith "Not Implemented yet"
 
     let init (size: int) (initializer: int -> 'a) : Vector<'a> =
         failwith "Not Implemented yet"
 
+    // обоснован ли этот метод или можно просто create x использовать
     let zeroCreate (size: int) : Vector<'a> =
         failwith "Not Implemented yet"
 
-
     (*
         methods
     *)
@@ -52,9 +52,10 @@ module Vector =
     let resize (size: int) (vector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
     let nnz (vector: Vector<'a>) : GraphblasEvaluation<int> = failwith "Not Implemented yet"
     let tuples (vector: Vector<'a>) : GraphblasEvaluation<VectorTuples<'a>> = failwith "Not Implemented yet"
+    // возвращается option, чтобы потом можно было бы сразу передавать её в методы (тк они option принимают)
     let mask (vector: Vector<'a>) : GraphblasEvaluation<Mask1D option> = failwith "Not Implemented yet"
     let complemented (vector: Vector<'a>) : GraphblasEvaluation<Mask1D option> = failwith "Not Implemented yet"
-    // let finish \ eval \ toHost
+    let synchronize (vector: Vector<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
 
     (*
         assignment, extraction and filling

src/GraphBLAS-sharp/Predefined/Monoids/Add.fs

@@ -17,7 +17,7 @@ module Add =
 
     let float32 =
         { new IMonoid<float32> with
-            member this.Zero = 0f
+            member this.Zero = 0.f
             member this.Plus = ClosedBinaryOp <@ (+) @>
         }
 

tests/GraphBLAS-sharp.Tests/OperationsTests/EWiseAddTests.fs

@@ -147,7 +147,8 @@ let checkCorrectnessGeneric<'a when 'a : struct and 'a : equality>
             graphblas {
                 let! result = Matrix.eWiseAdd semiring None left right
                 let! tuples = Matrix.tuples result
-                return! EvalGB.liftCl <| tuples.ToHost()
+                do! MatrixTuples.synchronize tuples
+                return tuples
             }
             |> EvalGB.runWithClContext oclContext
 

tests/GraphBLAS-sharp.Tests/Program.fs

@@ -6,10 +6,9 @@ let allTests =
     testList "All tests" [
         EWiseAdd.tests
     ]
+    |> testSequenced
 
-// sequenced test?
 [<EntryPoint>]
 let main argv =
     allTests
-    |> testSequenced
     |> runTestsWithCLIArgs [] argv