Split

.github/workflows/build-and-benchmark.yml

@@ -36,7 +36,7 @@ jobs:
         with:
           name: BFS
           tool: 'benchmarkdotnet'
-          output-file-path: BenchmarkDotNet.Artifacts/results/GraphBLAS.FSharp.Benchmarks.BFSBenchmarksWithoutDataTransfer-report-brief.json
+          output-file-path: BenchmarkDotNet.Artifacts/results/GraphBLAS.FSharp.Benchmarks.BFSWithoutTransferBenchmarkInt32-report-brief.json
           # Access token to deploy GitHub Pages branch
           github-token: ${{ secrets._GITHUB_TOKEN }}
           # Push and deploy GitHub pages branch automatically

README.md

@@ -19,32 +19,38 @@ GraphBLAS# is a GPGPU-based [GraphBLAS](https://graphblas.org/)-like API impleme
      | Left of 't1
      | Right of 't2
   ```
-  So, type of matrix-matrix elementwise oertion is ```Matrix<Option<'t1>> -> Matrix<Option<'t2>> -> (AtLeastOne<'t1,'t2> -> Option<'t3>) -> Matrix<Option<'t3>>```. 
-- No semirings. Just functions. Ofcourse one can implement semirings on the top of provided API.
+  So, type of matrix-matrix elementwise operation is ```Matrix<Option<'t1>> -> Matrix<Option<'t2>> -> (AtLeastOne<'t1,'t2> -> Option<'t3>) -> Matrix<Option<'t3>>```. 
+- No semirings. Just functions. Of course one can implement semirings on the top of provided API.
 - Minimal core: high-order functions allows us to minimaze core by functions unification. For example, such functions as matrix-matrix addition, matrix-matrix element-wise multiplication, masking all are partial case of `map2` function.
 
 ### Operations
 - **Matrix-Matrix**
-  - [x] COO-COO element-wize
-  - [x] CSR-CSR element-wize
-  - [ ] CSR-CSR multiplication
-  - [ ] COO transpose
-  - [ ] CSR transpose 
+  - [x] CSR-CSR `map2`
+  - [x] CSR-CSR `map2AtLeastOne`
+  - [x] COO-COO `map2`
+  - [x] COO-COO `map2AtLeastOne`
+  - [x] CSR-CSR multiplication
 - **Vector-Matrix**
   - [x] Dense-CSR multiplication
-  - [ ] COO-CSR multiplication
+  - [ ] Sparse-CSR multiplication
 - **Vector-Vector**
-  - [x] Dense-Dense element-wise
+  - [x] Dense-Dense `map2`
+  - [x] Dense-Dense `map2AtLeastOne`
+  - [x] Sparse-Sparse `map2`
+  - [x] Sparse-Sparse `map2AtLeastOne`
   - [ ] ...
 - **Matrix**
-  - [ ] `map`
-  - [ ] `iter`
+  - [x] `copy` 
+  - [x] `map`
+  - [x] COO transpose
+  - [x] CSR transpose
+  - [x] CSC transpose
   - [ ] ...
 - **Vector**
-  - [ ] `map`
-  - [ ] `iter`
-  - [ ] `filter`
-  - [ ] `contains`
+  - [x] `zeroCreate` 
+  - [x] `ofList`
+  - [x] `copy`
+  - [x] `reduce`
   - [ ] ...  
 
 ### Graph Analysis Algorithms

benchmarks/GraphBLAS-sharp.Benchmarks/Algorithms/BFS.fs

@@ -0,0 +1,178 @@
+namespace GraphBLAS.FSharp.Benchmarks.Algorithms.BFS
+
+open System.IO
+open BenchmarkDotNet.Attributes
+open GraphBLAS.FSharp
+open GraphBLAS.FSharp.Backend.Quotes
+open GraphBLAS.FSharp.IO
+open Brahma.FSharp
+open Backend.Algorithms.BFS
+open Microsoft.FSharp.Core
+open GraphBLAS.FSharp.Backend.Objects.ArraysExtensions
+open GraphBLAS.FSharp.Benchmarks
+open GraphBLAS.FSharp.Backend.Objects
+
+[<AbstractClass>]
+[<IterationCount(100)>]
+[<WarmupCount(10)>]
+[<Config(typeof<Configs.Matrix>)>]
+type Benchmarks<'elem when 'elem : struct>(
+    buildFunToBenchmark,
+    converter: string -> 'elem,
+    binaryConverter,
+    vertex: int)
+    =
+
+    let mutable funToBenchmark = None
+    let mutable matrix = Unchecked.defaultof<ClMatrix.CSR<'elem>>
+    let mutable matrixHost = Unchecked.defaultof<_>
+
+    member val ResultLevels = Unchecked.defaultof<ClArray<'elem option>> with get,set
+
+    [<ParamsSource("AvailableContexts")>]
+    member val OclContextInfo = Unchecked.defaultof<Utils.BenchmarkContext * int> with get, set
+
+    [<ParamsSource("InputMatrixProvider")>]
+    member val InputMatrixReader = Unchecked.defaultof<MtxReader> with get, set
+
+    member this.OclContext = (fst this.OclContextInfo).ClContext
+    member this.WorkGroupSize = snd this.OclContextInfo
+
+    member this.Processor =
+        let p = (fst this.OclContextInfo).Queue
+        p.Error.Add(fun e -> failwithf "%A" e)
+        p
+
+    static member AvailableContexts = Utils.availableContexts
+
+    static member InputMatrixProviderBuilder pathToConfig =
+        let datasetFolder = "BFS"
+        pathToConfig
+        |> Utils.getMatricesFilenames
+        |> Seq.map
+            (fun matrixFilename ->
+                printfn "%A" matrixFilename
+
+                match Path.GetExtension matrixFilename with
+                | ".mtx" -> MtxReader(Utils.getFullPathToMatrix datasetFolder matrixFilename)
+                | _ -> failwith "Unsupported matrix format")
+
+    member this.FunToBenchmark =
+        match funToBenchmark with
+        | None ->
+            let x = buildFunToBenchmark this.OclContext this.WorkGroupSize
+            funToBenchmark <- Some x
+            x
+        | Some x -> x
+
+    member this.BFS() =
+        this.ResultLevels <- this.FunToBenchmark this.Processor matrix vertex
+
+    member this.ClearInputMatrix() =
+        (matrix :> IDeviceMemObject).Dispose this.Processor
+
+    member this.ClearResult() = this.ResultLevels.FreeAndWait this.Processor
+
+    member this.ReadMatrix() =
+        let converter =
+            match this.InputMatrixReader.Field with
+            | Pattern -> binaryConverter
+            | _ -> converter
+
+        matrixHost <- this.InputMatrixReader.ReadMatrix converter
+
+    member this.LoadMatrixToGPU() =
+        matrix <- matrixHost.ToCSR.ToDevice this.OclContext
+
+    abstract member GlobalSetup : unit -> unit
+
+    abstract member IterationCleanup : unit -> unit
+
+    abstract member GlobalCleanup : unit -> unit
+
+    abstract member Benchmark : unit -> unit
+
+type WithoutTransferBenchmark<'elem when 'elem : struct>(
+    buildFunToBenchmark,
+    converter: string -> 'elem,
+    boolConverter,
+    vertex) =
+
+    inherit Benchmarks<'elem>(
+        buildFunToBenchmark,
+        converter,
+        boolConverter,
+        vertex)
+
+    [<GlobalSetup>]
+    override this.GlobalSetup() =
+        this.ReadMatrix()
+        this.LoadMatrixToGPU()
+
+    [<IterationCleanup>]
+    override this.IterationCleanup() =
+        this.ClearResult()
+
+    [<GlobalCleanup>]
+    override this.GlobalCleanup() =
+        this.ClearInputMatrix()
+
+    [<Benchmark>]
+    override this.Benchmark() =
+        this.BFS()
+        this.Processor.PostAndReply Msg.MsgNotifyMe
+
+type BFSWithoutTransferBenchmarkInt32() =
+
+    inherit WithoutTransferBenchmark<int>(
+        (singleSource ArithmeticOperations.intSumOption ArithmeticOperations.intMulOption),
+        int32,
+        (fun _ -> Utils.nextInt (System.Random())),
+        0)
+
+    static member InputMatrixProvider =
+        Benchmarks<_>.InputMatrixProviderBuilder "BFSBenchmarks.txt"
+
+type WithTransferBenchmark<'elem when 'elem : struct>(
+    buildFunToBenchmark,
+    converter: string -> 'elem,
+    boolConverter,
+    vertex) =
+
+    inherit Benchmarks<'elem>(
+        buildFunToBenchmark,
+        converter,
+        boolConverter,
+        vertex)
+
+    [<GlobalSetup>]
+    override this.GlobalSetup() =
+        this.ReadMatrix()
+
+    [<GlobalCleanup>]
+    override this.GlobalCleanup() =
+        this.ClearResult()
+
+    [<IterationCleanup>]
+    override this.IterationCleanup() =
+        this.ClearInputMatrix()
+        this.ClearResult()
+
+    [<Benchmark>]
+    override this.Benchmark() =
+        this.LoadMatrixToGPU()
+        this.BFS()
+        this.ResultLevels.ToHost this.Processor |> ignore
+        this.Processor.PostAndReply Msg.MsgNotifyMe
+
+type BFSWithTransferBenchmarkInt32() =
+
+    inherit WithTransferBenchmark<int>(
+        (singleSource ArithmeticOperations.intSumOption ArithmeticOperations.intMulOption),
+        int32,
+        (fun _ -> Utils.nextInt (System.Random())),
+        0)
+
+    static member InputMatrixProvider =
+        Benchmarks<_>.InputMatrixProviderBuilder "BFSBenchmarks.txt"
+