anchor.diff:  
               let effect (ct : CancellationToken) (n : LodDataNode) =
                   stepwise {
  +                    do! Stepwise.register (fun () -> removeFromWorkingSet n) // also if cancelled remove
                       let data =  
                           try 
                               Async.RunSynchronously(node.Data.GetData(n), cancellationToken = ct) |> Some
  -                        with | e -> Log.warn "data got cancelled"; None
  +                        with | e -> 
  +                            removeFromWorkingSet n
  +                            Log.warn "data got cancelled"; 
  +                            None
                       match data with
  -                        | Some v -> 
  +                        | Some v ->    
                               do! Stepwise.register (fun () -> pool.Remove v |> ignore)
                               let range = pool.Add v
                               let gref = { geometry = v; range = range; node = n }
                               do! Stepwise.register (fun () -> deactivate gref)
                               activate gref
  +                            removeFromWorkingSet n
                               return ()
                           | None -> return! Stepwise.cancel
                   }
  
positive.code:                         for v in add do
                              let id = getId v
                              deltas.[id % queueCount].Add v
                              content.Add v |> ignore
  
                          for v in rem do
                              let id = getId v
                              deltas.[id % queueCount].Remove v
                              content.Remove v |> ignore
                  }
  
              let subV = view.AddMarkingCallback (fun () -> r.Put ()) 
  
negative.code: 
          let pool = GeometryPool.createAsync runtime
          let calls = DrawCallSet(false)
          let mutable activeSize = 0L
  
  
          let pruning = false
          let inactive = ConcurrentHashQueue<GeometryRef>()
          let mutable inactiveSize = 0L
  
          let workingSet = CSet.empty
  
  
          let activate (n : GeometryRef) =
              let size = n.range.Size
  