add: Scatter.firstOccurrence

Author: IgorErin

src/GraphBLAS-sharp.Backend/Common/ClArray.fs

@@ -184,7 +184,7 @@ module ClArray =
     let removeDuplications (clContext: ClContext) workGroupSize =
 
         let scatter =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         let getUniqueBitmap = getUniqueBitmapLastOccurrence clContext workGroupSize
 
@@ -349,7 +349,7 @@ module ClArray =
             PrefixSum.runExcludeInplace <@ (+) @> clContext workGroupSize
 
         let scatter =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         fun (processor: MailboxProcessor<_>) allocationMode (array: ClArray<'a>) ->
 

src/GraphBLAS-sharp.Backend/Common/Scatter.fs

@@ -3,41 +3,19 @@ namespace GraphBLAS.FSharp.Backend.Common
 open Brahma.FSharp
 
 module internal Scatter =
-
-    /// <summary>
-    /// Creates a new array from the given one where it is indicated by the array of positions at which position in the new array
-    /// should be a value from the given one.
-    /// </summary>
-    /// <remarks>
-    /// Every element of the positions array must not be less than the previous one.
-    /// If there are several elements with the same indices, the last one of them will be at the common index.
-    /// If index is out of bounds, the value will be ignored.
-    /// </remarks>
-    /// <example>
-    /// <code>
-    /// let positions = [| 0; 0; 1; 1; 1; 2; 3; 3; 4 |]
-    /// let values = [| 1.9; 2.8; 3.7; 4.6; 5.5; 6.4; 7.3; 8.2; 9.1 |]
-    /// let result = run clContext 32 processor positions values result
-    /// ...
-    /// > val result = [| 2.8; 5.5; 6.4; 8.2; 9.1 |]
-    /// </code>
-    /// </example>
-    let runInplace<'a> (clContext: ClContext) workGroupSize =
+    let private general<'a> predicate (clContext: ClContext) workGroupSize =
 
         let run =
             <@ fun (ndRange: Range1D) (positions: ClArray<int>) (positionsLength: int) (values: ClArray<'a>) (result: ClArray<'a>) (resultLength: int) ->
 
                 let gid = ndRange.GlobalID0
 
                 if gid < positionsLength then
-                    let index = positions.[gid]
+                    // positions lengths == values length
+                    let predicateResult = (%predicate) gid positionsLength positions resultLength
 
-                    if 0 <= index && index < resultLength then
-                        if gid < positionsLength - 1 then
-                            if index <> positions.[gid + 1] then
-                                result.[index] <- values.[gid]
-                        else
-                            result.[index] <- values.[gid] @>
+                    if predicateResult then
+                        result.[positions.[gid]] <- values.[gid] @>
 
         let program = clContext.Compile(run)
 
@@ -58,3 +36,60 @@ module internal Scatter =
             )
 
             processor.Post(Msg.CreateRunMsg<_, _>(kernel))
+
+    /// <summary>
+    /// Creates a new array from the given one where it is indicated by the array of positions at which position in the new array
+    /// should be a value from the given one.
+    /// </summary>
+    /// <remarks>
+    /// Every element of the positions array must not be less than the previous one.
+    /// If there are several elements with the same indices, the FIRST one of them will be at the common index.
+    /// If index is out of bounds, the value will be ignored.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// let positions = [| 0; 0; 1; 1; 1; 2; 3; 3; 4 |]
+    /// let values = [| 1.9; 2.8; 3.7; 4.6; 5.5; 6.4; 7.3; 8.2; 9.1 |]
+    /// let result = run clContext 32 processor positions values result
+    /// ...
+    /// > val result = [| 1,9; 3.7; 6.4; 7.3; 9.1 |]
+    /// </code>
+    /// </example>
+    let scatterFirstOccurrence clContext =
+        general
+        <| <@ fun gid _ (positions: ClArray<int>) resultLength ->
+                 let currentKey = positions.[gid]
+                 // first occurrence condition
+                 (gid = 0 || positions.[gid - 1] <> positions.[gid])
+                    // result position in valid range
+                    && (0 <= currentKey && currentKey < resultLength)  @>
+        <| clContext
+
+    /// <summary>
+    /// Creates a new array from the given one where it is indicated by the array of positions at which position in the new array
+    /// should be a value from the given one.
+    /// </summary>
+    /// <remarks>
+    /// Every element of the positions array must not be less than the previous one.
+    /// If there are several elements with the same indices, the last one of them will be at the common index.
+    /// If index is out of bounds, the value will be ignored.
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// let positions = [| 0; 0; 1; 1; 1; 2; 3; 3; 4 |]
+    /// let values = [| 1.9; 2.8; 3.7; 4.6; 5.5; 6.4; 7.3; 8.2; 9.1 |]
+    /// let result = run clContext 32 processor positions values result
+    /// ...
+    /// > val result = [| 2.8; 5.5; 6.4; 8.2; 9.1 |]
+    /// </code>
+    /// </example>
+    let scatterLastOccurrence clContext =
+        general
+        <| <@ fun gid positionsLength (positions: ClArray<int>) resultLength ->
+                let index = positions.[gid]
+                // last occurrence condition
+                (gid = positionsLength - 1 || index <> positions.[gid + 1])
+                    // result position in valid range
+                    && (0 <= index && index < resultLength) @>
+        <| clContext
+

src/GraphBLAS-sharp.Backend/Matrix/CSRMatrix/SpGEMM/Expand.fs

@@ -81,7 +81,7 @@ module Expand =
 
         let init = ClArray.init clContext workGroupSize Map.id
 
-        let scatter = Scatter.runInplace clContext workGroupSize
+        let scatter = Scatter.scatterLastOccurrence clContext workGroupSize
 
         let zeroCreate = ClArray.zeroCreate clContext workGroupSize
 
@@ -214,7 +214,7 @@ module Expand =
 
         let init = ClArray.init clContext workGroupSize Map.id // TODO(fuse)
 
-        let scatter = Scatter.runInplace clContext workGroupSize
+        let scatter = Scatter.scatterLastOccurrence clContext workGroupSize
 
         fun (processor: MailboxProcessor<_>) allocationMode (values: ClArray<'a>) (columns: Indices) (rows: Indices) ->
 

src/GraphBLAS-sharp.Backend/Matrix/CSRMatrix/SpGEMMMasked.fs

@@ -151,8 +151,8 @@ module internal SpGEMMMasked =
         let calculate =
             calculate context workGroupSize opAdd opMul
 
-        let scatter = Scatter.runInplace context workGroupSize
-        let scatterData = Scatter.runInplace context workGroupSize
+        let scatter = Scatter.scatterLastOccurrence context workGroupSize
+        let scatterData = Scatter.scatterLastOccurrence context workGroupSize
 
         let scanInplace =
             PrefixSum.standardExcludeInplace context workGroupSize

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

@@ -11,10 +11,10 @@ module Common =
     let setPositions<'a when 'a: struct> (clContext: ClContext) workGroupSize =
 
         let indicesScatter =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         let valuesScatter =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         let sum =
             PrefixSum.standardExcludeInplace clContext workGroupSize

src/GraphBLAS-sharp.Backend/Vector/DenseVector/DenseVector.fs

@@ -90,10 +90,10 @@ module DenseVector =
     let toSparse<'a when 'a: struct> (clContext: ClContext) workGroupSize =
 
         let scatterValues =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         let scatterIndices =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         let getBitmap =
             ClArray.map clContext workGroupSize

src/GraphBLAS-sharp.Backend/Vector/SparseVector/Common.fs

@@ -13,10 +13,10 @@ module internal Common =
             PrefixSum.standardExcludeInplace clContext workGroupSize
 
         let valuesScatter =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         let indicesScatter =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         fun (processor: MailboxProcessor<_>) allocationMode (allValues: ClArray<'a>) (allIndices: ClArray<int>) (positions: ClArray<int>) ->
 

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

@@ -35,7 +35,7 @@ module Vector =
 
     let ofList (clContext: ClContext) workGroupSize =
         let scatter =
-            Scatter.runInplace clContext workGroupSize
+            Scatter.scatterLastOccurrence clContext workGroupSize
 
         let zeroCreate =
             ClArray.zeroCreate clContext workGroupSize

tests/GraphBLAS-sharp.Tests/Common/Scatter.fs

@@ -21,13 +21,13 @@ let wgSize = Tests.Utils.defaultWorkGroupSize
 
 let q = defaultContext.Queue
 
-let makeTest scatter (array: (int * 'a) []) (result: 'a []) =
+let makeTest hostScatter scatter (array: (int * 'a) []) (result: 'a []) =
     if array.Length > 0 then
         let positions, values = Array.unzip array
 
         let expected =
             Array.copy result
-            |> HostPrimitives.scatter positions values
+            |> hostScatter positions values
 
         let actual =
             use clPositions = context.CreateClArray positions
@@ -41,15 +41,29 @@ let makeTest scatter (array: (int * 'a) []) (result: 'a []) =
         $"Arrays should be equal. Actual is \n%A{actual}, expected \n%A{expected}"
         |> Tests.Utils.compareArrays (=) actual expected
 
-let testFixtures<'a when 'a: equality> =
-    Scatter.runInplace<'a> context wgSize
-    |> makeTest
+let testFixturesLast<'a when 'a: equality> hostScatter =
+    Scatter.scatterLastOccurrence<'a> context wgSize
+    |> makeTest hostScatter
+    |> testPropertyWithConfig { config with endSize = 10 } $"Correctness on %A{typeof<'a>}"
+
+let testFixturesFirst<'a when 'a: equality> hostScatter =
+    Scatter.scatterFirstOccurrence<'a> context wgSize
+    |> makeTest hostScatter
     |> testPropertyWithConfig { config with endSize = 10 } $"Correctness on %A{typeof<'a>}"
 
 let tests =
     q.Error.Add(fun e -> failwithf $"%A{e}")
 
-    [ testFixtures<int>
-      testFixtures<byte>
-      testFixtures<bool> ]
-    |> testList "Backend.Common.Scatter tests"
+    let last =
+        [ testFixturesLast<int> HostPrimitives.scatterLastOccurrence
+          testFixturesLast<byte> HostPrimitives.scatterLastOccurrence
+          testFixturesLast<bool> HostPrimitives.scatterLastOccurrence ]
+        |> testList "Last Occurrence"
+
+    let first =
+        [ testFixturesFirst<int> HostPrimitives.scatterFirstOccurrence
+          testFixturesFirst<byte> HostPrimitives.scatterFirstOccurrence
+          testFixturesFirst<bool> HostPrimitives.scatterFirstOccurrence ]
+        |> testList "First Occurrence"
+
+    testList "Scatter tests" [first; last]

tests/GraphBLAS-sharp.Tests/Helpers.fs

@@ -200,11 +200,11 @@ module HostPrimitives =
         ||> Array.map2 (fun (fst, snd) value ->  fst, snd, value)
         |> Array.unzip3
 
-    let scatter (positions: int array) (values: 'a array) (resultValues: 'a array) =
+    let generalScatter getBitmap (positions: int array) (values: 'a array) (resultValues: 'a array) =
 
         if positions.Length <> values.Length then failwith "Lengths must be the same"
 
-        let bitmap = getUniqueBitmapLastOccurrence positions
+        let bitmap = getBitmap positions
 
         Array.iteri2
             (fun index bit key ->
@@ -215,6 +215,10 @@ module HostPrimitives =
 
         resultValues
 
+    let scatterLastOccurrence positions = generalScatter getUniqueBitmapLastOccurrence positions
+
+    let scatterFirstOccurrence positions = generalScatter getUniqueBitmapFirstOccurrence positions
+
     let gather (positions: int []) (values: 'a []) (result: 'a []) =
         if positions.Length <> result.Length then
             failwith "Lengths must be the same"