anchor.diff:          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) =
  -            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
  +            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
  -                | _ -> 
  -                    rc
   
           let emit (value : 'a) =
               let now = DateTime.Now
  
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:             f()
  
      let private timer = new Timer(TimerCallback(tick), null, 10, 10)
  
      let installTick (f : unit -> unit) =
          lock tickFunctions (fun () -> 
              tickFunctions.Add(f, f)
          )
          { new IDisposable with
              member x.Dispose() = lock tickFunctions (fun () -> tickFunctions.Remove f |> ignore)
          }
  
      type Interlocked with
          static member TryChange(cell : byref<'a>, f : 'a -> 'a) =
  