add: ClArray.upperBound

Author: IgorErin

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

@@ -694,3 +694,33 @@ module ClArray =
             else
                 None
 
+    let upperBound<'a when 'a : equality and 'a : comparison> (clContext: ClContext) workGroupSize =
+
+        let kernel =
+            <@ fun (ndRange: Range1D) length (values: ClArray<'a>) (value: ClCell<'a>) (result: ClCell<int>) ->
+
+                let value = value.Value
+                let gid = ndRange.GlobalID0
+
+                if gid = 0 then
+
+                    result.Value <-
+                        (%Search.Bin.lowerBound 0) length value values @>
+
+        let program = clContext.Compile(kernel)
+
+        fun (processor: MailboxProcessor<_>) (values: ClArray<'a>) (value: ClCell<'a>) ->
+            let result = clContext.CreateClCell 0
+
+            let kernel = program.GetKernel()
+
+            let ndRange =
+                Range1D.CreateValid(1, workGroupSize)
+
+            processor.Post(Msg.MsgSetArguments(fun () -> kernel.KernelFunc ndRange values.Length values value result))
+            processor.Post(Msg.CreateRunMsg<_, _> kernel)
+
+            result
+
+
+

src/GraphBLAS-sharp.Backend/Matrix/SpGeMM/Expand.fs

@@ -72,7 +72,16 @@ module Expand =
                 let segmentPointersByLeftMatrixRows =
                     clContext.CreateClArrayWithSpecificAllocationMode(DeviceOnly, leftMatrix.RowPointers.Length)
 
+                gather processor segmentLengths leftMatrix.RowPointers segmentPointersByLeftMatrixRows
 
+                let segmentPointersByLeftMatrixRows = segmentPointersByLeftMatrixRows.ToHostAndFree processor
+
+                let beginRow = 0
+                let totalWork = 0
+
+                while beginRow < leftMatrix.RowCount do
+
+                    //let endRow =
 
                 ()
 

src/GraphBLAS-sharp.Backend/Quotes/Search.fs

@@ -121,23 +121,25 @@ module Search =
 
                 resultPosition @>
 
-        let lowerBound<'a when 'a : equality and 'a : comparison> startValue  =
+        let lowerBound<'a when 'a: comparison> startValue  =
             <@ fun lenght sourceItem (keys: ClArray<'a>) ->
 
                 let mutable leftEdge = 0
                 let mutable rightEdge = lenght - 1
 
                 let mutable resultPosition = startValue
 
-                while leftEdge <= rightEdge do
-                    let currentPosition = (leftEdge + rightEdge) / 2
-                    let currentKey = keys.[currentPosition]
+                if sourceItem >= keys.[lenght - 1] then lenght - 1
+                else
+                    while leftEdge <= rightEdge do
+                        let currentPosition = (leftEdge + rightEdge) / 2
+                        let currentKey = keys.[currentPosition]
 
-                    if sourceItem < currentKey then
-                        resultPosition <- currentPosition
+                        if sourceItem < currentKey then
+                            resultPosition <- currentPosition
 
-                        rightEdge <- currentPosition - 1
-                    else
-                        leftEdge <- currentPosition + 1
+                            rightEdge <- currentPosition - 1
+                        else
+                            leftEdge <- currentPosition + 1
 
-                resultPosition @>
+                    resultPosition @>

tests/GraphBLAS-sharp.Tests/Backend/Common/ClArray/UpperBound.fs

@@ -0,0 +1,60 @@
+module GraphBLAS.FSharp.Tests.Backend.Common.ClArray.UpperBound
+
+open Expecto
+open Brahma.FSharp
+open GraphBLAS.FSharp.Backend.Common
+open GraphBLAS.FSharp.Test
+open GraphBLAS.FSharp.Tests
+open GraphBLAS.FSharp.Backend.Objects.ClCell
+
+let context = Context.defaultContext.ClContext
+
+let processor = Context.defaultContext.Queue
+
+let config =
+    { Utils.defaultConfig with
+          arbitrary = [ typeof<Generators.UpperBound> ] }
+
+let makeTest testFun (array: 'a [], value: 'a) =
+
+    if array.Length > 0 then
+
+        let array = Array.sort array
+
+        let clArray = context.CreateClArray array
+        let clValue = context.CreateClCell value
+
+        let actual =
+            (testFun processor clArray clValue: ClCell<_>)
+                .ToHostAndFree processor
+
+        let expected =
+            let mutable expected = 0
+
+            let array = Array.rev array
+
+            for i in 0 .. array.Length - 1 do
+                let currentValue = array.[i]
+
+                if value < currentValue  then
+                    expected <- i
+
+            array.Length - expected - 1
+
+        "Results must be the same"
+        |> Expect.equal actual expected
+
+let createTest<'a when 'a : equality and 'a : comparison> =
+    ClArray.upperBound<'a> context Utils.defaultWorkGroupSize
+    |> makeTest
+    |> testPropertyWithConfig { config with endSize = 10 } $"test on %A{typeof<'a>}"
+
+let tests =
+    [ createTest<int>
+
+      if Utils.isFloat64Available context.ClDevice then
+        createTest<float>
+
+      createTest<float32>
+      createTest<bool> ]
+    |> testList "UpperBound"

tests/GraphBLAS-sharp.Tests/Generators.fs

@@ -1160,6 +1160,64 @@ module Generators =
             pairOfVectorsOfEqualSize <| Arb.generate<bool>
             |> Arb.fromGen
 
+    type UpperBound() =
+            static let arrayAndChunkPosition (valuesGenerator: Gen<'a>) =
+                gen {
+                    let! size = Gen.sized <| fun size -> Gen.choose (1, size + 1)
+
+                    let! array = Gen.arrayOfLength size valuesGenerator
+
+                    let! valueIndex = Gen.choose (0, array.Length - 1)
+
+                    let value = array.[valueIndex]
+
+                    return (array, value)
+                }
+
+            static member IntType() =
+                arrayAndChunkPosition <| Arb.generate<int>
+                |> Arb.fromGen
+
+            static member FloatType() =
+                arrayAndChunkPosition
+                <| (Arb.Default.NormalFloat()
+                    |> Arb.toGen
+                    |> Gen.map float)
+                |> Arb.fromGen
+
+            static member Float32Type() =
+                arrayAndChunkPosition
+                <| (normalFloat32Generator <| System.Random())
+                |> Arb.fromGen
+
+            static member SByteType() =
+                arrayAndChunkPosition <| Arb.generate<sbyte>
+                |> Arb.fromGen
+
+            static member ByteType() =
+                arrayAndChunkPosition <| Arb.generate<byte>
+                |> Arb.fromGen
+
+            static member Int16Type() =
+                arrayAndChunkPosition <| Arb.generate<int16>
+                |> Arb.fromGen
+
+            static member UInt16Type() =
+                arrayAndChunkPosition <| Arb.generate<uint16>
+                |> Arb.fromGen
+
+            static member Int32Type() =
+                arrayAndChunkPosition <| Arb.generate<int32>
+                |> Arb.fromGen
+
+            static member UInt32Type() =
+                arrayAndChunkPosition <| Arb.generate<uint32>
+                |> Arb.fromGen
+
+            static member BoolType() =
+                arrayAndChunkPosition <| Arb.generate<bool>
+                |> Arb.fromGen
+
     module Matrix =
         type Sub() =
             static let arrayAndChunkPosition (valuesGenerator: Gen<'a>) =

tests/GraphBLAS-sharp.Tests/GraphBLAS-sharp.Tests.fsproj

@@ -29,6 +29,7 @@
         <Compile Include="Backend/Common/ClArray/Pairwise.fs" />
         <Compile Include="Backend/Common/ClArray/RemoveDuplicates.fs" />
         <Compile Include="Backend/Common/ClArray/Replicate.fs" />
+        <Compile Include="Backend\Common\ClArray\UpperBound.fs" />
         <Compile Include="Backend/Common/Gather.fs" />
         <Compile Include="Backend/Common/Reduce/Reduce.fs" />
         <Compile Include="Backend/Common/Reduce/ReduceByKey.fs" />

tests/GraphBLAS-sharp.Tests/Program.fs

@@ -4,4 +4,4 @@ open GraphBLAS.FSharp.Tests
 
 
 [<EntryPoint>]
-let main argv = Backend.Matrix.SubRows.tests |> testSequenced |> runTestsWithCLIArgs [] argv
+let main argv = Common.ClArray.UpperBound.tests |> testSequenced |> runTestsWithCLIArgs [] argv