anchor.diff:  
       let private computeInstanceCache = System.Collections.Concurrent.ConcurrentDictionary<Context, GLCompute>()
   
  +    let private getGLCompute (ctx : Context) =
  +        computeInstanceCache.GetOrAdd(ctx, fun ctx -> GLCompute(ctx))
   
       type Kernel(prog : Program, localSize : Option<V3i>) =   
  -        let GLCompute = computeInstanceCache.GetOrAdd(prog.Context, fun ctx -> GLCompute(ctx))
  +        let GLCompute = getGLCompute prog.Context
           
  +        
  +
           let mutable isDisposed = 0
   
           let ctx = prog.Context
  
positive.code:             b.[i] <- a.[i] * 3.0 + c.[V2i(i,0)].X
          }
  
      [<LocalSize(X = 256)>]
      let scan (add : Expr<'a -> 'a -> 'a>) (zero : Expr<'a>) (input : 'a[]) (ret : 'a[]) =
          compute {
              let temp = allocateShared<'a> 256
  
              let gid = getGlobalId().X
              let lid = getLocalId().X
  
negative.code: 
              let mutable d = 2
              let mutable s = 1
              while s < elements do
                  if lid % d = 0 && lid >= s then
                      temp.[lid] <- (%add) temp.[lid] temp.[lid - s]
  
  