Repeating timers and suspending the computer

Repeating timers and suspending the computer

[Marcin Borkowski]

Hi all,

assume that I said

(run-with-timer 0 1
                (lambda () (message "%s" (format-time-string "%H:%M:%S.%3N"))))

and put my laptop in the "sleep mode" for 20 seconds.  How many time
messages should I get?  Assume `timer-max-repeats' is 10 (which seems to
be the default).

When I did the experiment, it seemed that the timer'd function was run
/twice/ after waking up, which looks really strange -- why two times?

Best,

-- 
Marcin Borkowski
http://mbork.pl

Re: Repeating timers and suspending the computer

[Eli Zaretskii]

> From: Marcin Borkowski <mbork@mbork.pl>
> Date: Fri, 09 Dec 2022 06:20:22 +0100
> 
> assume that I said
> 
> (run-with-timer 0 1
>                 (lambda () (message "%s" (format-time-string "%H:%M:%S.%3N"))))
> 
> and put my laptop in the "sleep mode" for 20 seconds.  How many time
> messages should I get?  Assume `timer-max-repeats' is 10 (which seems to
> be the default).
> 
> When I did the experiment, it seemed that the timer'd function was run
> /twice/ after waking up, which looks really strange -- why two times?

I think you have some implicit mental model of what happens when the
number of delayed invocations of the timer function exceeds that
limit, a model that you didn't describe.  You seem to be assuming that
you will get those 10 invocations, and no more, is that right?  But
that is not the only possible way of dealing with this situation.  In
fact, it isn't even smart: if time has jumped far ahead, why should
Emacs give you 10 useless invocations of the timer?

Or if you were expecting something else, please tell what you expected
and why.

Re: Repeating timers and suspending the computer

[Emanuel Berg]

Eli Zaretskii wrote:

> I think you have some implicit mental model [...]

IT buzzword of the year!

"We create a mental atmosphere"

https://www.youtube.com/watch?v=JoMJ-3yYjOc

-- 
underground experts united
https://dataswamp.org/~incal

Re: Repeating timers and suspending the computer

[Marcin Borkowski]

On 2022-12-09, at 08:25, Eli Zaretskii <eliz@gnu.org> wrote:

>> From: Marcin Borkowski <mbork@mbork.pl>
>> Date: Fri, 09 Dec 2022 06:20:22 +0100
>> 
>> assume that I said
>> 
>> (run-with-timer 0 1
>>                 (lambda () (message "%s" (format-time-string "%H:%M:%S.%3N"))))
>> 
>> and put my laptop in the "sleep mode" for 20 seconds.  How many time
>> messages should I get?  Assume `timer-max-repeats' is 10 (which seems to
>> be the default).
>> 
>> When I did the experiment, it seemed that the timer'd function was run
>> /twice/ after waking up, which looks really strange -- why two times?
>
> I think you have some implicit mental model of what happens when the

I think so, though it is pretty vague ATM.

> number of delayed invocations of the timer function exceeds that
> limit, a model that you didn't describe.  You seem to be assuming that
> you will get those 10 invocations, and no more, is that right?  But

"Assuming" is probably not the best word.  "Suspecting" might fit
better;-).

> that is not the only possible way of dealing with this situation.  In
> fact, it isn't even smart: if time has jumped far ahead, why should
> Emacs give you 10 useless invocations of the timer?

Well, I can think of some reasons...  (Not to say they are very /good/
reasons.)

> Or if you were expecting something else, please tell what you expected
> and why.

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?

-- 
Marcin Borkowski
http://mbork.pl

Re: Repeating timers and suspending the computer

[Eli Zaretskii]

> 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.

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.

Re: Repeating timers and suspending the computer

[Marcin Borkowski]

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

Re: Repeating timers and suspending the computer

[Eli Zaretskii]

> From: Marcin Borkowski <mbork@mbork.pl>
> Cc: help-gnu-emacs@gnu.org
> Date: Tue, 13 Dec 2022 06:16:53 +0100
> 
> ;; 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?

That's the idea, yes.

Re: Repeating timers and suspending the computer

[Marcin Borkowski]

On 2022-12-13, at 13:32, Eli Zaretskii <eliz@gnu.org> wrote:

>> From: Marcin Borkowski <mbork@mbork.pl>
>> Cc: help-gnu-emacs@gnu.org
>> Date: Tue, 13 Dec 2022 06:16:53 +0100
>>
>> ;; 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?
>
> That's the idea, yes.

Thanks.  Any ideas how to rephrase the manual so that it is unambiguous?

Best,

-- 
Marcin Borkowski
http://mbork.pl

Re: Repeating timers and suspending the computer

[Eli Zaretskii]

> From: Marcin Borkowski <mbork@mbork.pl>
> Cc: help-gnu-emacs@gnu.org
> Date: Wed, 14 Dec 2022 21:13:37 +0100
> 
> 
> On 2022-12-13, at 13:32, Eli Zaretskii <eliz@gnu.org> wrote:
> 
> >> 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?
> >
> > That's the idea, yes.
> 
> Thanks.  Any ideas how to rephrase the manual so that it is unambiguous?

I'm not sure I see why that matters.

Re: Repeating timers and suspending the computer

[Marcin Borkowski]

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

>> From: Marcin Borkowski <mbork@mbork.pl>
>> Cc: help-gnu-emacs@gnu.org
>> Date: Wed, 14 Dec 2022 21:13:37 +0100
>>
>>
>> On 2022-12-13, at 13:32, Eli Zaretskii <eliz@gnu.org> wrote:
>>
>> >> 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?
>> >
>> > That's the idea, yes.
>>
>> Thanks.  Any ideas how to rephrase the manual so that it is unambiguous?
>
> I'm not sure I see why that matters.

--8<---------------cut here---------------start------------->8---
If after careful rereading of the manual you still do not understand
what the command should do, that indicates a bug in the manual, which
you should report. The manual’s job is to make everything clear to
people who are not Emacs experts—including you. It is just as important
to report documentation bugs as program bugs.
--8<---------------cut here---------------end--------------->8---

(https://www.gnu.org/software/emacs/manual/html_node/emacs/Bug-Criteria.html)

I agree that it is not extremely important, but an unclear manual is
still a bug, right?

Best,

-- 
Marcin Borkowski
http://mbork.pl