anchor.diff:  
   
   module DefaultOverlays =
  -    
  +    open System.Threading
  +
       let timeString (t : MicroTime) =
           t.ToString()
   
  
positive.code: 
          runtime.CompileRender sg
  
      type AnnotationRenderTask(real : IRenderTask, annotation : IRenderTask, emit : RenderingResult -> unit) as this =
          inherit AdaptiveObject()
  
          let mutable upToDateExec = 0
          let mutable frameId = 0UL
  
          do real.AddOutput this
             annotation.AddOutput this
  
          interface IRenderTask with
              member x.FramebufferSignature = real.FramebufferSignature
              member x.Dispose() =
                  real.RemoveOutput x
                  annotation.RemoveOutput x
  
              member x.Runtime = real.Runtime
  
              member x.Run(caller, f) =
                  x.EvaluateAlways caller (fun () ->
                      // TODO: 1) does not work when rendering continuously
                      //       2) does also not work when annotating the same task multiple times
                      if not x.OutOfDate then upToDateExec <- upToDateExec + 1
                      else upToDateExec <- 0
  
                      frameId <- frameId + 1UL
  
                      if real.OutOfDate || upToDateExec > 1 then
                          let real = real.Run(x,f)
                          emit real
                          let annotation = annotation.Run(x,f)
                          RenderingResult(annotation.Framebuffer, real.Statistics + annotation.Statistics)
                      else
                          let real = real.Run(x,f)
                          let annotation = annotation.Run(x,f)
                          RenderingResult(annotation.Framebuffer, real.Statistics + annotation.Statistics)
                  )
  
              member x.FrameId = frameId
  
      let withStatistics (t : IRenderTask) =
          match t.Runtime with
              | Some runtime ->
                  let frame = Statistics.timeFrame (TimeSpan.FromMilliseconds 100.0)
                  let emit (r : RenderingResult) = frame.Emit r.Statistics
  
                  let overlay = statisticsOverlay runtime frame.Average
  
                  let task = new AnnotationRenderTask(t, overlay, emit)
                  task :> IRenderTask
              | _ -> 
                  Log.warn "could not determine the original task's runtime"
  
negative.code:         let values = ConcurrentQueue<DateTime * 'a>()
          let mutable tickInstalled = false
  
          let minCount = 5
          let mutable sum = zero
          let mutable count = 0
  
          let rec prune (rc : int) (t : DateTime) =
              if values.Count <= minCount then
                  rc
              else
                  match values.TryPeek() with
                      | (true, (tv,v)) ->
                          if tv < t - length then
                              match values.TryDequeue() with
                                  | (true, (tv,v)) ->
                                      Interlocked.Decrement &count |> ignore
                                      Interlocked.Change(&sum, fun s -> sub s v)
                                      prune (rc + 1) t
                                  | _ -> 
                                      rc
                          else
                              rc
                      | _ -> 
                          rc
  
          let emit (value : 'a) =
              let now = DateTime.Now
  