PageRank on ClMatrix and ClVector

Author: kirillgarbar

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

@@ -17,15 +17,16 @@ open GraphBLAS.FSharp.Objects
 type Benchmarks(
     buildFunToBenchmark,
     converter: string -> float32,
-    binaryConverter)
+    binaryConverter,
+    buildMatrix)
     =
 
     let mutable funToBenchmark = None
-    let mutable matrix = Unchecked.defaultof<ClMatrix.CSR<float32>>
-    let mutable matrixPrepared = Unchecked.defaultof<ClMatrix.CSR<float32>>
+    let mutable matrix = Unchecked.defaultof<ClMatrix<float32>>
+    let mutable matrixPrepared = Unchecked.defaultof<ClMatrix<float32>>
     let mutable matrixHost = Unchecked.defaultof<_>
 
-    member val Result = Unchecked.defaultof<ClArray<float32 option>> with get,set
+    member val Result = Unchecked.defaultof<ClVector<float32>> with get,set
 
     [<ParamsSource("AvailableContexts")>]
     member val OclContextInfo = Unchecked.defaultof<Utils.BenchmarkContext * int> with get, set
@@ -67,12 +68,12 @@ type Benchmarks(
         this.Result <- this.FunToBenchmark this.Processor matrixPrepared
 
     member this.ClearInputMatrix() =
-        (matrix :> IDeviceMemObject).Dispose this.Processor
+        matrix.Dispose this.Processor
 
     member this.ClearPreparedMatrix() =
-        (matrixPrepared :> IDeviceMemObject).Dispose this.Processor
+        matrixPrepared.Dispose this.Processor
 
-    member this.ClearResult() = this.Result.FreeAndWait this.Processor
+    member this.ClearResult() = this.Result.Dispose this.Processor
 
     member this.ReadMatrix() =
         let converter =
@@ -83,7 +84,7 @@ type Benchmarks(
         matrixHost <- this.InputMatrixReader.ReadMatrix converter
 
     member this.LoadMatrixToGPU() =
-        matrix <- matrixHost.ToCSR.ToDevice this.OclContext
+        matrix <- buildMatrix this.OclContext matrixHost
 
     member this.PrepareMatrix() =
         matrixPrepared <- Algorithms.PageRank.prepareMatrix this.OclContext this.WorkGroupSize this.Processor matrix
@@ -101,8 +102,8 @@ type PageRankWithoutTransferBenchmarkFloat32() =
     inherit Benchmarks(
         Algorithms.PageRank.run,
         float32,
-        (fun _ -> float32 <| Utils.nextInt (System.Random()))
-    )
+        (fun _ -> float32 <| Utils.nextInt (System.Random())),
+        (fun context matrix -> ClMatrix.CSR <| matrix.ToCSR.ToDevice context))
 
     static member InputMatrixProvider =
         Benchmarks.InputMatrixProviderBuilder "BFSBenchmarks.txt"

src/GraphBLAS-sharp.Backend/Algorithms/PageRank.fs

@@ -1,5 +1,6 @@
 namespace GraphBLAS.FSharp.Backend.Algorithms
 
+open GraphBLAS.FSharp
 open GraphBLAS.FSharp.Backend
 open Brahma.FSharp
 open GraphBLAS.FSharp.Objects
@@ -86,49 +87,52 @@ module internal PageRank =
         let copy =
             GraphBLAS.FSharp.ClArray.copy clContext workGroupSize
 
-        let transpose =
+        let transposeInPlace =
             Matrix.CSR.Matrix.transposeInPlace clContext workGroupSize
 
         let multiply = clContext.Compile multiply
 
-        fun (queue: MailboxProcessor<Msg>) (matrix: ClMatrix.CSR<float32>) ->
+        fun (queue: MailboxProcessor<Msg>) (matrix: ClMatrix<float32>) ->
+
+            match matrix with
+            | ClMatrix.CSR matrix ->
 
-            let outDegree = countOutDegree queue matrix
+                let outDegree = countOutDegree queue matrix
 
-            let resultValues =
-                clContext.CreateClArrayWithSpecificAllocationMode(DeviceOnly, matrix.Values.Length)
+                let resultValues =
+                    clContext.CreateClArrayWithSpecificAllocationMode(DeviceOnly, matrix.Values.Length)
 
-            let kernel = multiply.GetKernel()
+                let kernel = multiply.GetKernel()
 
-            let ndRange =
-                Range1D.CreateValid(matrix.RowCount * workGroupSize, workGroupSize)
+                let ndRange =
+                    Range1D.CreateValid(matrix.RowCount * workGroupSize, workGroupSize)
 
-            queue.Post(
-                Msg.MsgSetArguments
-                    (fun () ->
-                        kernel.KernelFunc
-                            ndRange
-                            matrix.RowCount
-                            matrix.RowPointers
-                            matrix.Values
-                            outDegree
-                            resultValues)
-            )
+                queue.Post(
+                    Msg.MsgSetArguments
+                        (fun () ->
+                            kernel.KernelFunc
+                                ndRange
+                                matrix.RowCount
+                                matrix.RowPointers
+                                matrix.Values
+                                outDegree
+                                resultValues)
+                )
 
-            queue.Post(Msg.CreateRunMsg<_, _> kernel)
+                queue.Post(Msg.CreateRunMsg<_, _> kernel)
 
-            outDegree.Free queue
+                outDegree.Free queue
 
-            let newMatrix =
-                { Context = clContext
-                  RowCount = matrix.RowCount
-                  ColumnCount = matrix.ColumnCount
-                  RowPointers = copy queue DeviceOnly matrix.RowPointers
-                  Columns = copy queue DeviceOnly matrix.Columns
-                  Values = resultValues }
+                let newMatrix =
+                    { Context = clContext
+                      RowCount = matrix.RowCount
+                      ColumnCount = matrix.ColumnCount
+                      RowPointers = copy queue DeviceOnly matrix.RowPointers
+                      Columns = copy queue DeviceOnly matrix.Columns
+                      Values = resultValues }
 
-            let transposed = transpose queue DeviceOnly newMatrix
-            transposed
+                transposeInPlace queue DeviceOnly newMatrix |> ClMatrix.CSR
+            | _ -> failwith "Not implemented"
 
     let run (clContext: ClContext) workGroupSize =
 
@@ -140,34 +144,34 @@ module internal PageRank =
         let mul = ArithmeticOperations.float32MulOption
 
         let spMVTo =
-            Operations.SpMV.runTo plus mul clContext workGroupSize
+            Operations.SpMVInPlace plus mul clContext workGroupSize
 
         let addToResult =
-            Vector.map2InPlace plus clContext workGroupSize
+            GraphBLAS.FSharp.Vector.map2InPlace plus clContext workGroupSize
 
         let subtractAndSquare =
-            Vector.map2InPlace minusAndSquare clContext workGroupSize
+            GraphBLAS.FSharp.Vector.map2To minusAndSquare clContext workGroupSize
 
         let reduce =
-            Vector.reduce <@ (+) @> clContext workGroupSize
+            GraphBLAS.FSharp.Vector.reduce <@ (+) @> clContext workGroupSize
 
         let create =
-            GraphBLAS.FSharp.ClArray.create clContext workGroupSize
+            GraphBLAS.FSharp.Vector.create clContext workGroupSize
 
-        fun (queue: MailboxProcessor<Msg>) (matrix: ClMatrix.CSR<float32>) ->
+        fun (queue: MailboxProcessor<Msg>) (matrix: ClMatrix<float32>) ->
 
             let vertexCount = matrix.RowCount
 
             //None is 0
-            let mutable rank = create queue DeviceOnly vertexCount None
+            let mutable rank = create queue DeviceOnly vertexCount Dense None
 
             let mutable prevRank =
-                create queue DeviceOnly vertexCount (Some(1.0f / (float32 vertexCount)))
+                create queue DeviceOnly vertexCount Dense (Some(1.0f / (float32 vertexCount)))
 
-            let mutable errors = create queue DeviceOnly vertexCount None
+            let mutable errors = create queue DeviceOnly vertexCount Dense None
 
             let addition =
-                create queue DeviceOnly vertexCount (Some((1.0f - alpha) / (float32 vertexCount)))
+                create queue DeviceOnly vertexCount Dense (Some((1.0f - alpha) / (float32 vertexCount)))
 
             let mutable error = accuracy + 0.1f
 
@@ -178,7 +182,7 @@ module internal PageRank =
 
                 // rank = matrix*rank + (1 - alpha)/N
                 spMVTo queue matrix prevRank rank
-                addToResult queue rank addition rank
+                addToResult queue rank addition
 
                 // error
                 subtractAndSquare queue rank prevRank errors
@@ -189,8 +193,8 @@ module internal PageRank =
                 rank <- prevRank
                 prevRank <- temp
 
-            prevRank.Free queue
-            errors.Free queue
-            addition.Free queue
+            prevRank.Dispose queue
+            errors.Dispose queue
+            addition.Dispose queue
 
             rank