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:                 comp.Run()
              timer.Stop()
              let currentTime = timer.ElapsedMilliseconds
              Console.WriteLine("Stride " + (stride * 4).ToString() + " bytes: " + currentTime.ToString() + " ms")
  
              // Update drops
              if (currentTime < lastTime) then            
                  // Last stride may be the LDS line size, we +1
                  drops.[stride - 1] <- drops.[stride - 1] + 1
              else 
                  if stride > 0 then                
                      drops.[stride - 1] <- drops.[stride - 1] - 1
              lastTime <- currentTime
          
          // Now get the sum of drops of each bucket and multiple
          let dropsSum = new List<int>()
          dropsSum.Add(0)
          for i = 1 to drops.Length - 1 do
              let mutable currMult = 1
              let mutable sum = 0
              while (currMult * i) < drops.Length do
                  sum <- sum + drops.[currMult * i]
                  currMult <- currMult + 1
              dropsSum.Add(sum)
  
          // Find lds line as max of dropsSum
          let mutable ldsLine = 0
          let mutable maxDrop = Int32.MinValue
          for i = 1 to dropsSum.Count - 1 do
              if dropsSum.[i] > maxDrop then
                  ldsLine <- i
                  maxDrop <- dropsSum.[i]
          Console.WriteLine("LDS line is " + (ldsLine * 4).ToString() + " bytes")
          ldsLine * 4
  
      member private this.FindLDSBanksCount(stride: int, pIndex: int, dIndex: int) =
          // Create wavefront test
          let o = Array.zeroCreate<int> (2 <<< 20)
          let localSize = 256L
          let localArr = Array.zeroCreate<int>((((stride / 4) * 1) * (localSize |> int)) + 255)
  
          // Ensure compilation overhead excluded
  
negative.code:         comp.Run()
  
          // Now start from 1 and increase to see no conflicts 
          let raises = Array.zeroCreate<int64> (strideMax + 1)
          let mutable lastTime = 0L
          let elSize = Marshal.SizeOf(localArr.GetType().GetElementType())
  
          for stride = 0 to strideMax do
              let localArr = Array.zeroCreate<char>((stride * localSize) + 255)
              let comp = <@ DEVICE(pIndex, dIndex, 
                                   LDSBenchmark.LDSStrideTest(localArr, o, stride, ws)) @>
  