add: spgemm coo->csr->coo

Author: artemiipatov

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

@@ -45,7 +45,7 @@ module internal MSBFS =
 
             let findIntersection = Intersect.findKeysIntersection clContext workGroupSize
 
-            fun (queue: MailboxProcessor<_>) allocationMode (levels: ClMatrix.COO<_>) (front: ClMatrix.COO<_>) ->
+            fun (queue: MailboxProcessor<_>) allocationMode (front: ClMatrix.COO<_>) (levels: ClMatrix.COO<_>) ->
 
                 // Find intersection of levels and front indices.
                 let intersection = findIntersection queue DeviceOnly front levels
@@ -64,15 +64,15 @@ module internal MSBFS =
 
         let run<'a when 'a: struct>
             (add: Expr<int -> int -> int option>)
-            (mul: Expr<'a -> int -> int option>)
+            (mul: Expr<int -> 'a -> int option>)
             (clContext: ClContext)
             workGroupSize
             =
 
             let spGeMM =
-                Operations.SpGeMM.expand add mul clContext workGroupSize
+                Operations.SpGeMM.COO.expand add mul clContext workGroupSize
 
-            let toCSRInPlace = Matrix.toCSRInPlace clContext workGroupSize
+            let copy = Matrix.copy clContext workGroupSize
 
             let updateFrontAndLevels = updateFrontAndLevels clContext workGroupSize
 
@@ -88,10 +88,7 @@ module internal MSBFS =
                     startMatrix
                     |> Matrix.ofList clContext DeviceOnly sourceVertexCount vertexCount
 
-                let mutable front =
-                    startMatrix
-                    |> Matrix.ofList clContext DeviceOnly sourceVertexCount vertexCount
-                    |> toCSRInPlace queue DeviceOnly
+                let mutable front = copy queue DeviceOnly levels
 
                 let mutable level = 0
                 let mutable stop = false
@@ -100,16 +97,16 @@ module internal MSBFS =
                     level <- level + 1
 
                     //Getting new frontier
-                    match spGeMM queue DeviceOnly matrix (ClMatrix.CSR front) with
+                    match spGeMM queue DeviceOnly (ClMatrix.COO front) matrix with
                     | None ->
                         front.Dispose queue
                         stop <- true
                     | Some newFrontier ->
                         front.Dispose queue
                         //Filtering visited vertices
-                        match updateFrontAndLevels queue DeviceOnly levels newFrontier with
+                        match updateFrontAndLevels queue DeviceOnly newFrontier levels with
                         | l, Some f ->
-                            front <- toCSRInPlace queue DeviceOnly f
+                            front <- f
                             levels.Dispose queue
                             levels <- l
                             newFrontier.Dispose queue

src/GraphBLAS-sharp.Backend/Matrix/COO/Matrix.fs

@@ -11,6 +11,25 @@ open GraphBLAS.FSharp.Objects.ArraysExtensions
 open GraphBLAS.FSharp.Objects.ClContextExtensions
 
 module Matrix =
+    /// <summary>
+    /// Creates new COO matrix with the values from the given one.
+    /// </summary>
+    /// <param name="clContext">OpenCL context.</param>
+    /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+    let copy (clContext: ClContext) workGroupSize =
+
+        let copy = ClArray.copy clContext workGroupSize
+
+        let copyData = ClArray.copy clContext workGroupSize
+
+        fun (processor: MailboxProcessor<_>) allocationMode (matrix: COO<'a>) ->
+            { Context = clContext
+              RowCount = matrix.RowCount
+              ColumnCount = matrix.ColumnCount
+              Rows = copy processor allocationMode matrix.Rows
+              Columns = copy processor allocationMode matrix.Columns
+              Values = copyData processor allocationMode matrix.Values }
+
     /// <summary>
     /// Builds a new COO matrix whose elements are the results of applying the given function
     /// to each of the elements of the matrix.
@@ -85,7 +104,7 @@ module Matrix =
     /// </summary>
     /// <param name="clContext">OpenCL context.</param>
     /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
-    let private compressRows (clContext: ClContext) workGroupSize =
+    let compressRows (clContext: ClContext) workGroupSize =
 
         let compressRows =
             <@ fun (ndRange: Range1D) (rows: ClArray<int>) (nnz: int) (rowPointers: ClArray<int>) ->
@@ -251,3 +270,62 @@ module Matrix =
           Values = clContext.CreateClArrayWithSpecificAllocationMode(allocationMode, values)
           RowCount = rowCount
           ColumnCount = columnCount }
+
+    /// <summary>
+    /// Returns matrix composed of all elements from the given row range of the input matrix.
+    /// </summary>
+    /// <param name="clContext">OpenCL context.</param>
+    /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+    let subRows (clContext: ClContext) workGroupSize =
+
+        let upperBound = ClArray.upperBound clContext workGroupSize
+
+        let blit = ClArray.blit clContext workGroupSize
+
+        let blitData = ClArray.blit clContext workGroupSize
+
+        fun (processor: MailboxProcessor<_>) allocationMode startRow count (matrix: ClMatrix.COO<'a>) ->
+            if count <= 0 then
+                failwith "Count must be greater than zero"
+
+            if startRow < 0 then
+                failwith "startIndex must be greater then zero"
+
+            if startRow + count > matrix.RowCount then
+                failwith "startIndex and count sum is larger than the matrix row count"
+
+            let firstRowClCell = clContext.CreateClCell(startRow - 1)
+            let lastRowClCell = clContext.CreateClCell(startRow + count)
+
+            // extract rows
+            let firstIndex = (upperBound processor matrix.Rows firstRowClCell).ToHostAndFree processor
+            let lastIndex = (upperBound processor matrix.Rows lastRowClCell).ToHostAndFree processor - 1
+
+            firstRowClCell.Free processor
+            lastRowClCell.Free processor
+
+            let resultLength = lastIndex - firstIndex + 1
+
+            let rows =
+                clContext.CreateClArrayWithSpecificAllocationMode(allocationMode, resultLength)
+
+            blit processor matrix.Columns firstIndex rows 0 resultLength
+
+            // extract values
+            let values =
+                clContext.CreateClArrayWithSpecificAllocationMode(allocationMode, resultLength)
+
+            blitData processor matrix.Values firstIndex values 0 resultLength
+
+            // extract indices
+            let columns =
+                clContext.CreateClArrayWithSpecificAllocationMode(allocationMode, resultLength)
+
+            blit processor matrix.Columns firstIndex columns 0 resultLength
+
+            { Context = clContext
+              RowCount = matrix.RowCount
+              ColumnCount = matrix.ColumnCount
+              Rows = rows
+              Columns = columns
+              Values = values }

src/GraphBLAS-sharp.Backend/Operations/Operations.fs

@@ -98,6 +98,88 @@ module Operations =
                     |> Some
                 | _ -> failwith "Vector formats are not matching."
 
+        /// <summary>
+        /// Applying the given function to the corresponding elements of the two given arrays pairwise.
+        /// Stores the result in the left vector.
+        /// </summary>
+        /// <remarks>
+        /// The two input arrays must have the same lengths.
+        /// </remarks>
+        /// <param name="map">The function to transform the pairs of the input elements.</param>
+        /// <param name="clContext">OpenCL context.</param>
+        /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+        let map2InPlace (map: Expr<'a option -> 'b option -> 'a option>) (clContext: ClContext) workGroupSize =
+            let map2Dense =
+                Dense.Vector.map2InPlace map clContext workGroupSize
+
+            fun (processor: MailboxProcessor<_>) (leftVector: ClVector<'a>) (rightVector: ClVector<'b>) ->
+                match leftVector, rightVector with
+                | ClVector.Dense left, ClVector.Dense right -> map2Dense processor left right left
+                | _ -> failwith "Unsupported vector format"
+
+        /// <summary>
+        /// Applying the given function to the corresponding elements of the two given arrays pairwise.
+        /// Stores the result in the given vector.
+        /// </summary>
+        /// <remarks>
+        /// The two input arrays must have the same lengths.
+        /// </remarks>
+        /// <param name="map">The function to transform the pairs of the input elements.</param>
+        /// <param name="clContext">OpenCL context.</param>
+        /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+        let map2To (map: Expr<'a option -> 'b option -> 'c option>) (clContext: ClContext) workGroupSize =
+            let map2Dense =
+                Dense.Vector.map2InPlace map clContext workGroupSize
+
+            fun (processor: MailboxProcessor<_>) (leftVector: ClVector<'a>) (rightVector: ClVector<'b>) (resultVector: ClVector<'c>) ->
+                match leftVector, rightVector, resultVector with
+                | ClVector.Dense left, ClVector.Dense right, ClVector.Dense result -> map2Dense processor left right result
+                | _ -> failwith "Unsupported vector format"
+
+        /// <summary>
+        /// Applying the given function to the corresponding elements of the two given arrays pairwise.
+        /// Returns new vector.
+        /// </summary>
+        /// <remarks>
+        /// The two input arrays must have the same lengths.
+        /// </remarks>
+        /// <param name="map">The function to transform the pairs of the input elements.</param>
+        /// <param name="clContext">OpenCL context.</param>
+        /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+        let map2Dense (map: Expr<'a option -> 'b option -> 'a option>) (clContext: ClContext) workGroupSize =
+            let map2Dense =
+                Dense.Vector.map2 map clContext workGroupSize
+
+            fun (processor: MailboxProcessor<_>) allocationFlag (leftVector: ClVector<'a>) (rightVector: ClVector<'b>) ->
+                match leftVector, rightVector with
+                | ClVector.Dense left, ClVector.Dense right -> map2Dense processor allocationFlag left right
+                | _ -> failwith "Unsupported vector format"
+
+        /// <summary>
+        /// Applying the given function to the corresponding elements of the two given arrays pairwise.
+        /// Returns new vector as option.
+        /// </summary>
+        /// <remarks>
+        /// The two input arrays must have the same lengths.
+        /// </remarks>
+        /// <param name="map">The function to transform the pairs of the input elements.</param>
+        /// <param name="clContext">OpenCL context.</param>
+        /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+        let map2Sparse (map: Expr<'a option -> 'b option -> 'a option>) (clContext: ClContext) workGroupSize =
+            let map2Sparse =
+                Sparse.Map2.run map clContext workGroupSize
+
+            let map2SparseDense =
+                Sparse.Map2.runSparseDense map clContext workGroupSize
+
+            fun (processor: MailboxProcessor<_>) allocationFlag (leftVector: ClVector<'a>) (rightVector: ClVector<'b>) ->
+                match leftVector, rightVector with
+                | ClVector.Sparse left, ClVector.Sparse right ->
+                    Option.map ClVector.Sparse (map2Sparse processor allocationFlag left right)
+                | ClVector.Sparse left, ClVector.Dense right ->
+                    Option.map ClVector.Sparse (map2SparseDense processor allocationFlag left right)
+                | _ -> failwith "Unsupported vector format"
+
     module Matrix =
         /// <summary>
         /// Builds a new matrix whose elements are the results of applying the given function
@@ -374,3 +456,43 @@ module Operations =
 
                     run processor allocationMode resultCapacity leftMatrix rightMatrix
                 | _ -> failwith "Matrix formats are not matching"
+
+        module COO =
+            /// <summary>
+            /// Generalized matrix-matrix multiplication. Left matrix should be in COO format.
+            /// </summary>
+            /// <param name="opAdd">Type of binary function to reduce entries.</param>
+            /// <param name="opMul">Type of binary function to combine entries.</param>
+            /// <param name="clContext">OpenCL context.</param>
+            /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+            let expand
+                (opAdd: Expr<'c -> 'c -> 'c option>)
+                (opMul: Expr<'a -> 'b -> 'c option>)
+                (clContext: ClContext)
+                workGroupSize
+                =
+
+                let run =
+                    SpGeMM.Expand.COO.run opAdd opMul clContext workGroupSize
+
+                fun (processor: MailboxProcessor<_>) allocationMode (leftMatrix: ClMatrix<'a>) (rightMatrix: ClMatrix<'b>) ->
+                    match leftMatrix, rightMatrix with
+                    | ClMatrix.COO leftMatrix, ClMatrix.CSR rightMatrix ->
+                        let allocCapacity =
+                            List.max [ sizeof<'a>
+                                       sizeof<'c>
+                                       sizeof<'b> ]
+                            |> uint64
+                            |> (*) 1UL<Byte>
+
+                        let resultCapacity =
+                            (clContext.MaxMemAllocSize / allocCapacity) / 3UL
+
+                        let resultCapacity =
+                            (min
+                             <| uint64 System.Int32.MaxValue
+                             <| resultCapacity)
+                            |> int
+
+                        run processor allocationMode resultCapacity leftMatrix rightMatrix
+                    | _ -> failwith "Matrix formats are not matching"