Content-Type: multipart/mixed; boundary="------------0orVPbvmYUlQ6quLDq0TER7P"
Message-ID: <9f7f4def-7ea8-4ad3-83e7-a8cc9d18c58a@wi3ck.info>
Date: Tue, 5 Nov 2024 08:58:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Commit Timestamp and LSN Inversion issue
To: Amit Kapila <amit.kapila16@gmail.com>,
 Aleksander Alekseev <aleksander@timescale.com>
Cc: pgsql-hackers <pgsql-hackers@postgresql.org>,
 shveta malik <shveta.malik@gmail.com>,
 "Zhijie Hou (Fujitsu)" <houzj.fnst@fujitsu.com>, tomas@vondra.me
References: <CAJpy0uBxEJnabEp3JS=n9X19Vx2ZK3k5AR7N0h-cSMtOwYV3fA@mail.gmail.com>
 <CAJ7c6TNZY3idBDoGOaoS_fF6vJuBMjnDhZC4i5V0J58s2SJ3AA@mail.gmail.com>
 <CAA4eK1LOmtMpmJAxsmN0yXJb-Q9vi6KThDYXdpVGL_WZW5ZgvQ@mail.gmail.com>
 <CAJ7c6TOcQPcydC7HW=xPEDN6_Ec7iSTP9j=1VTAeG=haguOQHw@mail.gmail.com>
 <CAA4eK1KhAxe6=VTxa6xEbc22_VVBLsVuvRH8Wxws8i50gH=eqw@mail.gmail.com>
Content-Language: en-US
From: Jan Wieck <jan@wi3ck.info>
In-Reply-To: <CAA4eK1KhAxe6=VTxa6xEbc22_VVBLsVuvRH8Wxws8i50gH=eqw@mail.gmail.com>
Archived-At: <https://www.postgresql.org/message-id/9f7f4def-7ea8-4ad3-83e7-a8cc9d18c58a%40wi3ck.info>
Precedence: bulk

This is a multi-part message in MIME format.
--------------0orVPbvmYUlQ6quLDq0TER7P
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit

Hi Hackers,

On 9/5/24 01:39, Amit Kapila wrote:
> On Wed, Sep 4, 2024 at 6:35 PM Aleksander Alekseev
> <aleksander@timescale.com> wrote:
>>
>> > > I don't think you can rely on a system clock for conflict resolution.
>> > > In a corner case a DBA can move the clock forward or backward between
>> > > recordings of Ts1 and Ts2. On top of that there is no guarantee that
>> > > 2+ servers have synchronised clocks. It seems to me that what you are
>> > > proposing will just hide the problem instead of solving it in the
>> > > general case.
>> > >
>> >
>> > It is possible that we can't rely on the system clock for conflict
>> > resolution but that is not the specific point of this thread. As
>> > mentioned in the subject of this thread, the problem is "Commit
>> > Timestamp and LSN Inversion issue". The LSN value and timestamp for a
>> > commit are not generated atomically, so two different transactions can
>> > have them in different order.
>>
>> Hm.... Then I'm having difficulties understanding why this is a
>> problem
> 
> This is a potential problem pointed out during discussion of CDR [1]
> (Please read the point starting from "How is this going to deal .."
> and response by Shveta). The point of this thread is that though it
> appears to be a problem but practically there is no scenario where it
> can impact even when we implement "last_write_wins" startegy as
> explained in the initial email. If you or someone sees a problem due
> to LSN<->timestamp inversion then we need to explore the solution for
> it.
> 
>>
>> and why it was necessary to mention CDR in this context in the
>> first place.
>>
>> OK, let's forget about CDR completely. Who is affected by the current
>> behavior and why would it be beneficial changing it?
>>
> 
> We can't forget CDR completely as this could only be a potential
> problem in that context. Right now, we don't have any built-in
> resolution strategies, so this can't impact but if this is a problem
> then we need to have a solution for it before considering a solution
> like "last_write_wins" strategy.

I agree that we can't forget about CDR. This is precisely the problem we 
ran into here at pgEdge and why we came up with a solution (attached).

> Now, instead of discussing LSN<->timestamp inversion issue, you
> started to discuss "last_write_wins" strategy itself which we have
> discussed to some extent in the thread [2]. BTW, we are planning to
> start a separate thread as well just to discuss the clock skew problem
> w.r.t resolution strategies like "last_write_wins" strategy. So, we
> can discuss clock skew in that thread and keep the focus of this
> thread LSN<->timestamp inversion problem.

Fact is that "last_write_wins" together with some implementation of 
Conflict free Replicated Data Types (CRDT) is good enough for many real 
world situations. Anything resembling a TPC-B or TPC-C is quite happy 
with it.

The attached solution is minimally invasive because it doesn't move the 
timestamp generation (clock_gettime() call) into the critical section of 
ReserveXLogInsertLocation() that is protected by a spinlock. Instead it 
keeps track of the last commit-ts written to WAL in shared memory and 
simply bumps that by one microsecond if the next one is below or equal. 
There is one extra condition in that code section plus a function call 
by pointer for every WAL record. In the unlikely case of encountering a 
stalled or backwards running commit-ts, the expensive part of 
recalculating the CRC of the altered commit WAL-record is done later, 
after releasing the spinlock. I have not been able to measure any 
performance impact on a machine with 2x Xeon-Silver (32 HT cores).

This will work fine until we have systems that can sustain a commit rate 
of one million transactions per second or higher for more than a few 
milliseconds.


Regards, Jan


--------------0orVPbvmYUlQ6quLDq0TER7P
Content-Type: text/x-patch; charset=UTF-8;
 name="pg18-025-logical_commit_clock.diff"
Content-Disposition: attachment; filename="pg18-025-logical_commit_clock.diff"
Content-Transfer-Encoding: base64
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--------------0orVPbvmYUlQ6quLDq0TER7P--