Add enable_timeout_every() to fire the same timeout repeatedly.

enable_timeout_at() and enable_timeout_after() can still be used
when you want to fire a timeout just once.

Patch by me, per a suggestion from Tom Lane.

Discussion: http://postgr.es/m/2992585.1632938816@sss.pgh.pa.us
Discussion: http://postgr.es/m/CA+TgmoYqSF5sCNrgTom9r3Nh=at4WmYFD=gsV-omStZ60S0ZUQ@mail.gmail.com

diff --git a/src/backend/utils/misc/timeout.c b/src/backend/utils/misc/timeout.c
index 95a273d9cfbdbd672e3d3d6eba594df4fec164c5..af74e99ed1af69156f74a682b77ea09efc63001e 100644 (file)
--- a/src/backend/utils/misc/timeout.c
+++ b/src/backend/utils/misc/timeout.c
@@ -36,6 +36,7 @@ typedef struct timeout_params
 
    TimestampTz start_time;     /* time that timeout was last activated */
    TimestampTz fin_time;       /* time it is, or was last, due to fire */
+   int         interval_in_ms; /* time between firings, or 0 if just once */
 } timeout_params;
 
 /*
@@ -153,7 +154,8 @@ remove_timeout_index(int index)
  * Enable the specified timeout reason
  */
 static void
-enable_timeout(TimeoutId id, TimestampTz now, TimestampTz fin_time)
+enable_timeout(TimeoutId id, TimestampTz now, TimestampTz fin_time,
+              int interval_in_ms)
 {
    int         i;
 
@@ -188,6 +190,7 @@ enable_timeout(TimeoutId id, TimestampTz now, TimestampTz fin_time)
    all_timeouts[id].indicator = false;
    all_timeouts[id].start_time = now;
    all_timeouts[id].fin_time = fin_time;
+   all_timeouts[id].interval_in_ms = interval_in_ms;
 
    insert_timeout(id, i);
 }
@@ -399,6 +402,29 @@ handle_sig_alarm(SIGNAL_ARGS)
                /* And call its handler function */
                this_timeout->timeout_handler();
 
+               /* If it should fire repeatedly, re-enable it. */
+               if (this_timeout->interval_in_ms > 0)
+               {
+                   TimestampTz new_fin_time;
+
+                   /*
+                    * To guard against drift, schedule the next instance of
+                    * the timeout based on the intended firing time rather
+                    * than the actual firing time. But if the timeout was so
+                    * late that we missed an entire cycle, fall back to
+                    * scheduling based on the actual firing time.
+                    */
+                   new_fin_time =
+                       TimestampTzPlusMilliseconds(this_timeout->fin_time,
+                                                   this_timeout->interval_in_ms);
+                   if (new_fin_time < now)
+                       new_fin_time =
+                           TimestampTzPlusMilliseconds(now,
+                                                       this_timeout->interval_in_ms);
+                   enable_timeout(this_timeout->index, now, new_fin_time,
+                                  this_timeout->interval_in_ms);
+               }
+
                /*
                 * The handler might not take negligible time (CheckDeadLock
                 * for instance isn't too cheap), so let's update our idea of
@@ -449,6 +475,7 @@ InitializeTimeouts(void)
        all_timeouts[i].timeout_handler = NULL;
        all_timeouts[i].start_time = 0;
        all_timeouts[i].fin_time = 0;
+       all_timeouts[i].interval_in_ms = 0;
    }
 
    all_timeouts_initialized = true;
@@ -532,7 +559,29 @@ enable_timeout_after(TimeoutId id, int delay_ms)
    /* Queue the timeout at the appropriate time. */
    now = GetCurrentTimestamp();
    fin_time = TimestampTzPlusMilliseconds(now, delay_ms);
-   enable_timeout(id, now, fin_time);
+   enable_timeout(id, now, fin_time, 0);
+
+   /* Set the timer interrupt. */
+   schedule_alarm(now);
+}
+
+/*
+ * Enable the specified timeout to fire periodically, with the specified
+ * delay as the time between firings.
+ *
+ * Delay is given in milliseconds.
+ */
+void
+enable_timeout_every(TimeoutId id, TimestampTz fin_time, int delay_ms)
+{
+   TimestampTz now;
+
+   /* Disable timeout interrupts for safety. */
+   disable_alarm();
+
+   /* Queue the timeout at the appropriate time. */
+   now = GetCurrentTimestamp();
+   enable_timeout(id, now, fin_time, delay_ms);
 
    /* Set the timer interrupt. */
    schedule_alarm(now);
@@ -555,7 +604,7 @@ enable_timeout_at(TimeoutId id, TimestampTz fin_time)
 
    /* Queue the timeout at the appropriate time. */
    now = GetCurrentTimestamp();
-   enable_timeout(id, now, fin_time);
+   enable_timeout(id, now, fin_time, 0);
 
    /* Set the timer interrupt. */
    schedule_alarm(now);
@@ -590,11 +639,17 @@ enable_timeouts(const EnableTimeoutParams *timeouts, int count)
            case TMPARAM_AFTER:
                fin_time = TimestampTzPlusMilliseconds(now,
                                                       timeouts[i].delay_ms);
-               enable_timeout(id, now, fin_time);
+               enable_timeout(id, now, fin_time, 0);
                break;
 
            case TMPARAM_AT:
-               enable_timeout(id, now, timeouts[i].fin_time);
+               enable_timeout(id, now, timeouts[i].fin_time, 0);
+               break;
+
+           case TMPARAM_EVERY:
+               fin_time = TimestampTzPlusMilliseconds(now,
+                                                      timeouts[i].delay_ms);
+               enable_timeout(id, now, fin_time, timeouts[i].delay_ms);
                break;
 
            default:

diff --git a/src/include/utils/timeout.h b/src/include/utils/timeout.h
index 93e6a691b3f36c30e54326527c25651922567861..1b13ac96e0e4788c35ecbdf78e928b39749a9167 100644 (file)
--- a/src/include/utils/timeout.h
+++ b/src/include/utils/timeout.h
@@ -48,14 +48,15 @@ typedef void (*timeout_handler_proc) (void);
 typedef enum TimeoutType
 {
    TMPARAM_AFTER,
-   TMPARAM_AT
+   TMPARAM_AT,
+   TMPARAM_EVERY
 } TimeoutType;
 
 typedef struct
 {
    TimeoutId   id;             /* timeout to set */
    TimeoutType type;           /* TMPARAM_AFTER or TMPARAM_AT */
-   int         delay_ms;       /* only used for TMPARAM_AFTER */
+   int         delay_ms;       /* only used for TMPARAM_AFTER/EVERY */
    TimestampTz fin_time;       /* only used for TMPARAM_AT */
 } EnableTimeoutParams;
 
@@ -75,6 +76,8 @@ extern void reschedule_timeouts(void);
 
 /* timeout operation */
 extern void enable_timeout_after(TimeoutId id, int delay_ms);
+extern void enable_timeout_every(TimeoutId id, TimestampTz fin_time,
+                                int delay_ms);
 extern void enable_timeout_at(TimeoutId id, TimestampTz fin_time);
 extern void enable_timeouts(const EnableTimeoutParams *timeouts, int count);
 extern void disable_timeout(TimeoutId id, bool keep_indicator);