anchor.diff:  
       let aValues = m1
       let bValues = m2
  -    let cParallel = Array.zeroCreate(rows * columns)
  +    let cParallel = Array.zeroCreate(mSize * mSize)
   
       let command = 
           <@
               fun (r:_2D) (a:array<_>) (b:array<_>) (c:array<_>) -> 
                   let tx = r.GlobalID0
                   let ty = r.GlobalID1
  -                let mutable buf = c.[ty * columns + tx]
  -                for k in 0 .. columns - 1 do
  -                    buf <- buf + (a.[ty * columns + k] * b.[k * columns + tx])
  -                c.[ty * columns + tx] <- buf
  +                let mutable buf = c.[ty * mSize + tx]
  +                for k in 0 .. mSize - 1 do
  +                    buf <- buf + (a.[ty * mSize + k] * b.[k * mSize + tx])
  +                c.[ty * mSize + tx] <- buf
           @>
   
  -    printfn "Multiplying two %Ax%A matrices %A times using .NET..." rows columns iterations
  -    let cNormal = Array.zeroCreate (rows * columns)
  +    printfn "Multiplying two %Ax%A matrices %A times using .NET..." mSize mSize iterations
  +    let cNormal = Array.zeroCreate (mSize * mSize)
  +    let cpuStart = System.DateTime.Now
       for i in 0 .. iterations - 1 do
  -        Timer<string>.Global.Start()
  -        Multiply aValues rows columns bValues rows columns cNormal
  -        Timer<string>.Global.Lap(".NET")
  +        Multiply aValues mSize mSize bValues mSize mSize cNormal
  +    let cpuTime = System.DateTime.Now - cpuStart
   
       printfn "done."
   
  -    printfn 
  -        "Multiplying two %Ax%A matrices %A times using OpenCL and selected platform/device : %A ..." 
  -        rows columns iterations provider
  +    printfn "Multiplying two %Ax%A matrices %A times using OpenCL and selected platform/device : %A ..." mSize mSize iterations provider
   
       let kernel, kernelPrepare, kernelRun = provider.Compile command
  -    let d =(new _2D(rows, columns, localWorkSize, localWorkSize))
  +    let d =(new _2D(mSize, mSize, localWorkSize, localWorkSize))
       kernelPrepare d aValues bValues cParallel
       
  +    let gpuStart = System.DateTime.Now
       for i in 0 .. iterations - 1 do
  -        Timer<string>.Global.Start()
  -        let _ = commandQueue.Add(kernelRun()).Finish()            
  -        Timer<string>.Global.Lap("OpenCL")
  -        
  +        commandQueue.Add(kernelRun()).Finish() |> ignore
  +    let gpuTime = System.DateTime.Now - gpuStart
  +
       let _ = commandQueue.Add(cParallel.ToHost provider).Finish()
       
       printfn "Verifying results..."
       let mutable isSuccess = true
  -    for i in 0 .. rows * columns - 1 do
  +    for i in 0 .. mSize * mSize - 1 do
           if isSuccess && System.Math.Abs(float32 (cParallel.[i] - cNormal.[i])) > 0.01f
           then
               isSuccess <- false
  -            printfn 
  -                "Expected: %A Actual: %A Error = %A" 
  -                cNormal.[i] cParallel.[i] (System.Math.Abs(cParallel.[i] - cNormal.[i]))            
  +            printfn "Expected: %A Actual: %A Error = %A" cNormal.[i] cParallel.[i] (System.Math.Abs(cParallel.[i] - cNormal.[i]))            
               
       printfn "done."
   
  -    Timer<string>.Global.Average(".NET") |> printfn "Avg. time, F#: %A"
  -    Timer<string>.Global.Average("OpenCL") |> printfn "Avg. time, OpenCL: %A"
  +    cpuTime.TotalMilliseconds / float iterations |> printfn "Avg. time, F#: %A"
  +    gpuTime.TotalMilliseconds / float iterations |> printfn "Avg. time, OpenCL: %A"
   
       commandQueue.Dispose()
  -    provider.Dispose()
       provider.CloseAllBuffers()
  +    provider.Dispose()    
               
  -Main "NVIDIA*" (MakeMatrix 200 200) (MakeMatrix 200 200) |> ignore
  +Main "NVIDIA*" 300
   
   (**
   
  
positive.code:                  buf <- buf + a.[i * aCols + k] * b.[k * bCols + j]
              c.[i * cCols + j] <- c.[i * cCols + j] + buf
      
  let Main platformName (m1: array<_>) (m2: array<_>) =    
  
      let rows = 200
      let columns = 200
      let localWorkSize = 2
      let iterations = 10
      let deviceType = DeviceType.Default
  
negative.code: 
  module MatrixMultiply
  
  open OpenCL.Net
  open Brahma.OpenCL
  open Brahma.FSharp.OpenCL.Core
  