Fix bogus comments.

diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c
index c028ab3dce260527790e67bdf4568472d977a145..a10dc3d8b2c9921b5d8ab0ab632d75bd3eba7426 100644 (file)
--- a/src/backend/replication/walsender.c
+++ b/src/backend/replication/walsender.c
@@ -30,7 +30,7 @@
  *
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/replication/walsender.c,v 1.2 2010/01/15 11:47:15 heikki Exp $
+ *       $PostgreSQL: pgsql/src/backend/replication/walsender.c,v 1.3 2010/01/21 08:19:57 heikki Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -602,7 +602,7 @@ XLogSend(StringInfo outMsg)
                sentPtr.xrecoff == 0)
                return true;
 
-       /* Attempt to send all the records which were written to the disk */
+       /* Attempt to send all records flushed to the disk already */
        SendRqstPtr = GetWriteRecPtr();
 
        /* Quick exit if nothing to do */
@@ -610,18 +610,10 @@ XLogSend(StringInfo outMsg)
                return true;
 
        /*
-        * Since successive pages in a segment are consecutively written,
-        * we can gather multiple records together by issuing just one
-        * read() call, and send them as one CopyData message at one time;
-        * nmsgs is the number of CopyData messages sent in this XLogSend;
-        * npages is the number of pages we have determined can be read and
-        * sent together; startpos is the starting position of reading and
-        * sending in the first page, startoff is the file offset at which
-        * it should go and endpos is the end position of reading and
-        * sending in the last page. We must initialize all of them to
-        * keep the compiler quiet.
+        * We gather multiple records together by issuing just one read() of
+        * a suitable size, and send them as one CopyData message. Repeat
+        * until we've sent everything we can.
         */
-
        while (XLByteLT(sentPtr, SendRqstPtr))
        {
                XLogRecPtr startptr;
@@ -631,31 +623,30 @@ XLogSend(StringInfo outMsg)
                /*
                 * Figure out how much to send in one message. If there's less than
                 * MAX_SEND_SIZE bytes to send, send everything. Otherwise send
-                * MAX_SEND_SIZE bytes, but round to page boundary for efficiency.
+                * MAX_SEND_SIZE bytes, but round to page boundary.
+                *
+                * The rounding is not only for performance reasons. Walreceiver
+                * relies on the fact that we never split a WAL record across two
+                * messages. Since a long WAL record is split at page boundary into
+                * continuation records, page boundary is alwayssafe cut-off point.
+                * We also assume that SendRqstPtr never points in the middle of a
+                * WAL record.
                 */
                startptr = sentPtr;
                endptr = startptr;
                XLByteAdvance(endptr, MAX_SEND_SIZE);
-
-               /*
-                * Round down to page boundary. This is not only for performance
-                * reasons, walreceiver relies on the fact that we never split a WAL
-                * record across two messages. Since a long WAL record is split at
-                * page boundary into continuation records, page boundary is always
-                * safe cut-off point. We also assume that SendRqstPtr never points
-                * in the middle of a WAL record.
-                */
+               /* round down to page boundary. */
                endptr.xrecoff -= (endptr.xrecoff % XLOG_BLCKSZ);
-
+               /* if we went beyond SendRqstPtr, back off */
                if (XLByteLT(SendRqstPtr, endptr))
                        endptr = SendRqstPtr;
 
                /*
-                * OK to read and send the log.
+                * OK to read and send the slice.
                 *
                 * We don't need to convert the xlogid/xrecoff from host byte order
                 * to network byte order because the both server can be expected to
-                * have the same byte order. If they have the different order, we
+                * have the same byte order. If they have different byte order, we
                 * don't reach here.
                 */
                pq_sendbytes(outMsg, (char *) &startptr, sizeof(startptr));
@@ -671,7 +662,7 @@ XLogSend(StringInfo outMsg)
                sentPtr = endptr;
 
                /*
-                * Read the log into the output buffer directly to prevent
+                * Read the log directly into the output buffer to prevent
                 * extra memcpy calls.
                 */
                enlargeStringInfo(outMsg, nbytes);