anchor.diff:  
       member private this.FindLDSLineSize(pIndex: int, dIndex: int) =
           // Create wavefront test
  -        let o = Array.zeroCreate<int> (4 <<< 20)
  -        let localSize = 512
  +        let localSize = 256
  +        let globalSize = 2 <<< 20
  +        let tries = 100
  +        let strideMax = 32
  +
  +        let o = Array.zeroCreate<int> (globalSize)
           let localArr = Array.zeroCreate<char>((0 * localSize) + 255)
   
           // Ensure compilation overhead excluded
  
positive.code: open System.Runtime.InteropServices
  open FSCL.Runtime
  open System.Diagnostics
  
  type LDSBenchmark() = 
      [<ReflectedDefinition>]
  
negative.code:                 comp.Run()
              timer.Stop()
              let currentTime = timer.ElapsedMilliseconds
              Console.WriteLine("Stride " + (stride * elSize).ToString() + " bytes: " + currentTime.ToString() + " ms")
  
              // Update delta with prec
              if stride > 0 then 
                  raises.[stride - 1] <- currentTime - lastTime
              lastTime <- currentTime
          
          // Now get the sum of deltas of each bucket and multiple
          let raisesSum = new List<int>()
          raisesSum.Add(0)
          for i = 1 to raises.Length - 2 do
              let mutable currMult = 1
              let mutable sum = 0
              while (currMult * i) < raises.Length do
                  sum <- sum + (raises.[currMult * i] |> int)
                  currMult <- currMult + 1
              raisesSum.Add(sum)
  
          // Find lds line as max of dropsSum
          let mutable ldsLine = 0
          let mutable maxRaise = Int32.MinValue
          for i = 0 to raisesSum.Count - 1 do
              if raisesSum.[i] > maxRaise then
                  ldsLine <- i
                  maxRaise <- raisesSum.[i]
          Console.WriteLine("LDS line is " + (ldsLine * elSize).ToString() + " bytes")
          ldsLine * 4
  
      member private this.FindLDSBanksCount(stride: int, pIndex: int, dIndex: int) =
          // Create wavefront test
          let localSize = 256L
          let globalSize = 2 <<< 20
          let tries = 100
          let strideMax = 32
          let o = Array.zeroCreate<int> (2 <<< 20)
          let localArr = Array.zeroCreate<int>((((stride / 4) * 1) * (localSize |> int)) + 255)
  
          // Ensure compilation overhead excluded
  