Implement some vector constructors; add mask complementation

Author: dpanfilyonok

benchmarks/GraphBLAS-sharp.Benchmarks/Program.fs

@@ -6,8 +6,8 @@ let main argv =
     let benchmarks = BenchmarkSwitcher [|
         // typeof<EWiseAddBenchmarks4Float32>
         // typeof<EWiseAddBenchmarks4Bool>
-        // typeof<BFSBenchmarks>
-        typeof<QGBenchmarks>
+        typeof<BFSBenchmarks>
+        // typeof<QGBenchmarks>
     |]
 
     benchmarks.Run argv |> ignore

src/GraphBLAS-sharp/Backend/CSRMatrix/SpMSpV.fs

@@ -177,7 +177,7 @@ module internal rec SpMSpV =
             }
 
         elif mask.Indices.Length = 0 && not mask.IsComplemented ||
-            mask.Indices.Length = mask.Size && mask.IsComplemented then
+             mask.Indices.Length = mask.Size && mask.IsComplemented then
             return {
                 Size = matrix.RowCount
                 Indices = [||]

src/GraphBLAS-sharp/Backend/Mask/GetComplemented.fs

@@ -0,0 +1,58 @@
+namespace GraphBLAS.FSharp.Backend.Mask
+
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
+open GraphBLAS.FSharp
+open GraphBLAS.FSharp.Backend.Common
+open Brahma.OpenCL
+
+module internal GetComplemented =
+    let mask1D (mask: Mask1D) = opencl {
+        let size = mask.Size
+        let nnz = mask.Indices.Length
+
+        let bitmap = Array.create size 1
+        let getComplementedBitmap =
+            <@
+                fun (range: _1D)
+                    (maskIndices: int[])
+                    (bitmap: int[]) ->
+
+                    let gid = range.GlobalID0
+
+                    if gid < nnz then
+                        let maskIdx = maskIndices.[gid]
+                        bitmap.[maskIdx] <- 0
+            @>
+
+        do! RunCommand getComplementedBitmap <| fun kernelPrepare ->
+            kernelPrepare
+            <| _1D(Utils.getDefaultGlobalSize nnz, Utils.defaultWorkGroupSize)
+            <| mask.Indices
+            <| bitmap
+
+        let! (positions, _) = PrefixSum.runExclude bitmap
+
+        let complementedIndices = Array.zeroCreate<int> (size - nnz)
+        let setPosotions =
+            <@
+                fun (range: _1D)
+                    (positions: int[])
+                    (bitmap: int[])
+                    (complementedIndices: int[]) ->
+
+                    let gid = range.GlobalID0
+
+                    if gid < size && bitmap.[gid] = 1 then
+                        complementedIndices.[positions.[gid]] <- gid
+            @>
+
+        do! RunCommand setPosotions <| fun kernelPrepare ->
+            kernelPrepare
+            <| _1D(Utils.getDefaultGlobalSize size, Utils.defaultWorkGroupSize)
+            <| positions
+            <| bitmap
+            <| complementedIndices
+
+        return Mask1D(complementedIndices, size, not mask.IsComplemented)
+    }

src/GraphBLAS-sharp/GraphBLAS-sharp.fsproj

@@ -44,6 +44,7 @@
     <Compile Include="Backend/COOVector/EWiseAdd.fs" />
     <Compile Include="Backend/COOVector/FillSubVector.fs" />
     <Compile Include="Backend/COOVector/AssignSubVector.fs" />
+    <Compile Include="Backend/Mask/GetComplemented.fs" />
     <Compile Include="Operations/Matrix.fs" />
     <Compile Include="Operations/Vector.fs" />
     <Compile Include="Operations/Scalar.fs" />
@@ -63,4 +64,4 @@
     </Content>
   </ItemGroup>
   <Import Project="..\..\.paket\Paket.Restore.targets" />
-</Project>
+</Project>

src/GraphBLAS-sharp/Operations/Scalar.fs

@@ -9,7 +9,8 @@ module Scalar =
         constructors
     *)
 
-    let create (value: 'a) : GraphblasEvaluation<Scalar<'a>> = graphblas { return ScalarWrapped { Value = [| value |] } }
+    let create (value: 'a) : GraphblasEvaluation<Scalar<'a>> =
+        graphblas { return ScalarWrapped { Value = [| value |] } }
 
     (*
         methods

src/GraphBLAS-sharp/Operations/Vector.fs

@@ -18,7 +18,13 @@ module Vector =
         failwith "Not Implemented yet"
 
     let ofList (size: int) (elements: (int * 'a) list) : GraphblasEvaluation<Vector<'a>> =
-        failwith "Not Implemented yet"
+        let (indices, values) =
+            elements
+            |> Array.ofList
+            |> Array.sortBy fst
+            |> Array.unzip
+
+        graphblas { return VectorCOO <| COOVector.FromTuples(size, indices, values) }
 
     // можно оставить, но с условием, что будет создаваться full vector
     // let ofArray (array: 'a[]) : GraphblasEvaluation<Vector<'a>> =
@@ -31,7 +37,7 @@ module Vector =
         failwith "Not Implemented yet"
 
     let zeroCreate<'a when 'a : struct> (size: int) : GraphblasEvaluation<Vector<'a>> =
-        failwith "Not Implemented yet"
+        graphblas { return VectorCOO <| COOVector.FromTuples(size, [||], [||]) }
 
     (*
         methods
@@ -77,8 +83,9 @@ module Vector =
         match vector with
         | VectorCOO vector ->
             opencl {
-                let! resultIndices = Copy.copyArray vector.Indices
-                return Mask1D(resultIndices, vector.Size, true)
+                let! indices = Copy.copyArray vector.Indices
+                let! complementedMask = Mask.GetComplemented.mask1D <| Mask1D(indices, vector.Size, true)
+                return complementedMask
             }
         |> EvalGB.fromCl
 
@@ -106,9 +113,19 @@ module Vector =
     let extractValue (vector: Vector<'a>) (idx: int) : GraphblasEvaluation<Scalar<'a>> =
         failwith "Not Implemented yet"
 
+    // assignToVector
     /// t <- vec
     let assignVector (target: Vector<'a>) (source: Vector<'a>) : GraphblasEvaluation<unit> =
-        failwith "Not Implemented yet"
+        if target.Size <> source.Size then
+            invalidArg "source" <| sprintf "The size of source vector must be %A. Received: %A" target.Size source.Size
+
+        match source, target with
+        | VectorCOO source, VectorCOO target ->
+            opencl {
+                target.Indices <- source.Indices
+                target.Values <- source.Values
+            }
+        |> EvalGB.fromCl
 
     /// t.[mask] <- vec
     let assignSubVector (target: Vector<'a>) (mask: Mask1D) (source: Vector<'a>) : GraphblasEvaluation<unit> =

tests/GraphBLAS-sharp.Tests/MatrixOperationsTests/MxvTests.fs

@@ -228,8 +228,7 @@ let tests =
 
             deviceType = DeviceType.Cpu &&
             case.MatrixCase = CSR &&
-            case.VectorCase = VectorFormat.COO &&
-            case.MaskCase <> Complemented
+            case.VectorCase = VectorFormat.COO
         )
     |> List.collect testFixtures
     |> testList "Matrix.mxv tests"