Fix walsender timeouts when decoding a large transaction

The logical slots have a fast code path for sending data so as not to
impose too high a per message overhead. The fast path skips checks for
interrupts and timeouts. However, the existing coding failed to consider
the fact that a transaction with a large number of changes may take a
very long time to be processed and sent to the client. This causes the
walsender to ignore interrupts for potentially a long time and more
importantly it will result in the walsender being killed due to
timeout at the end of such a transaction.

This commit changes the fast path to also check for interrupts and only
allows calling the fast path when the last keepalive check happened less
than half the walsender timeout ago. Otherwise the slower code path will
be taken.

Backpatched to 9.4

Petr Jelinek, reviewed by  Kyotaro HORIGUCHI, Yura Sokolov,  Craig
Ringer and Robert Haas.

Discussion: https://postgr.es/m/e082a56a-fd95-a250-3bae-0fff93832510@2ndquadrant.com

diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index 9c320ff1edf44b85f138694ef32e5534cd356b26..4e06ffc6862d23ed7a7d4195671c488c591c6514 100644 (file)
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -1076,6 +1076,9 @@ static void
 WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid,
                                bool last_write)
 {
+       TimestampTz     now;
+       int64 now_int;
+
        /* output previously gathered data in a CopyData packet */
        pq_putmessage_noblock('d', ctx->out->data, ctx->out->len);
 
@@ -1085,23 +1088,54 @@ WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid,
         * several releases by streaming physical replication.
         */
        resetStringInfo(&tmpbuf);
-       pq_sendint64(&tmpbuf, GetCurrentIntegerTimestamp());
+       now_int = GetCurrentIntegerTimestamp();
+       now = IntegerTimestampToTimestampTz(now_int);
+       pq_sendint64(&tmpbuf, now_int);
        memcpy(&ctx->out->data[1 + sizeof(int64) + sizeof(int64)],
                   tmpbuf.data, sizeof(int64));
 
-       /* fast path */
+       CHECK_FOR_INTERRUPTS();
+
        /* Try to flush pending output to the client */
        if (pq_flush_if_writable() != 0)
                WalSndShutdown();
 
-       if (!pq_is_send_pending())
+       /* Try taking fast path unless we get too close to walsender timeout. */
+       if (now < TimestampTzPlusMilliseconds(last_reply_timestamp,
+                                                                                 wal_sender_timeout / 2) &&
+               !pq_is_send_pending())
+       {
                return;
+       }
 
+       /* If we have pending write here, go to slow path */
        for (;;)
        {
                int                     wakeEvents;
                long            sleeptime;
-               TimestampTz now;
+
+               /* Check for input from the client */
+               ProcessRepliesIfAny();
+
+               now = GetCurrentTimestamp();
+
+               /* die if timeout was reached */
+               WalSndCheckTimeOut(now);
+
+               /* Send keepalive if the time has come */
+               WalSndKeepaliveIfNecessary(now);
+
+               if (!pq_is_send_pending())
+                       break;
+
+               sleeptime = WalSndComputeSleeptime(now);
+
+               wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH |
+                       WL_SOCKET_WRITEABLE | WL_SOCKET_READABLE | WL_TIMEOUT;
+
+               /* Sleep until something happens or we time out */
+               WaitLatchOrSocket(MyLatch, wakeEvents,
+                                                 MyProcPort->sock, sleeptime);
 
                /*
                 * Emergency bailout if postmaster has died.  This is to avoid the
@@ -1123,33 +1157,9 @@ WalSndWriteData(LogicalDecodingContext *ctx, XLogRecPtr lsn, TransactionId xid,
                        SyncRepInitConfig();
                }
 
-               /* Check for input from the client */
-               ProcessRepliesIfAny();
-
                /* Try to flush pending output to the client */
                if (pq_flush_if_writable() != 0)
                        WalSndShutdown();
-
-               /* If we finished clearing the buffered data, we're done here. */
-               if (!pq_is_send_pending())
-                       break;
-
-               now = GetCurrentTimestamp();
-
-               /* die if timeout was reached */
-               WalSndCheckTimeOut(now);
-
-               /* Send keepalive if the time has come */
-               WalSndKeepaliveIfNecessary(now);
-
-               sleeptime = WalSndComputeSleeptime(now);
-
-               wakeEvents = WL_LATCH_SET | WL_POSTMASTER_DEATH |
-                       WL_SOCKET_WRITEABLE | WL_SOCKET_READABLE | WL_TIMEOUT;
-
-               /* Sleep until something happens or we time out */
-               WaitLatchOrSocket(MyLatch, wakeEvents,
-                                                 MyProcPort->sock, sleeptime);
        }
 
        /* reactivate latch so WalSndLoop knows to continue */