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);