mirror of https://github.com/postgres/postgres
least-recently-used strategy from clog.c into slru.c. It doesn't change any visible behaviour and passes all regression tests plus a TruncateCLOG test done manually. Apart from refactoring I made a little change to SlruRecentlyUsed, formerly ClogRecentlyUsed: It now skips incrementing lru_counts, if slotno is already the LRU slot, thus saving a few CPU cycles. To make this work, lru_counts are initialised to 1 in SimpleLruInit. SimpleLru will be used by pg_subtrans (part of the nested transactions project), so the main purpose of this patch is to avoid future code duplication. Manfred KoizarWIN32_DEV
Bruce Momjian
22 years ago
parent
240dc5cddc
commit
0abe7431c6
@ -0,0 +1,886 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* slru.c |
||||||
|
* Simple LRU |
||||||
|
* |
||||||
|
* This module replaces the old "pg_log" access code, which treated pg_log |
||||||
|
* essentially like a relation, in that it went through the regular buffer |
||||||
|
* manager. The problem with that was that there wasn't any good way to |
||||||
|
* recycle storage space for transactions so old that they'll never be |
||||||
|
* looked up again. Now we use specialized access code so that the commit |
||||||
|
* log can be broken into relatively small, independent segments. |
||||||
|
* |
||||||
|
* Portions Copyright (c) 2003, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* $Header: /cvsroot/pgsql/src/backend/access/transam/slru.c,v 1.1 2003/06/11 22:37:45 momjian Exp $ |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
#include "postgres.h" |
||||||
|
|
||||||
|
#include <fcntl.h> |
||||||
|
#include <dirent.h> |
||||||
|
#include <errno.h> |
||||||
|
#include <sys/stat.h> |
||||||
|
#include <unistd.h> |
||||||
|
|
||||||
|
#include "access/slru.h" |
||||||
|
#include "storage/lwlock.h" |
||||||
|
#include "miscadmin.h" |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Define segment size. A page is the same BLCKSZ as is used everywhere |
||||||
|
* else in Postgres. The segment size can be chosen somewhat arbitrarily; |
||||||
|
* we make it 32 pages by default, or 256Kb, i.e. 1M transactions for CLOG |
||||||
|
* or 64K transactions for SUBTRANS. |
||||||
|
* |
||||||
|
* Note: because TransactionIds are 32 bits and wrap around at 0xFFFFFFFF, |
||||||
|
* page numbering also wraps around at 0xFFFFFFFF/xxxx_XACTS_PER_PAGE (where |
||||||
|
* xxxx is CLOG or SUBTRANS, respectively), and segment numbering at |
||||||
|
* 0xFFFFFFFF/xxxx_XACTS_PER_PAGE/SLRU_PAGES_PER_SEGMENT. We need |
||||||
|
* take no explicit notice of that fact in this module, except when comparing |
||||||
|
* segment and page numbers in SimpleLruTruncate (see PagePrecedes()). |
||||||
|
*/ |
||||||
|
|
||||||
|
#define SLRU_PAGES_PER_SEGMENT 32 |
||||||
|
|
||||||
|
|
||||||
|
/*----------
|
||||||
|
* Shared-memory data structures for SLRU control |
||||||
|
* |
||||||
|
* We use a simple least-recently-used scheme to manage a pool of page |
||||||
|
* buffers. Under ordinary circumstances we expect that write |
||||||
|
* traffic will occur mostly to the latest page (and to the just-prior |
||||||
|
* page, soon after a page transition). Read traffic will probably touch |
||||||
|
* a larger span of pages, but in any case a fairly small number of page |
||||||
|
* buffers should be sufficient. So, we just search the buffers using plain |
||||||
|
* linear search; there's no need for a hashtable or anything fancy. |
||||||
|
* The management algorithm is straight LRU except that we will never swap |
||||||
|
* out the latest page (since we know it's going to be hit again eventually). |
||||||
|
* |
||||||
|
* We use a control LWLock to protect the shared data structures, plus |
||||||
|
* per-buffer LWLocks that synchronize I/O for each buffer. A process |
||||||
|
* that is reading in or writing out a page buffer does not hold the control |
||||||
|
* lock, only the per-buffer lock for the buffer it is working on. |
||||||
|
* |
||||||
|
* To change the page number or state of a buffer, one must normally hold |
||||||
|
* the control lock. (The sole exception to this rule is that a writer |
||||||
|
* process changes the state from DIRTY to WRITE_IN_PROGRESS while holding |
||||||
|
* only the per-buffer lock.) If the buffer's state is neither EMPTY nor |
||||||
|
* CLEAN, then there may be processes doing (or waiting to do) I/O on the |
||||||
|
* buffer, so the page number may not be changed, and the only allowed state |
||||||
|
* transition is to change WRITE_IN_PROGRESS to DIRTY after dirtying the page. |
||||||
|
* To do any other state transition involving a buffer with potential I/O |
||||||
|
* processes, one must hold both the per-buffer lock and the control lock. |
||||||
|
* (Note the control lock must be acquired second; do not wait on a buffer |
||||||
|
* lock while holding the control lock.) A process wishing to read a page |
||||||
|
* marks the buffer state as READ_IN_PROGRESS, then drops the control lock, |
||||||
|
* acquires the per-buffer lock, and rechecks the state before proceeding. |
||||||
|
* This recheck takes care of the possibility that someone else already did |
||||||
|
* the read, while the early marking prevents someone else from trying to |
||||||
|
* read the same page into a different buffer. |
||||||
|
* |
||||||
|
* Note we are assuming that read and write of the state value is atomic, |
||||||
|
* since I/O processes may examine and change the state while not holding |
||||||
|
* the control lock. |
||||||
|
* |
||||||
|
* As with the regular buffer manager, it is possible for another process |
||||||
|
* to re-dirty a page that is currently being written out. This is handled |
||||||
|
* by setting the page's state from WRITE_IN_PROGRESS to DIRTY. The writing |
||||||
|
* process must notice this and not mark the page CLEAN when it's done. |
||||||
|
*---------- |
||||||
|
*/ |
||||||
|
|
||||||
|
typedef enum |
||||||
|
{ |
||||||
|
SLRU_PAGE_EMPTY, /* buffer is not in use */ |
||||||
|
SLRU_PAGE_READ_IN_PROGRESS, /* page is being read in */ |
||||||
|
SLRU_PAGE_CLEAN, /* page is valid and not dirty */ |
||||||
|
SLRU_PAGE_DIRTY, /* page is valid but needs write */ |
||||||
|
SLRU_PAGE_WRITE_IN_PROGRESS /* page is being written out */ |
||||||
|
} SlruPageStatus; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Shared-memory state |
||||||
|
*/ |
||||||
|
typedef struct SlruSharedData |
||||||
|
{ |
||||||
|
/*
|
||||||
|
* Info for each buffer slot. Page number is undefined when status is |
||||||
|
* EMPTY. lru_count is essentially the number of page switches since |
||||||
|
* last use of this page; the page with highest lru_count is the best |
||||||
|
* candidate to replace. |
||||||
|
*/ |
||||||
|
char *page_buffer[NUM_CLOG_BUFFERS]; |
||||||
|
SlruPageStatus page_status[NUM_CLOG_BUFFERS]; |
||||||
|
int page_number[NUM_CLOG_BUFFERS]; |
||||||
|
unsigned int page_lru_count[NUM_CLOG_BUFFERS]; |
||||||
|
|
||||||
|
/*
|
||||||
|
* latest_page_number is the page number of the current end of the |
||||||
|
* CLOG; this is not critical data, since we use it only to avoid |
||||||
|
* swapping out the latest page. |
||||||
|
*/ |
||||||
|
int latest_page_number; |
||||||
|
} SlruSharedData; |
||||||
|
typedef SlruSharedData *SlruShared; |
||||||
|
|
||||||
|
|
||||||
|
#define SlruFileName(ctl, path, seg) \ |
||||||
|
snprintf(path, MAXPGPATH, "%s/%04X", (ctl)->Dir, seg) |
||||||
|
|
||||||
|
/*
|
||||||
|
* Macro to mark a buffer slot "most recently used". |
||||||
|
*/ |
||||||
|
#define SlruRecentlyUsed(shared, slotno) \ |
||||||
|
do { \
|
||||||
|
if ((shared)->page_lru_count[slotno] != 0) { \
|
||||||
|
int iilru; \
|
||||||
|
for (iilru = 0; iilru < NUM_CLOG_BUFFERS; iilru++) \
|
||||||
|
(shared)->page_lru_count[iilru]++; \
|
||||||
|
(shared)->page_lru_count[slotno] = 0; \
|
||||||
|
} \
|
||||||
|
} while (0) |
||||||
|
|
||||||
|
/* Saved info for SlruReportIOError */ |
||||||
|
typedef enum |
||||||
|
{ |
||||||
|
SLRU_OPEN_FAILED, |
||||||
|
SLRU_CREATE_FAILED, |
||||||
|
SLRU_SEEK_FAILED, |
||||||
|
SLRU_READ_FAILED, |
||||||
|
SLRU_WRITE_FAILED |
||||||
|
} SlruErrorCause; |
||||||
|
static SlruErrorCause slru_errcause; |
||||||
|
static int slru_errno; |
||||||
|
|
||||||
|
|
||||||
|
static bool SlruPhysicalReadPage(SlruCtl ctl, int pageno, int slotno); |
||||||
|
static bool SlruPhysicalWritePage(SlruCtl ctl, int pageno, int slotno); |
||||||
|
static void SlruReportIOError(SlruCtl ctl, int pageno, TransactionId xid); |
||||||
|
static int SlruSelectLRUPage(SlruCtl ctl, int pageno); |
||||||
|
static bool SlruScanDirectory(SlruCtl ctl, int cutoffPage, bool doDeletions); |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Initialization of shared memory |
||||||
|
*/ |
||||||
|
|
||||||
|
int |
||||||
|
SimpleLruShmemSize(void) |
||||||
|
{ |
||||||
|
return MAXALIGN(sizeof(SlruSharedData)) + BLCKSZ * NUM_CLOG_BUFFERS |
||||||
|
#ifdef EXEC_BACKEND |
||||||
|
+ MAXALIGN(sizeof(SlruLockData)) |
||||||
|
#endif |
||||||
|
; |
||||||
|
} |
||||||
|
|
||||||
|
void |
||||||
|
SimpleLruInit(SlruCtl ctl, const char *name, const char *subdir) |
||||||
|
{ |
||||||
|
bool found; |
||||||
|
char *ptr; |
||||||
|
SlruShared shared; |
||||||
|
SlruLock locks; |
||||||
|
|
||||||
|
ptr = ShmemInitStruct(name, SimpleLruShmemSize(), &found); |
||||||
|
shared = (SlruShared) ptr; |
||||||
|
|
||||||
|
#ifdef EXEC_BACKEND |
||||||
|
/*
|
||||||
|
* Locks are in shared memory |
||||||
|
*/ |
||||||
|
locks = (SlruLock)(ptr + MAXALIGN(sizeof(SlruSharedData)) + |
||||||
|
BLCKSZ * NUM_CLOG_BUFFERS); |
||||||
|
#else |
||||||
|
/*
|
||||||
|
* Locks are in private memory |
||||||
|
*/ |
||||||
|
Assert(!IsUnderPostmaster); |
||||||
|
locks = malloc(sizeof(SlruLockData)); |
||||||
|
Assert(locks); |
||||||
|
#endif |
||||||
|
|
||||||
|
|
||||||
|
if (!IsUnderPostmaster) |
||||||
|
/* Initialize locks and shared memory area */ |
||||||
|
{ |
||||||
|
char *bufptr; |
||||||
|
int slotno; |
||||||
|
|
||||||
|
Assert(!found); |
||||||
|
|
||||||
|
locks->ControlLock = LWLockAssign(); |
||||||
|
|
||||||
|
memset(shared, 0, sizeof(SlruSharedData)); |
||||||
|
|
||||||
|
bufptr = (char *)shared + MAXALIGN(sizeof(SlruSharedData)); |
||||||
|
|
||||||
|
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++) |
||||||
|
{ |
||||||
|
locks->BufferLocks[slotno] = LWLockAssign(); |
||||||
|
shared->page_buffer[slotno] = bufptr; |
||||||
|
shared->page_status[slotno] = SLRU_PAGE_EMPTY; |
||||||
|
shared->page_lru_count[slotno] = 1; |
||||||
|
bufptr += BLCKSZ; |
||||||
|
} |
||||||
|
|
||||||
|
/* shared->latest_page_number will be set later */ |
||||||
|
} |
||||||
|
else |
||||||
|
Assert(found); |
||||||
|
|
||||||
|
|
||||||
|
ctl->locks = locks; |
||||||
|
ctl->shared = shared; |
||||||
|
|
||||||
|
|
||||||
|
/* Init directory path */ |
||||||
|
snprintf(ctl->Dir, MAXPGPATH, "%s/%s", DataDir, subdir); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Initialize (or reinitialize) a page to zeroes. |
||||||
|
* |
||||||
|
* The page is not actually written, just set up in shared memory. |
||||||
|
* The slot number of the new page is returned. |
||||||
|
* |
||||||
|
* Control lock must be held at entry, and will be held at exit. |
||||||
|
*/ |
||||||
|
int |
||||||
|
SimpleLruZeroPage(SlruCtl ctl, int pageno) |
||||||
|
{ |
||||||
|
int slotno; |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
|
||||||
|
/* Find a suitable buffer slot for the page */ |
||||||
|
slotno = SlruSelectLRUPage(ctl, pageno); |
||||||
|
Assert(shared->page_status[slotno] == SLRU_PAGE_EMPTY || |
||||||
|
shared->page_status[slotno] == SLRU_PAGE_CLEAN || |
||||||
|
shared->page_number[slotno] == pageno); |
||||||
|
|
||||||
|
/* Mark the slot as containing this page */ |
||||||
|
shared->page_number[slotno] = pageno; |
||||||
|
shared->page_status[slotno] = SLRU_PAGE_DIRTY; |
||||||
|
SlruRecentlyUsed(shared, slotno); |
||||||
|
|
||||||
|
/* Set the buffer to zeroes */ |
||||||
|
MemSet(shared->page_buffer[slotno], 0, BLCKSZ); |
||||||
|
|
||||||
|
/* Assume this page is now the latest active page */ |
||||||
|
shared->latest_page_number = pageno; |
||||||
|
|
||||||
|
return slotno; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Find a page in a shared buffer, reading it in if necessary. |
||||||
|
* The page number must correspond to an already-initialized page. |
||||||
|
* |
||||||
|
* The passed-in xid is used only for error reporting, and may be |
||||||
|
* InvalidTransactionId if no specific xid is associated with the action. |
||||||
|
* |
||||||
|
* Return value is the shared-buffer address of the page. |
||||||
|
* The buffer's LRU access info is updated. |
||||||
|
* If forwrite is true, the buffer is marked as dirty. |
||||||
|
* |
||||||
|
* Control lock must be held at entry, and will be held at exit. |
||||||
|
*/ |
||||||
|
char * |
||||||
|
SimpleLruReadPage(SlruCtl ctl, int pageno, TransactionId xid, bool forwrite) |
||||||
|
{ |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
|
||||||
|
/* Outer loop handles restart if we lose the buffer to someone else */ |
||||||
|
for (;;) |
||||||
|
{ |
||||||
|
int slotno; |
||||||
|
bool ok; |
||||||
|
|
||||||
|
/* See if page already is in memory; if not, pick victim slot */ |
||||||
|
slotno = SlruSelectLRUPage(ctl, pageno); |
||||||
|
|
||||||
|
/* Did we find the page in memory? */ |
||||||
|
if (shared->page_number[slotno] == pageno && |
||||||
|
shared->page_status[slotno] != SLRU_PAGE_EMPTY) |
||||||
|
{ |
||||||
|
/* If page is still being read in, we cannot use it yet */ |
||||||
|
if (shared->page_status[slotno] != SLRU_PAGE_READ_IN_PROGRESS) |
||||||
|
{ |
||||||
|
/* otherwise, it's ready to use */ |
||||||
|
SlruRecentlyUsed(shared, slotno); |
||||||
|
if (forwrite) |
||||||
|
shared->page_status[slotno] = SLRU_PAGE_DIRTY; |
||||||
|
return shared->page_buffer[slotno]; |
||||||
|
} |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
/* We found no match; assert we selected a freeable slot */ |
||||||
|
Assert(shared->page_status[slotno] == SLRU_PAGE_EMPTY || |
||||||
|
shared->page_status[slotno] == SLRU_PAGE_CLEAN); |
||||||
|
} |
||||||
|
|
||||||
|
/* Mark the slot read-busy (no-op if it already was) */ |
||||||
|
shared->page_number[slotno] = pageno; |
||||||
|
shared->page_status[slotno] = SLRU_PAGE_READ_IN_PROGRESS; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Temporarily mark page as recently-used to discourage |
||||||
|
* SlruSelectLRUPage from selecting it again for someone else. |
||||||
|
*/ |
||||||
|
SlruRecentlyUsed(shared, slotno); |
||||||
|
|
||||||
|
/* Release shared lock, grab per-buffer lock instead */ |
||||||
|
LWLockRelease(ctl->locks->ControlLock); |
||||||
|
LWLockAcquire(ctl->locks->BufferLocks[slotno], LW_EXCLUSIVE); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Check to see if someone else already did the read, or took the |
||||||
|
* buffer away from us. If so, restart from the top. |
||||||
|
*/ |
||||||
|
if (shared->page_number[slotno] != pageno || |
||||||
|
shared->page_status[slotno] != SLRU_PAGE_READ_IN_PROGRESS) |
||||||
|
{ |
||||||
|
LWLockRelease(ctl->locks->BufferLocks[slotno]); |
||||||
|
LWLockAcquire(ctl->locks->ControlLock, LW_EXCLUSIVE); |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
/* Okay, do the read */ |
||||||
|
ok = SlruPhysicalReadPage(ctl, pageno, slotno); |
||||||
|
|
||||||
|
/* Re-acquire shared control lock and update page state */ |
||||||
|
LWLockAcquire(ctl->locks->ControlLock, LW_EXCLUSIVE); |
||||||
|
|
||||||
|
Assert(shared->page_number[slotno] == pageno && |
||||||
|
shared->page_status[slotno] == SLRU_PAGE_READ_IN_PROGRESS); |
||||||
|
|
||||||
|
shared->page_status[slotno] = ok ? SLRU_PAGE_CLEAN : SLRU_PAGE_EMPTY; |
||||||
|
|
||||||
|
LWLockRelease(ctl->locks->BufferLocks[slotno]); |
||||||
|
|
||||||
|
/* Now it's okay to elog if we failed */ |
||||||
|
if (!ok) |
||||||
|
SlruReportIOError(ctl, pageno, xid); |
||||||
|
|
||||||
|
SlruRecentlyUsed(shared, slotno); |
||||||
|
if (forwrite) |
||||||
|
shared->page_status[slotno] = SLRU_PAGE_DIRTY; |
||||||
|
return shared->page_buffer[slotno]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Write a page from a shared buffer, if necessary. |
||||||
|
* Does nothing if the specified slot is not dirty. |
||||||
|
* |
||||||
|
* NOTE: only one write attempt is made here. Hence, it is possible that |
||||||
|
* the page is still dirty at exit (if someone else re-dirtied it during |
||||||
|
* the write). However, we *do* attempt a fresh write even if the page |
||||||
|
* is already being written; this is for checkpoints. |
||||||
|
* |
||||||
|
* Control lock must be held at entry, and will be held at exit. |
||||||
|
*/ |
||||||
|
void |
||||||
|
SimpleLruWritePage(SlruCtl ctl, int slotno) |
||||||
|
{ |
||||||
|
int pageno; |
||||||
|
bool ok; |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
|
||||||
|
/* Do nothing if page does not need writing */ |
||||||
|
if (shared->page_status[slotno] != SLRU_PAGE_DIRTY && |
||||||
|
shared->page_status[slotno] != SLRU_PAGE_WRITE_IN_PROGRESS) |
||||||
|
return; |
||||||
|
|
||||||
|
pageno = shared->page_number[slotno]; |
||||||
|
|
||||||
|
/* Release shared lock, grab per-buffer lock instead */ |
||||||
|
LWLockRelease(ctl->locks->ControlLock); |
||||||
|
LWLockAcquire(ctl->locks->BufferLocks[slotno], LW_EXCLUSIVE); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Check to see if someone else already did the write, or took the |
||||||
|
* buffer away from us. If so, do nothing. NOTE: we really should |
||||||
|
* never see WRITE_IN_PROGRESS here, since that state should only |
||||||
|
* occur while the writer is holding the buffer lock. But accept it |
||||||
|
* so that we have a recovery path if a writer aborts. |
||||||
|
*/ |
||||||
|
if (shared->page_number[slotno] != pageno || |
||||||
|
(shared->page_status[slotno] != SLRU_PAGE_DIRTY && |
||||||
|
shared->page_status[slotno] != SLRU_PAGE_WRITE_IN_PROGRESS)) |
||||||
|
{ |
||||||
|
LWLockRelease(ctl->locks->BufferLocks[slotno]); |
||||||
|
LWLockAcquire(ctl->locks->ControlLock, LW_EXCLUSIVE); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Mark the slot write-busy. After this point, a transaction status |
||||||
|
* update on this page will mark it dirty again. NB: we are assuming |
||||||
|
* that read/write of the page status field is atomic, since we change |
||||||
|
* the state while not holding control lock. However, we cannot set |
||||||
|
* this state any sooner, or we'd possibly fool a previous writer into |
||||||
|
* thinking he's successfully dumped the page when he hasn't. |
||||||
|
* (Scenario: other writer starts, page is redirtied, we come along |
||||||
|
* and set WRITE_IN_PROGRESS again, other writer completes and sets |
||||||
|
* CLEAN because redirty info has been lost, then we think it's clean |
||||||
|
* too.) |
||||||
|
*/ |
||||||
|
shared->page_status[slotno] = SLRU_PAGE_WRITE_IN_PROGRESS; |
||||||
|
|
||||||
|
/* Okay, do the write */ |
||||||
|
ok = SlruPhysicalWritePage(ctl, pageno, slotno); |
||||||
|
|
||||||
|
/* Re-acquire shared control lock and update page state */ |
||||||
|
LWLockAcquire(ctl->locks->ControlLock, LW_EXCLUSIVE); |
||||||
|
|
||||||
|
Assert(shared->page_number[slotno] == pageno && |
||||||
|
(shared->page_status[slotno] == SLRU_PAGE_WRITE_IN_PROGRESS || |
||||||
|
shared->page_status[slotno] == SLRU_PAGE_DIRTY)); |
||||||
|
|
||||||
|
/* Cannot set CLEAN if someone re-dirtied page since write started */ |
||||||
|
if (shared->page_status[slotno] == SLRU_PAGE_WRITE_IN_PROGRESS) |
||||||
|
shared->page_status[slotno] = ok ? SLRU_PAGE_CLEAN : SLRU_PAGE_DIRTY; |
||||||
|
|
||||||
|
LWLockRelease(ctl->locks->BufferLocks[slotno]); |
||||||
|
|
||||||
|
/* Now it's okay to elog if we failed */ |
||||||
|
if (!ok) |
||||||
|
SlruReportIOError(ctl, pageno, InvalidTransactionId); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Physical read of a (previously existing) page into a buffer slot |
||||||
|
* |
||||||
|
* On failure, we cannot just elog(ERROR) since caller has put state in |
||||||
|
* shared memory that must be undone. So, we return FALSE and save enough |
||||||
|
* info in static variables to let SlruReportIOError make the report. |
||||||
|
* |
||||||
|
* For now, assume it's not worth keeping a file pointer open across |
||||||
|
* read/write operations. We could cache one virtual file pointer ... |
||||||
|
*/ |
||||||
|
static bool |
||||||
|
SlruPhysicalReadPage(SlruCtl ctl, int pageno, int slotno) |
||||||
|
{ |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
int segno = pageno / SLRU_PAGES_PER_SEGMENT; |
||||||
|
int rpageno = pageno % SLRU_PAGES_PER_SEGMENT; |
||||||
|
int offset = rpageno * BLCKSZ; |
||||||
|
char path[MAXPGPATH]; |
||||||
|
int fd; |
||||||
|
|
||||||
|
SlruFileName(ctl, path, segno); |
||||||
|
|
||||||
|
/*
|
||||||
|
* In a crash-and-restart situation, it's possible for us to receive |
||||||
|
* commands to set the commit status of transactions whose bits are in |
||||||
|
* already-truncated segments of the commit log (see notes in |
||||||
|
* SlruPhysicalWritePage). Hence, if we are InRecovery, allow the |
||||||
|
* case where the file doesn't exist, and return zeroes instead. |
||||||
|
*/ |
||||||
|
fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR); |
||||||
|
if (fd < 0) |
||||||
|
{ |
||||||
|
if (errno != ENOENT || !InRecovery) |
||||||
|
{ |
||||||
|
slru_errcause = SLRU_OPEN_FAILED; |
||||||
|
slru_errno = errno; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
elog(LOG, "file %s doesn't exist, reading as zeroes", path); |
||||||
|
MemSet(shared->page_buffer[slotno], 0, BLCKSZ); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
if (lseek(fd, (off_t) offset, SEEK_SET) < 0) |
||||||
|
{ |
||||||
|
slru_errcause = SLRU_SEEK_FAILED; |
||||||
|
slru_errno = errno; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
errno = 0; |
||||||
|
if (read(fd, shared->page_buffer[slotno], BLCKSZ) != BLCKSZ) |
||||||
|
{ |
||||||
|
slru_errcause = SLRU_READ_FAILED; |
||||||
|
slru_errno = errno; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
close(fd); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Physical write of a page from a buffer slot |
||||||
|
* |
||||||
|
* On failure, we cannot just elog(ERROR) since caller has put state in |
||||||
|
* shared memory that must be undone. So, we return FALSE and save enough |
||||||
|
* info in static variables to let SlruReportIOError make the report. |
||||||
|
* |
||||||
|
* For now, assume it's not worth keeping a file pointer open across |
||||||
|
* read/write operations. We could cache one virtual file pointer ... |
||||||
|
*/ |
||||||
|
static bool |
||||||
|
SlruPhysicalWritePage(SlruCtl ctl, int pageno, int slotno) |
||||||
|
{ |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
int segno = pageno / SLRU_PAGES_PER_SEGMENT; |
||||||
|
int rpageno = pageno % SLRU_PAGES_PER_SEGMENT; |
||||||
|
int offset = rpageno * BLCKSZ; |
||||||
|
char path[MAXPGPATH]; |
||||||
|
int fd; |
||||||
|
|
||||||
|
SlruFileName(ctl, path, segno); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If the file doesn't already exist, we should create it. It is |
||||||
|
* possible for this to need to happen when writing a page that's not |
||||||
|
* first in its segment; we assume the OS can cope with that. (Note: |
||||||
|
* it might seem that it'd be okay to create files only when |
||||||
|
* SimpleLruZeroPage is called for the first page of a segment. However, |
||||||
|
* if after a crash and restart the REDO logic elects to replay the |
||||||
|
* log from a checkpoint before the latest one, then it's possible |
||||||
|
* that we will get commands to set transaction status of transactions |
||||||
|
* that have already been truncated from the commit log. Easiest way |
||||||
|
* to deal with that is to accept references to nonexistent files here |
||||||
|
* and in SlruPhysicalReadPage.) |
||||||
|
*/ |
||||||
|
fd = BasicOpenFile(path, O_RDWR | PG_BINARY, S_IRUSR | S_IWUSR); |
||||||
|
if (fd < 0) |
||||||
|
{ |
||||||
|
if (errno != ENOENT) |
||||||
|
{ |
||||||
|
slru_errcause = SLRU_OPEN_FAILED; |
||||||
|
slru_errno = errno; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
fd = BasicOpenFile(path, O_RDWR | O_CREAT | O_EXCL | PG_BINARY, |
||||||
|
S_IRUSR | S_IWUSR); |
||||||
|
if (fd < 0) |
||||||
|
{ |
||||||
|
slru_errcause = SLRU_CREATE_FAILED; |
||||||
|
slru_errno = errno; |
||||||
|
return false; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (lseek(fd, (off_t) offset, SEEK_SET) < 0) |
||||||
|
{ |
||||||
|
slru_errcause = SLRU_SEEK_FAILED; |
||||||
|
slru_errno = errno; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
errno = 0; |
||||||
|
if (write(fd, shared->page_buffer[slotno], BLCKSZ) != BLCKSZ) |
||||||
|
{ |
||||||
|
/* if write didn't set errno, assume problem is no disk space */ |
||||||
|
if (errno == 0) |
||||||
|
errno = ENOSPC; |
||||||
|
slru_errcause = SLRU_WRITE_FAILED; |
||||||
|
slru_errno = errno; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
close(fd); |
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Issue the error message after failure of SlruPhysicalReadPage or |
||||||
|
* SlruPhysicalWritePage. Call this after cleaning up shared-memory state. |
||||||
|
*/ |
||||||
|
static void |
||||||
|
SlruReportIOError(SlruCtl ctl, int pageno, TransactionId xid) |
||||||
|
{ |
||||||
|
int segno = pageno / SLRU_PAGES_PER_SEGMENT; |
||||||
|
int rpageno = pageno % SLRU_PAGES_PER_SEGMENT; |
||||||
|
int offset = rpageno * BLCKSZ; |
||||||
|
char path[MAXPGPATH]; |
||||||
|
|
||||||
|
/* XXX TODO: provide xid as context in error messages */ |
||||||
|
|
||||||
|
SlruFileName(ctl, path, segno); |
||||||
|
errno = slru_errno; |
||||||
|
switch (slru_errcause) |
||||||
|
{ |
||||||
|
case SLRU_OPEN_FAILED: |
||||||
|
elog(ERROR, "open of %s failed: %m", path); |
||||||
|
break; |
||||||
|
case SLRU_CREATE_FAILED: |
||||||
|
elog(ERROR, "creation of file %s failed: %m", path); |
||||||
|
break; |
||||||
|
case SLRU_SEEK_FAILED: |
||||||
|
elog(ERROR, "lseek of file %s, offset %u failed: %m", |
||||||
|
path, offset); |
||||||
|
break; |
||||||
|
case SLRU_READ_FAILED: |
||||||
|
elog(ERROR, "read of file %s, offset %u failed: %m", |
||||||
|
path, offset); |
||||||
|
break; |
||||||
|
case SLRU_WRITE_FAILED: |
||||||
|
elog(ERROR, "write of file %s, offset %u failed: %m", |
||||||
|
path, offset); |
||||||
|
break; |
||||||
|
default: |
||||||
|
/* can't get here, we trust */ |
||||||
|
elog(ERROR, "unknown SimpleLru I/O error"); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Select the slot to re-use when we need a free slot. |
||||||
|
* |
||||||
|
* The target page number is passed because we need to consider the |
||||||
|
* possibility that some other process reads in the target page while |
||||||
|
* we are doing I/O to free a slot. Hence, check or recheck to see if |
||||||
|
* any slot already holds the target page, and return that slot if so. |
||||||
|
* Thus, the returned slot is *either* a slot already holding the pageno |
||||||
|
* (could be any state except EMPTY), *or* a freeable slot (state EMPTY |
||||||
|
* or CLEAN). |
||||||
|
* |
||||||
|
* Control lock must be held at entry, and will be held at exit. |
||||||
|
*/ |
||||||
|
static int |
||||||
|
SlruSelectLRUPage(SlruCtl ctl, int pageno) |
||||||
|
{ |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
/* Outer loop handles restart after I/O */ |
||||||
|
for (;;) |
||||||
|
{ |
||||||
|
int slotno; |
||||||
|
int bestslot = 0; |
||||||
|
unsigned int bestcount = 0; |
||||||
|
|
||||||
|
/* See if page already has a buffer assigned */ |
||||||
|
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++) |
||||||
|
{ |
||||||
|
if (shared->page_number[slotno] == pageno && |
||||||
|
shared->page_status[slotno] != SLRU_PAGE_EMPTY) |
||||||
|
return slotno; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* If we find any EMPTY slot, just select that one. Else locate |
||||||
|
* the least-recently-used slot that isn't the latest page. |
||||||
|
*/ |
||||||
|
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++) |
||||||
|
{ |
||||||
|
if (shared->page_status[slotno] == SLRU_PAGE_EMPTY) |
||||||
|
return slotno; |
||||||
|
if (shared->page_lru_count[slotno] > bestcount && |
||||||
|
shared->page_number[slotno] != shared->latest_page_number) |
||||||
|
{ |
||||||
|
bestslot = slotno; |
||||||
|
bestcount = shared->page_lru_count[slotno]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* If the selected page is clean, we're set. |
||||||
|
*/ |
||||||
|
if (shared->page_status[bestslot] == SLRU_PAGE_CLEAN) |
||||||
|
return bestslot; |
||||||
|
|
||||||
|
/*
|
||||||
|
* We need to do I/O. Normal case is that we have to write it |
||||||
|
* out, but it's possible in the worst case to have selected a |
||||||
|
* read-busy page. In that case we use SimpleLruReadPage to wait for |
||||||
|
* the read to complete. |
||||||
|
*/ |
||||||
|
if (shared->page_status[bestslot] == SLRU_PAGE_READ_IN_PROGRESS) |
||||||
|
(void) SimpleLruReadPage(ctl, shared->page_number[bestslot], |
||||||
|
InvalidTransactionId, false); |
||||||
|
else |
||||||
|
SimpleLruWritePage(ctl, bestslot); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Now loop back and try again. This is the easiest way of |
||||||
|
* dealing with corner cases such as the victim page being |
||||||
|
* re-dirtied while we wrote it. |
||||||
|
*/ |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* This must be called ONCE during postmaster or standalone-backend startup |
||||||
|
*/ |
||||||
|
void |
||||||
|
SimpleLruSetLatestPage(SlruCtl ctl, int pageno) |
||||||
|
{ |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
|
||||||
|
shared->latest_page_number = pageno; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* This is called during checkpoint and postmaster/standalone-backend shutdown |
||||||
|
*/ |
||||||
|
void |
||||||
|
SimpleLruFlush(SlruCtl ctl, bool checkpoint) |
||||||
|
{ |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
int slotno; |
||||||
|
|
||||||
|
LWLockAcquire(ctl->locks->ControlLock, LW_EXCLUSIVE); |
||||||
|
|
||||||
|
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++) |
||||||
|
{ |
||||||
|
SimpleLruWritePage(ctl, slotno); |
||||||
|
/*
|
||||||
|
* When called during a checkpoint, |
||||||
|
* we cannot assert that the slot is clean now, since another |
||||||
|
* process might have re-dirtied it already. That's okay. |
||||||
|
*/ |
||||||
|
Assert(checkpoint || |
||||||
|
shared->page_status[slotno] == SLRU_PAGE_EMPTY || |
||||||
|
shared->page_status[slotno] == SLRU_PAGE_CLEAN); |
||||||
|
} |
||||||
|
|
||||||
|
LWLockRelease(ctl->locks->ControlLock); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Remove all segments before the one holding the passed page number |
||||||
|
* |
||||||
|
* When this is called, we know that the database logically contains no |
||||||
|
* reference to transaction IDs older than oldestXact. However, we must |
||||||
|
* not remove any segment until we have performed a checkpoint, to ensure |
||||||
|
* that no such references remain on disk either; else a crash just after |
||||||
|
* the truncation might leave us with a problem. Since CLOG segments hold |
||||||
|
* a large number of transactions, the opportunity to actually remove a |
||||||
|
* segment is fairly rare, and so it seems best not to do the checkpoint |
||||||
|
* unless we have confirmed that there is a removable segment. Therefore |
||||||
|
* we issue the checkpoint command here, not in higher-level code as might |
||||||
|
* seem cleaner. |
||||||
|
*/ |
||||||
|
void |
||||||
|
SimpleLruTruncate(SlruCtl ctl, int cutoffPage) |
||||||
|
{ |
||||||
|
int slotno; |
||||||
|
SlruShared shared = (SlruShared) ctl->shared; |
||||||
|
|
||||||
|
/*
|
||||||
|
* The cutoff point is the start of the segment containing cutoffPage. |
||||||
|
*/ |
||||||
|
cutoffPage -= cutoffPage % SLRU_PAGES_PER_SEGMENT; |
||||||
|
|
||||||
|
if (!SlruScanDirectory(ctl, cutoffPage, false)) |
||||||
|
return; /* nothing to remove */ |
||||||
|
|
||||||
|
/* Perform a forced CHECKPOINT */ |
||||||
|
CreateCheckPoint(false, true); |
||||||
|
|
||||||
|
/*
|
||||||
|
* Scan shared memory and remove any pages preceding the cutoff |
||||||
|
* page, to ensure we won't rewrite them later. (Any dirty pages |
||||||
|
* should have been flushed already during the checkpoint, we're just |
||||||
|
* being extra careful here.) |
||||||
|
*/ |
||||||
|
LWLockAcquire(ctl->locks->ControlLock, LW_EXCLUSIVE); |
||||||
|
|
||||||
|
restart:; |
||||||
|
|
||||||
|
/*
|
||||||
|
* While we are holding the lock, make an important safety check: the |
||||||
|
* planned cutoff point must be <= the current endpoint page. |
||||||
|
* Otherwise we have already wrapped around, and proceeding with the |
||||||
|
* truncation would risk removing the current segment. |
||||||
|
*/ |
||||||
|
if (ctl->PagePrecedes(shared->latest_page_number, cutoffPage)) |
||||||
|
{ |
||||||
|
LWLockRelease(ctl->locks->ControlLock); |
||||||
|
elog(LOG, "unable to truncate %s: apparent wraparound", ctl->Dir); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
for (slotno = 0; slotno < NUM_CLOG_BUFFERS; slotno++) |
||||||
|
{ |
||||||
|
if (shared->page_status[slotno] == SLRU_PAGE_EMPTY) |
||||||
|
continue; |
||||||
|
if (!ctl->PagePrecedes(shared->page_number[slotno], cutoffPage)) |
||||||
|
continue; |
||||||
|
|
||||||
|
/*
|
||||||
|
* If page is CLEAN, just change state to EMPTY (expected case). |
||||||
|
*/ |
||||||
|
if (shared->page_status[slotno] == SLRU_PAGE_CLEAN) |
||||||
|
{ |
||||||
|
shared->page_status[slotno] = SLRU_PAGE_EMPTY; |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* Hmm, we have (or may have) I/O operations acting on the page, |
||||||
|
* so we've got to wait for them to finish and then start again. |
||||||
|
* This is the same logic as in SlruSelectLRUPage. |
||||||
|
*/ |
||||||
|
if (shared->page_status[slotno] == SLRU_PAGE_READ_IN_PROGRESS) |
||||||
|
(void) SimpleLruReadPage(ctl, shared->page_number[slotno], |
||||||
|
InvalidTransactionId, false); |
||||||
|
else |
||||||
|
SimpleLruWritePage(ctl, slotno); |
||||||
|
goto restart; |
||||||
|
} |
||||||
|
|
||||||
|
LWLockRelease(ctl->locks->ControlLock); |
||||||
|
|
||||||
|
/* Now we can remove the old segment(s) */ |
||||||
|
(void) SlruScanDirectory(ctl, cutoffPage, true); |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* SlruTruncate subroutine: scan directory for removable segments. |
||||||
|
* Actually remove them iff doDeletions is true. Return TRUE iff any |
||||||
|
* removable segments were found. Note: no locking is needed. |
||||||
|
*/ |
||||||
|
static bool |
||||||
|
SlruScanDirectory(SlruCtl ctl, int cutoffPage, bool doDeletions) |
||||||
|
{ |
||||||
|
bool found = false; |
||||||
|
DIR *cldir; |
||||||
|
struct dirent *clde; |
||||||
|
int segno; |
||||||
|
int segpage; |
||||||
|
char path[MAXPGPATH]; |
||||||
|
|
||||||
|
cldir = opendir(ctl->Dir); |
||||||
|
if (cldir == NULL) |
||||||
|
elog(ERROR, "could not open directory (%s): %m", ctl->Dir); |
||||||
|
|
||||||
|
errno = 0; |
||||||
|
while ((clde = readdir(cldir)) != NULL) |
||||||
|
{ |
||||||
|
if (strlen(clde->d_name) == 4 && |
||||||
|
strspn(clde->d_name, "0123456789ABCDEF") == 4) |
||||||
|
{ |
||||||
|
segno = (int) strtol(clde->d_name, NULL, 16); |
||||||
|
segpage = segno * SLRU_PAGES_PER_SEGMENT; |
||||||
|
if (ctl->PagePrecedes(segpage, cutoffPage)) |
||||||
|
{ |
||||||
|
found = true; |
||||||
|
if (doDeletions) |
||||||
|
{ |
||||||
|
elog(LOG, "removing file %s/%s", ctl->Dir, clde->d_name); |
||||||
|
snprintf(path, MAXPGPATH, "%s/%s", ctl->Dir, clde->d_name); |
||||||
|
unlink(path); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
errno = 0; |
||||||
|
} |
||||||
|
if (errno) |
||||||
|
elog(ERROR, "could not read directory (%s): %m", ctl->Dir); |
||||||
|
closedir(cldir); |
||||||
|
|
||||||
|
return found; |
||||||
|
} |
||||||
@ -0,0 +1,62 @@ |
|||||||
|
/*
|
||||||
|
* slru.h |
||||||
|
* |
||||||
|
* Simple LRU |
||||||
|
* |
||||||
|
* Portions Copyright (c) 2003, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1994, Regents of the University of California |
||||||
|
* |
||||||
|
* $Id: slru.h,v 1.1 2003/06/11 22:37:46 momjian Exp $ |
||||||
|
*/ |
||||||
|
#ifndef SLRU_H |
||||||
|
#define SLRU_H |
||||||
|
|
||||||
|
#include "access/xlog.h" |
||||||
|
|
||||||
|
/* exported because lwlock.c needs it */ |
||||||
|
#define NUM_CLOG_BUFFERS 8 |
||||||
|
|
||||||
|
typedef struct SlruLockData |
||||||
|
{ |
||||||
|
LWLockId ControlLock; |
||||||
|
/*
|
||||||
|
* BufferLocks is set during CLOGShmemInit and does not change thereafter. |
||||||
|
* The value is automatically inherited by backends via fork, and |
||||||
|
* doesn't need to be in shared memory. |
||||||
|
*/ |
||||||
|
LWLockId BufferLocks[NUM_CLOG_BUFFERS]; /* Per-buffer I/O locks */ |
||||||
|
} SlruLockData; |
||||||
|
typedef SlruLockData *SlruLock; |
||||||
|
|
||||||
|
typedef struct SlruCtlData |
||||||
|
{ |
||||||
|
void *shared; /* pointer to SlruSharedData */ |
||||||
|
SlruLock locks; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Dir is set during SimpleLruShmemInit and does not change thereafter. |
||||||
|
* The value is automatically inherited by backends via fork, and |
||||||
|
* doesn't need to be in shared memory. |
||||||
|
*/ |
||||||
|
char Dir[MAXPGPATH]; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Decide which of two page numbers is "older" for truncation purposes. |
||||||
|
* We need to use comparison of TransactionIds here in order to do the right |
||||||
|
* thing with wraparound XID arithmetic. |
||||||
|
*/ |
||||||
|
bool (*PagePrecedes)(int, int); |
||||||
|
|
||||||
|
} SlruCtlData; |
||||||
|
typedef SlruCtlData *SlruCtl; |
||||||
|
|
||||||
|
extern int SimpleLruShmemSize(void); |
||||||
|
extern void SimpleLruInit(SlruCtl ctl, const char *name, const char *subdir); |
||||||
|
extern int SimpleLruZeroPage(SlruCtl ctl, int pageno); |
||||||
|
extern char *SimpleLruReadPage(SlruCtl ctl, int pageno, TransactionId xid, bool forwrite); |
||||||
|
extern void SimpleLruWritePage(SlruCtl ctl, int slotno); |
||||||
|
extern void SimpleLruSetLatestPage(SlruCtl ctl, int pageno); |
||||||
|
extern void SimpleLruFlush(SlruCtl ctl, bool checkpoint); |
||||||
|
extern void SimpleLruTruncate(SlruCtl ctl, int cutoffPage); |
||||||
|
|
||||||
|
#endif /* SLRU_H */ |
||||||
Loading…
Reference in new issue