Re: Repeating timers and suspending the computer

[Marcin Borkowski <mbork@mbork.pl>]

On 2022-12-11, at 07:52, Eli Zaretskii <eliz@gnu.org> wrote:

>> From: Marcin Borkowski <mbork@mbork.pl>
>> Cc: help-gnu-emacs@gnu.org
>> Date: Sat, 10 Dec 2022 22:39:11 +0100
>>
>>
>> Frankly, I expected my function to be called either once or 10 times,
>> but not twice.
>>
>> So, how can I get a better mental model?
>
> By looking at the source, of course.  There you will see that if the
> expected number of calls exceeds the limit, Emacs advances the "last
> invocation time" of the timer to the current time, thus effectively
> bypassing all those delayed invocations.

Well, I looked at timer.el, but it seems (not surprisingly) that timers
are implemented at least partially in the C core:

--8<---------------cut here---------------start------------->8---
(defun timer-event-handler (timer)
  "Call the handler for the timer TIMER.
This function is called, by name, directly by the C code."
...
)
--8<---------------cut here---------------end--------------->8---

and I'm not brave nor knowledgeable enough to dive there.

But here is one part I found:

--8<---------------cut here---------------start------------->8---
;; If real time has jumped forward,
;; perhaps because Emacs was suspended for a long time,
;; limit how many times things get repeated.
(if (and (numberp timer-max-repeats)
         (time-less-p (timer--time timer) nil))
    (let ((repeats (/ (timer-until timer nil)
                      (timer--repeat-delay timer))))
      (if (> repeats timer-max-repeats)
          (timer-inc-time timer (* (timer--repeat-delay timer)
                                   repeats)))))
--8<---------------cut here---------------end--------------->8---

Do I get it correctly that this means that of the scheduled number of
repeats is /less/ than `timer-max-repeats', then all of them get
executed, but when it is greater than that, only one of them is?

Here is the declaration of that variable:

--8<---------------cut here---------------start------------->8---
(defcustom timer-max-repeats 10
  "Maximum number of times to repeat a timer, if many repeats are delayed.
Timer invocations can be delayed because Emacs is suspended or busy,
or because the system's time changes.  If such an occurrence makes it
appear that many invocations are overdue, this variable controls
how many will really happen."
  :type 'integer
  :group 'internal)
--8<---------------cut here---------------end--------------->8---

Now I can see that the docstring is ambiguous, isn't it?  What it seems
to do is "if the timer-ed function would be called more than
`timer-max-repeats' times, run it just once", and what I understood from
the docstring was "if the timer-ed function would be called more than
`timer-max-repeats' times, run it `timer-max-repeats' times".

> Why you see 2 calls instead of just the expected one needs more
> investigation.  At the very least, it depends on the exact time when
> your computer was awoken: if that time was close to the integral
> multiple of the timer period, you can legitimately see two invocations
> with a very small time interval between them.  But maybe some other
> factor is at work here.  If you are really interested, I suggest to
> instrument timer.el with some calls to 'message' and repeat the
> experiment to learn why that happens.

That is interesting.  What I did was more or less this:

--8<---------------cut here---------------start------------->8---
(setq testing-timer
      (run-with-timer
       1 1
       (lambda ()
	 (message "%s" (format-time-string "%H:%M:%S.%3N")))))
--8<---------------cut here---------------end--------------->8---

so that I knew the exact time my function was run, and it seems that if
I waited much longer than 10 seconds, it was run twice at the exact same
moment.

I'm not sure if I'm determined enough to investigate this further...

Thank you very much, now I know much more about timers!

-- 
Marcin Borkowski
http://mbork.pl