From d8b1e82bab1ee51b416956b241e824f0b1d125e8 Mon Sep 17 00:00:00 2001 From: Yura Sokolov Date: Sun, 19 Jan 2025 17:40:28 +0300 Subject: [PATCH] Dumb lock-free XLog Reservation without xl_prev --- src/backend/access/transam/xlog.c | 106 ++++++++++-------------- src/backend/access/transam/xlogreader.c | 2 +- 2 files changed, 47 insertions(+), 61 deletions(-) diff --git a/src/backend/access/transam/xlog.c b/src/backend/access/transam/xlog.c index bf3dbda901d..d45e6408268 100644 --- a/src/backend/access/transam/xlog.c +++ b/src/backend/access/transam/xlog.c @@ -395,17 +395,18 @@ static SessionBackupState sessionBackupState = SESSION_BACKUP_NONE; */ typedef struct XLogCtlInsert { - slock_t insertpos_lck; /* protects CurrBytePos and PrevBytePos */ - /* * CurrBytePos is the end of reserved WAL. The next record will be - * inserted at that position. PrevBytePos is the start position of the - * previously inserted (or rather, reserved) record - it is copied to the - * prev-link of the next record. These are stored as "usable byte - * positions" rather than XLogRecPtrs (see XLogBytePosToRecPtr()). + * inserted at that position. + * + * The start position of the previously inserted (or rather, reserved) + * record (it is copied to the prev-link of the next record) will be + * stored in PrevLinksHash. + * + * These are stored as "usable byte positions" rather than XLogRecPtrs + * (see XLogBytePosToRecPtr()). */ - uint64 CurrBytePos; - uint64 PrevBytePos; + pg_atomic_uint64 CurrBytePos; /* * Make sure the above heavily-contended spinlock and byte positions are @@ -715,6 +716,12 @@ static void WALInsertLockAcquireExclusive(void); static void WALInsertLockRelease(void); static void WALInsertLockUpdateInsertingAt(XLogRecPtr insertingAt); +static inline XLogRecPtr +ReadInsertCurrBytePos(void) +{ + return pg_atomic_read_u64(&XLogCtl->Insert.CurrBytePos); +} + /* * Insert an XLOG record represented by an already-constructed chain of data * chunks. This is a low-level routine; to construct the WAL record header @@ -1111,36 +1118,18 @@ ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogCtlInsert *Insert = &XLogCtl->Insert; uint64 startbytepos; uint64 endbytepos; - uint64 prevbytepos; size = MAXALIGN(size); /* All (non xlog-switch) records should contain data. */ Assert(size > SizeOfXLogRecord); - /* - * The duration the spinlock needs to be held is minimized by minimizing - * the calculations that have to be done while holding the lock. The - * current tip of reserved WAL is kept in CurrBytePos, as a byte position - * that only counts "usable" bytes in WAL, that is, it excludes all WAL - * page headers. The mapping between "usable" byte positions and physical - * positions (XLogRecPtrs) can be done outside the locked region, and - * because the usable byte position doesn't include any headers, reserving - * X bytes from WAL is almost as simple as "CurrBytePos += X". - */ - SpinLockAcquire(&Insert->insertpos_lck); - - startbytepos = Insert->CurrBytePos; + startbytepos = pg_atomic_fetch_add_u64(&Insert->CurrBytePos, size); endbytepos = startbytepos + size; - prevbytepos = Insert->PrevBytePos; - Insert->CurrBytePos = endbytepos; - Insert->PrevBytePos = startbytepos; - - SpinLockRelease(&Insert->insertpos_lck); *StartPos = XLogBytePosToRecPtr(startbytepos); *EndPos = XLogBytePosToEndRecPtr(endbytepos); - *PrevPtr = XLogBytePosToRecPtr(prevbytepos); + *PrevPtr = *StartPos - 1; /* * Check that the conversions between "usable byte positions" and @@ -1148,7 +1137,6 @@ ReserveXLogInsertLocation(int size, XLogRecPtr *StartPos, XLogRecPtr *EndPos, */ Assert(XLogRecPtrToBytePos(*StartPos) == startbytepos); Assert(XLogRecPtrToBytePos(*EndPos) == endbytepos); - Assert(XLogRecPtrToBytePos(*PrevPtr) == prevbytepos); } /* @@ -1166,32 +1154,29 @@ ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr) XLogCtlInsert *Insert = &XLogCtl->Insert; uint64 startbytepos; uint64 endbytepos; - uint64 prevbytepos; uint32 size = MAXALIGN(SizeOfXLogRecord); XLogRecPtr ptr; uint32 segleft; /* - * These calculations are a bit heavy-weight to be done while holding a - * spinlock, but since we're holding all the WAL insertion locks, there - * are no other inserters competing for it. GetXLogInsertRecPtr() does - * compete for it, but that's not called very frequently. + * Currently ReserveXLogInsertLocation is protected with exclusive + * insertion lock, so there is no contention against CurrBytePos, But we + * still do CAS loop for being uniform. + * + * Probably we'll get rid of exclusive lock in a future. */ - SpinLockAcquire(&Insert->insertpos_lck); - startbytepos = Insert->CurrBytePos; +repeat: + startbytepos = pg_atomic_read_u64(&Insert->CurrBytePos); ptr = XLogBytePosToEndRecPtr(startbytepos); if (XLogSegmentOffset(ptr, wal_segment_size) == 0) { - SpinLockRelease(&Insert->insertpos_lck); *EndPos = *StartPos = ptr; return false; } endbytepos = startbytepos + size; - prevbytepos = Insert->PrevBytePos; - *StartPos = XLogBytePosToRecPtr(startbytepos); *EndPos = XLogBytePosToEndRecPtr(endbytepos); @@ -1202,17 +1187,24 @@ ReserveXLogSwitch(XLogRecPtr *StartPos, XLogRecPtr *EndPos, XLogRecPtr *PrevPtr) *EndPos += segleft; endbytepos = XLogRecPtrToBytePos(*EndPos); } - Insert->CurrBytePos = endbytepos; - Insert->PrevBytePos = startbytepos; - SpinLockRelease(&Insert->insertpos_lck); + if (!pg_atomic_compare_exchange_u64(&Insert->CurrBytePos, + &startbytepos, + endbytepos)) + { + /* + * Don't use spin delay here: perform_spin_delay primary case is for + * solving single core contention. But on single core we will succeed + * on the next attempt. + */ + goto repeat; + } - *PrevPtr = XLogBytePosToRecPtr(prevbytepos); + *PrevPtr = *StartPos - 1; Assert(XLogSegmentOffset(*EndPos, wal_segment_size) == 0); Assert(XLogRecPtrToBytePos(*EndPos) == endbytepos); Assert(XLogRecPtrToBytePos(*StartPos) == startbytepos); - Assert(XLogRecPtrToBytePos(*PrevPtr) == prevbytepos); return true; } @@ -1507,7 +1499,6 @@ WaitXLogInsertionsToFinish(XLogRecPtr upto) XLogRecPtr inserted; XLogRecPtr reservedUpto; XLogRecPtr finishedUpto; - XLogCtlInsert *Insert = &XLogCtl->Insert; int i; if (MyProc == NULL) @@ -1522,9 +1513,7 @@ WaitXLogInsertionsToFinish(XLogRecPtr upto) return inserted; /* Read the current insert position */ - SpinLockAcquire(&Insert->insertpos_lck); - bytepos = Insert->CurrBytePos; - SpinLockRelease(&Insert->insertpos_lck); + bytepos = ReadInsertCurrBytePos(); reservedUpto = XLogBytePosToEndRecPtr(bytepos); /* @@ -5017,12 +5006,13 @@ XLOGShmemInit(void) XLogCtl->InstallXLogFileSegmentActive = false; XLogCtl->WalWriterSleeping = false; - SpinLockInit(&XLogCtl->Insert.insertpos_lck); SpinLockInit(&XLogCtl->info_lck); pg_atomic_init_u64(&XLogCtl->logInsertResult, InvalidXLogRecPtr); pg_atomic_init_u64(&XLogCtl->logWriteResult, InvalidXLogRecPtr); pg_atomic_init_u64(&XLogCtl->logFlushResult, InvalidXLogRecPtr); pg_atomic_init_u64(&XLogCtl->unloggedLSN, InvalidXLogRecPtr); + + pg_atomic_init_u64(&XLogCtl->Insert.CurrBytePos, 0); } /* @@ -6018,8 +6008,11 @@ StartupXLOG(void) * previous incarnation. */ Insert = &XLogCtl->Insert; - Insert->PrevBytePos = XLogRecPtrToBytePos(endOfRecoveryInfo->lastRec); - Insert->CurrBytePos = XLogRecPtrToBytePos(EndOfLog); + { + XLogRecPtr endOfLog = XLogRecPtrToBytePos(EndOfLog); + + pg_atomic_write_u64(&Insert->CurrBytePos, endOfLog); + } /* * Tricky point here: lastPage contains the *last* block that the LastRec @@ -7005,7 +6998,7 @@ CreateCheckPoint(int flags) if (shutdown) { - XLogRecPtr curInsert = XLogBytePosToRecPtr(Insert->CurrBytePos); + XLogRecPtr curInsert = XLogBytePosToRecPtr(ReadInsertCurrBytePos()); /* * Compute new REDO record ptr = location of next XLOG record. @@ -9434,14 +9427,7 @@ register_persistent_abort_backup_handler(void) XLogRecPtr GetXLogInsertRecPtr(void) { - XLogCtlInsert *Insert = &XLogCtl->Insert; - uint64 current_bytepos; - - SpinLockAcquire(&Insert->insertpos_lck); - current_bytepos = Insert->CurrBytePos; - SpinLockRelease(&Insert->insertpos_lck); - - return XLogBytePosToRecPtr(current_bytepos); + return XLogBytePosToRecPtr(ReadInsertCurrBytePos()); } /* diff --git a/src/backend/access/transam/xlogreader.c b/src/backend/access/transam/xlogreader.c index 3596af06172..0851b62af93 100644 --- a/src/backend/access/transam/xlogreader.c +++ b/src/backend/access/transam/xlogreader.c @@ -1165,7 +1165,7 @@ ValidXLogRecordHeader(XLogReaderState *state, XLogRecPtr RecPtr, * check guards against torn WAL pages where a stale but valid-looking * WAL record starts on a sector boundary. */ - if (record->xl_prev != PrevRecPtr) + if (false && record->xl_prev != PrevRecPtr) { report_invalid_record(state, "record with incorrect prev-link %X/%X at %X/%X", -- 2.43.0