diff --git a/.gitignore b/.gitignore index 3f11f2e..6542e35 100644 --- a/.gitignore +++ b/.gitignore @@ -22,3 +22,4 @@ lcov.info /GNUmakefile /config.log /config.status +/nbproject/private/ \ No newline at end of file diff --git a/src/backend/access/nbtree/nbtpage.c b/src/backend/access/nbtree/nbtpage.c index 2796445..0229f5a 100644 --- a/src/backend/access/nbtree/nbtpage.c +++ b/src/backend/access/nbtree/nbtpage.c @@ -508,7 +508,7 @@ _bt_getbuf(Relation rel, BlockNumber blkno, int access) if (blkno != P_NEW) { /* Read an existing block of the relation */ - buf = ReadBuffer(rel, blkno); + buf = ReadBufferLevel(rel, blkno, BUFFER_LEVEL_2ND); LockBuffer(buf, access); _bt_checkpage(rel, buf); } @@ -548,7 +548,7 @@ _bt_getbuf(Relation rel, BlockNumber blkno, int access) blkno = GetFreeIndexPage(rel); if (blkno == InvalidBlockNumber) break; - buf = ReadBuffer(rel, blkno); + buf = ReadBufferLevel(rel, blkno, BUFFER_LEVEL_2ND); if (ConditionalLockBuffer(buf)) { page = BufferGetPage(buf); diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c index dadb49d..2922711 100644 --- a/src/backend/storage/buffer/buf_init.c +++ b/src/backend/storage/buffer/buf_init.c @@ -22,6 +22,7 @@ BufferDesc *BufferDescriptors; char *BufferBlocks; int32 *PrivateRefCount; +BufferLevelDesc *bufferLevels; /* * Data Structures: @@ -72,8 +73,7 @@ int32 *PrivateRefCount; void InitBufferPool(void) { - bool foundBufs, - foundDescs; + bool foundBufs, foundDescs, foundBufferLevels = false; BufferDescriptors = (BufferDesc *) ShmemInitStruct("Buffer Descriptors", @@ -83,19 +83,38 @@ InitBufferPool(void) ShmemInitStruct("Buffer Blocks", NBuffers * (Size) BLCKSZ, &foundBufs); - if (foundDescs || foundBufs) + bufferLevels = (BufferLevelDesc*) + ShmemInitStruct("Buffer Levels Descriptors Table", + sizeof(BufferLevelDesc) * BUFFER_LEVEL_SIZE, + &foundBufferLevels); + if (foundDescs || foundBufs || foundBufferLevels) { /* both should be present or neither */ - Assert(foundDescs && foundBufs); + Assert(foundDescs && foundBufs && foundBufferLevels); /* note: this path is only taken in EXEC_BACKEND case */ } else { BufferDesc *buf; + BufferLevelDesc *bufferLevelDesc; + int i; - + buf = BufferDescriptors; + /* Initialize buffer levels. */ + //1st Level - Default + bufferLevelDesc = bufferLevels; + bufferLevelDesc->index = 0; + bufferLevelDesc->super = BUFFER_LEVEL_END_OF_LIST; + bufferLevelDesc->lower = BUFFER_LEVEL_END_OF_LIST; + + //2nd Level - For indices + bufferLevelDesc++; + bufferLevelDesc->index = 1; + bufferLevelDesc->super = BUFFER_LEVEL_END_OF_LIST; + bufferLevelDesc->lower = 0; + /* * Initialize all the buffer headers. */ @@ -117,6 +136,10 @@ InitBufferPool(void) */ buf->freeNext = i + 1; + /* Assign buffer level. */ + //TODO Currently hardcoded - + buf->buf_level = ( 0.3 * NBuffers > i ) ? BUFFER_LEVEL_DEFAULT : BUFFER_LEVEL_2ND; + buf->io_in_progress_lock = LWLockAssign(); buf->content_lock = LWLockAssign(); } diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index 1f89e52..867bae0 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -47,7 +47,8 @@ #include "storage/standby.h" #include "utils/rel.h" #include "utils/resowner.h" - +#include "catalog/pg_type.h" +#include "funcapi.h" /* Note: these two macros only work on shared buffers, not local ones! */ #define BufHdrGetBlock(bufHdr) ((Block) (BufferBlocks + ((Size) (bufHdr)->buf_id) * BLCKSZ)) @@ -85,7 +86,7 @@ static volatile BufferDesc *PinCountWaitBuf = NULL; static Buffer ReadBuffer_common(SMgrRelation reln, char relpersistence, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy, - bool *hit); + bool *hit, BufferLevel bufferLevel); static bool PinBuffer(volatile BufferDesc *buf, BufferAccessStrategy strategy); static void PinBuffer_Locked(volatile BufferDesc *buf); static void UnpinBuffer(volatile BufferDesc *buf, bool fixOwner); @@ -102,7 +103,8 @@ static volatile BufferDesc *BufferAlloc(SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum, BufferAccessStrategy strategy, - bool *foundPtr); + bool *foundPtr, + BufferLevel bufferLevel); static void FlushBuffer(volatile BufferDesc *buf, SMgrRelation reln); static void AtProcExit_Buffers(int code, Datum arg); @@ -186,6 +188,18 @@ ReadBuffer(Relation reln, BlockNumber blockNum) return ReadBufferExtended(reln, MAIN_FORKNUM, blockNum, RBM_NORMAL, NULL); } +Buffer +ReadBufferLevel(Relation reln, BlockNumber blockNum, BufferLevel bufferLevel) { + return ReadBufferExtendedLevel(reln, MAIN_FORKNUM, blockNum, RBM_NORMAL, NULL, bufferLevel); +} + +/** See {@link } for more details. */ +Buffer +ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, + ReadBufferMode mode, BufferAccessStrategy strategy) { + return ReadBufferExtendedLevel(reln, forkNum, blockNum, mode, strategy, BUFFER_LEVEL_DEFAULT); +} + /* * ReadBufferExtended -- returns a buffer containing the requested * block of the requested relation. If the blknum @@ -219,8 +233,8 @@ ReadBuffer(Relation reln, BlockNumber blockNum) * See buffer/README for details. */ Buffer -ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, - ReadBufferMode mode, BufferAccessStrategy strategy) +ReadBufferExtendedLevel(Relation reln, ForkNumber forkNum, BlockNumber blockNum, + ReadBufferMode mode, BufferAccessStrategy strategy, BufferLevel bufferLevel) { bool hit; Buffer buf; @@ -244,12 +258,19 @@ ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, */ pgstat_count_buffer_read(reln); buf = ReadBuffer_common(reln->rd_smgr, reln->rd_rel->relpersistence, - forkNum, blockNum, mode, strategy, &hit); + forkNum, blockNum, mode, strategy, &hit, bufferLevel); if (hit) pgstat_count_buffer_hit(reln); return buf; } +/** See {@link ReadBufferWithoutRelcacheLevel} for more details. */ +Buffer +ReadBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, + BlockNumber blockNum, ReadBufferMode mode, + BufferAccessStrategy strategy) { + return ReadBufferWithoutRelcacheLevel(rnode, forkNum, blockNum, mode, strategy, BUFFER_LEVEL_DEFAULT); +} /* * ReadBufferWithoutRelcache -- like ReadBufferExtended, but doesn't require @@ -261,16 +282,16 @@ ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, * parameters. */ Buffer -ReadBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, +ReadBufferWithoutRelcacheLevel(RelFileNode rnode, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, - BufferAccessStrategy strategy) + BufferAccessStrategy strategy, BufferLevel bufferLevel) { bool hit; SMgrRelation smgr = smgropen(rnode, InvalidBackendId); return ReadBuffer_common(smgr, RELPERSISTENCE_PERMANENT, forkNum, blockNum, - mode, strategy, &hit); + mode, strategy, &hit, bufferLevel); } @@ -282,7 +303,7 @@ ReadBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, static Buffer ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, - BufferAccessStrategy strategy, bool *hit) + BufferAccessStrategy strategy, bool *hit, BufferLevel bufferLevel) { volatile BufferDesc *bufHdr; Block bufBlock; @@ -323,7 +344,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, * not currently in memory. */ bufHdr = BufferAlloc(smgr, relpersistence, forkNum, blockNum, - strategy, &found); + strategy, &found, bufferLevel); if (found) pgBufferUsage.shared_blks_hit++; else @@ -507,7 +528,8 @@ static volatile BufferDesc * BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, BlockNumber blockNum, BufferAccessStrategy strategy, - bool *foundPtr) + bool *foundPtr, + BufferLevel bufferLevel) { BufferTag newTag; /* identity of requested block */ uint32 newHash; /* hash value for newTag */ @@ -585,7 +607,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum, * still held, since it would be bad to hold the spinlock while * possibly waking up other processes. */ - buf = StrategyGetBuffer(strategy, &lock_held); + buf = StrategyGetBufferLevel(strategy, &lock_held, bufferLevel); Assert(buf->refcount == 0); @@ -2772,3 +2794,69 @@ local_buffer_write_error_callback(void *arg) pfree(path); } } + +Datum +dump_shared_buffers_info(PG_FUNCTION_ARGS) +{ + FuncCallContext *funcctx; + int idx = 2; + + //fprintf(stderr, "Executing dump_shared_buffers_info\n"); + if (SRF_IS_FIRSTCALL()) + { + TupleDesc tupdesc; + MemoryContext oldcontext; + int val = 1; + + funcctx = SRF_FIRSTCALL_INIT(); + oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); + + /* + * build tupdesc for result tuples (matches out parameters in pg_proc + * entry) + */ + tupdesc = CreateTemplateTupleDesc(3, false); + TupleDescInitEntry(tupdesc, (AttrNumber) val++, "buf_idx", + INT4OID, -1, 0); + TupleDescInitEntry(tupdesc, (AttrNumber) val++, "buf_level", + INT4OID, -1, 0); + TupleDescInitEntry(tupdesc, (AttrNumber) val++, "buf_free_next", + INT4OID, -1, 0); + + funcctx->tuple_desc = BlessTupleDesc(tupdesc); + + /* allocate memory for user context */ + funcctx->user_fctx = (void*) palloc(sizeof(int)); + *((int *) funcctx->user_fctx) = 0; + MemoryContextSwitchTo(oldcontext); + } + + funcctx = SRF_PERCALL_SETUP(); + idx = *((int *) funcctx->user_fctx); + if (idx < NBuffers) { + BufferDesc *bufferDesc; + Datum result; + Datum values[4]; + bool nulls[4]; + HeapTuple tuple; + int val = 0; + + bufferDesc = BufferDescriptors + idx; + + values[val++] = Int32GetDatum(idx); + values[val++] = Int32GetDatum(bufferDesc->buf_level); + values[val++] = Int32GetDatum(bufferDesc->freeNext); + MemSet(nulls, 0, sizeof(nulls)); + + idx++; + *((int *) funcctx->user_fctx) = idx; + tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls); + result = HeapTupleGetDatum(tuple); + + SRF_RETURN_NEXT(funcctx, result); + }else { + SRF_RETURN_DONE(funcctx); + } + + SRF_RETURN_DONE(funcctx); +} \ No newline at end of file diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c index 72968db..fc27609 100644 --- a/src/backend/storage/buffer/freelist.c +++ b/src/backend/storage/buffer/freelist.c @@ -25,10 +25,14 @@ typedef struct { /* Clock sweep hand: index of next buffer to consider grabbing */ - int nextVictimBuffer; + int nextVictimBufferByLevel[BUFFER_LEVEL_SIZE]; - int firstFreeBuffer; /* Head of list of unused buffers */ - int lastFreeBuffer; /* Tail of list of unused buffers */ + /** Head of list of unused buffers */ + int firstFreeBufferByLevel[BUFFER_LEVEL_SIZE]; + + //Currently unused + ///** Tail of list of unused buffers */ + //int lastFreeBufferByLevel[BUFFER_LEVEL_SIZE]; /* * NOTE: lastFreeBuffer is undefined when firstFreeBuffer is -1 (that is, @@ -81,11 +85,16 @@ typedef struct BufferAccessStrategyData /* Prototypes for internal functions */ -static volatile BufferDesc *GetBufferFromRing(BufferAccessStrategy strategy); +static volatile BufferDesc *GetBufferFromRing(BufferAccessStrategy strategy, BufferLevel level); static void AddBufferToRing(BufferAccessStrategy strategy, volatile BufferDesc *buf); +static int findFisrtBufferByLevel(BufferLevel level); +volatile BufferDesc * +StrategyGetBuffer(BufferAccessStrategy strategy, bool *lock_held) { + return StrategyGetBufferLevel(strategy, lock_held, BUFFER_LEVEL_DEFAULT); +} /* * StrategyGetBuffer * @@ -104,18 +113,21 @@ static void AddBufferToRing(BufferAccessStrategy strategy, * kernel calls while holding the buffer header spinlock. */ volatile BufferDesc * -StrategyGetBuffer(BufferAccessStrategy strategy, bool *lock_held) +StrategyGetBufferLevel(BufferAccessStrategy strategy, bool *lock_held, BufferLevel level) { - volatile BufferDesc *buf; + volatile BufferDesc *buf = NULL; int trycounter; - + int bufferToExamine; + volatile BufferDesc *prevExaminedBuffer; + + //level = BUFFER_LEVEL_DEFAULT; /* * If given a strategy object, see whether it can select a buffer. We * assume strategy objects don't need the BufFreelistLock. */ if (strategy != NULL) { - buf = GetBufferFromRing(strategy); + buf = GetBufferFromRing(strategy, level); if (buf != NULL) { *lock_held = false; @@ -139,14 +151,33 @@ StrategyGetBuffer(BufferAccessStrategy strategy, bool *lock_held) * are considered to be protected by the BufFreelistLock not the * individual buffer spinlocks, so it's OK to manipulate them without * holding the spinlock. + * + * We do not keep lock on previous buffer, as free list is modified + * only by freelist.c and list is locked exclusivly (ensure this). */ - while (StrategyControl->firstFreeBuffer >= 0) + prevExaminedBuffer = NULL; + bufferToExamine = StrategyControl->firstFreeBufferByLevel[level]; + while (bufferToExamine >= 0) { - buf = &BufferDescriptors[StrategyControl->firstFreeBuffer]; + buf = &BufferDescriptors[bufferToExamine]; Assert(buf->freeNext != FREENEXT_NOT_IN_LIST); - + if (buf->buf_level != level) { + prevExaminedBuffer = buf; + bufferToExamine = buf->freeNext; + //fprintf(stderr, "Skipping buffer %d due to level missmatch %d, next is %d\n", buf->buf_id, buf->buf_level, buf->freeNext); + continue; + }else { + //fprintf(stderr, "Selecting buffer %d with level %d\n", buf->buf_id, buf->buf_level); + } + /* Unconditionally remove buffer from freelist */ - StrategyControl->firstFreeBuffer = buf->freeNext; + if (prevExaminedBuffer != NULL) { + /* We are after list head. */ + prevExaminedBuffer->freeNext = buf->freeNext; + }else { + /* We modify head of list. */ + StrategyControl->firstFreeBufferByLevel[level] = buf->freeNext; + } buf->freeNext = FREENEXT_NOT_IN_LIST; /* @@ -161,23 +192,50 @@ StrategyGetBuffer(BufferAccessStrategy strategy, bool *lock_held) { if (strategy != NULL) AddBufferToRing(strategy, buf); + if (buf->buf_level != BUFFER_LEVEL_DEFAULT) { + //fprintf(stderr, "Returing free buffer %d with level %d\n", buf->buf_id, buf->buf_level); + } + Assert(buf->buf_level == level); return buf; } UnlockBufHdr(buf); } - + if (buf != NULL && buf->buf_level != BUFFER_LEVEL_DEFAULT) { + //fprintf(stderr, "No free buffers found with level %d\n", buf->buf_level); + } /* Nothing on the freelist, so run the "clock sweep" algorithm */ - trycounter = NBuffers; + trycounter = NBuffers; //I know, we should only do NBuffersByLevel, but this is not initialized still for (;;) { - buf = &BufferDescriptors[StrategyControl->nextVictimBuffer]; + buf = &BufferDescriptors[StrategyControl->nextVictimBufferByLevel[level]]; - if (++StrategyControl->nextVictimBuffer >= NBuffers) + if (++StrategyControl->nextVictimBufferByLevel[level] >= NBuffers) { - StrategyControl->nextVictimBuffer = 0; - StrategyControl->completePasses++; + /* We need to determine next victim buffer. We assume + * for now, that we can sweep buffers by changing + * buf_level. I don't know if such feature will be used + * or not. + */ + StrategyControl->nextVictimBufferByLevel[level] = findFisrtBufferByLevel(level); + + Assert(StrategyControl->nextVictimBufferByLevel[level] >= 0); + + StrategyControl->completePasses++; } + /* If buffer doesn't have required level move next. It is almost + * same as code checking if buffer is pinned, but we don't use + * locking here. + */ + if (buf->buf_level != level) { + if (--trycounter == 0) + elog(ERROR, "no unpinned buffers available with requested level"); + //fprintf(stderr, "Skipping in clock sweep buffer %d due to buffer level mismatch %d\n", buf->buf_id, buf->buf_level); + continue; + } + + Assert(buf->buf_level == level); + /* * If the buffer is pinned or has a nonzero usage_count, we cannot use * it; decrement the usage_count (unless pinned) and keep scanning. @@ -195,6 +253,10 @@ StrategyGetBuffer(BufferAccessStrategy strategy, bool *lock_held) /* Found a usable buffer */ if (strategy != NULL) AddBufferToRing(strategy, buf); + if (buf->buf_level != BUFFER_LEVEL_DEFAULT) { + //fprintf(stderr, "Returing free buffer from clock sweep %d with level %d\n", buf->buf_id, buf->buf_level); + } + Assert(buf->buf_level == level); return buf; } } @@ -231,10 +293,10 @@ StrategyFreeBuffer(volatile BufferDesc *buf) */ if (buf->freeNext == FREENEXT_NOT_IN_LIST) { - buf->freeNext = StrategyControl->firstFreeBuffer; + buf->freeNext = StrategyControl->firstFreeBufferByLevel[buf->buf_level]; if (buf->freeNext < 0) - StrategyControl->lastFreeBuffer = buf->buf_id; - StrategyControl->firstFreeBuffer = buf->buf_id; + //StrategyControl->lastFreeBufferByLevel[buf->buf_level] = buf->buf_id; + StrategyControl->firstFreeBufferByLevel[buf->buf_level] = buf->buf_id; } LWLockRelease(BufFreelistLock); @@ -257,7 +319,8 @@ StrategySyncStart(uint32 *complete_passes, uint32 *num_buf_alloc) int result; LWLockAcquire(BufFreelistLock, LW_EXCLUSIVE); - result = StrategyControl->nextVictimBuffer; + //TODO We take next vitim buffer from default level, as we have many levels + result = StrategyControl->nextVictimBufferByLevel[BUFFER_LEVEL_DEFAULT]; if (complete_passes) *complete_passes = StrategyControl->completePasses; if (num_buf_alloc) @@ -326,6 +389,11 @@ StrategyInitialize(bool init) if (!found) { + int i; + BufferDesc *buf; + BufferLevel level; + int previousBufferLevel; + /* * Only done once, usually in postmaster */ @@ -335,12 +403,38 @@ StrategyInitialize(bool init) * Grab the whole linked list of free buffers for our strategy. We * assume it was previously set up by InitBufferPool(). */ - StrategyControl->firstFreeBuffer = 0; - StrategyControl->lastFreeBuffer = NBuffers - 1; - - /* Initialize the clock sweep pointer */ - StrategyControl->nextVictimBuffer = 0; + //StrategyControl->firstFreeBuffer = 0; + //StrategyControl->lastFreeBuffer = NBuffers - 1; + //Devo mode: + // - we don't set lastFreeBuffer is never used + for (i=0; i < BUFFER_LEVEL_SIZE; i++) { + StrategyControl->firstFreeBufferByLevel[i] = FREENEXT_END_OF_LIST; + //StrategyControl->lastFreeBufferByLevel[i] = FREENEXT_END_OF_LIST; + } + buf = BufferDescriptors; + for (i=0; i < NBuffers; i++, buf++) { + level = buf->buf_level; + if (StrategyControl->firstFreeBufferByLevel[level] == FREENEXT_END_OF_LIST) { + StrategyControl->firstFreeBufferByLevel[level] = i; + } + } + previousBufferLevel = NBuffers - 1; + + /* Coerce last free nexts. */ + for (level = BUFFER_LEVEL_SIZE - 1; level > -1; level--) { + if (StrategyControl->firstFreeBufferByLevel[level] != FREENEXT_END_OF_LIST) { + BufferDescriptors[previousBufferLevel].freeNext = FREENEXT_END_OF_LIST; + previousBufferLevel = StrategyControl->firstFreeBufferByLevel[level] - 1; + + } + StrategyControl->nextVictimBufferByLevel[level] + = StrategyControl->firstFreeBufferByLevel[level]; + } + + //Just simple check if everything is ok + Assert(previousBufferLevel == -1); + /* Clear statistics */ StrategyControl->completePasses = 0; StrategyControl->numBufferAllocs = 0; @@ -431,7 +525,7 @@ FreeAccessStrategy(BufferAccessStrategy strategy) * The bufhdr spin lock is held on the returned buffer. */ static volatile BufferDesc * -GetBufferFromRing(BufferAccessStrategy strategy) +GetBufferFromRing(BufferAccessStrategy strategy, BufferLevel level) { volatile BufferDesc *buf; Buffer bufnum; @@ -452,6 +546,8 @@ GetBufferFromRing(BufferAccessStrategy strategy) return NULL; } + // TODO: If buffer doesn't have requested level tall caller to allocate new buffer. Is it ok? + /* * If the buffer is pinned we cannot use it under any circumstances. * @@ -521,3 +617,16 @@ StrategyRejectBuffer(BufferAccessStrategy strategy, volatile BufferDesc *buf) return true; } + +static int findFisrtBufferByLevel(BufferLevel level) { + int i; + BufferDesc *buf; + + buf = BufferDescriptors; + for (i=0; i < NBuffers; i++, buf++) { + if (buf->buf_level == level) + return i; + } + + return FREENEXT_END_OF_LIST; +} \ No newline at end of file diff --git a/src/include/catalog/pg_proc.h b/src/include/catalog/pg_proc.h index cff64ba..d634f84 100644 --- a/src/include/catalog/pg_proc.h +++ b/src/include/catalog/pg_proc.h @@ -4320,7 +4320,8 @@ DATA(insert OID = 3113 ( last_value PGNSP PGUID 12 1 0 0 f t f t f i 1 0 2283 " DESCR("fetch the last row value"); DATA(insert OID = 3114 ( nth_value PGNSP PGUID 12 1 0 0 f t f t f i 2 0 2283 "2283 23" _null_ _null_ _null_ _null_ window_nth_value _null_ _null_ _null_ )); DESCR("fetch the Nth row value"); - +DATA(insert OID = 3833 ( dump_shared_buffers_info PGNSP PGUID 12 1 10 0 f f f t t s 0 0 2249 "" "{23,23,23}" "{o,o,o}" "{buf_idx,buf_level,buf_free_next}" _null_ dump_shared_buffers_info _null_ _null_ _null_ )); +DESCR("Dump information about usage of shared buffers"); /* * Symbolic values for provolatile column: these indicate whether the result diff --git a/src/include/storage/buf.h b/src/include/storage/buf.h index 5347ab0..01b51d2 100644 --- a/src/include/storage/buf.h +++ b/src/include/storage/buf.h @@ -43,4 +43,15 @@ typedef int Buffer; */ typedef struct BufferAccessStrategyData *BufferAccessStrategy; + +/** Type for buffer level. */ +typedef int BufferLevel; + +#define BUFFER_LEVEL_END_OF_LIST -2 +#define BUFFER_LEVEL_DEFAULT 0 +#define BUFFER_LEVEL_2ND 1 +/** I wonder to mark end of list with zeroed struct, not to put all here. */ +#define BUFFER_LEVEL_SIZE 2 + +extern int NBuffersByLevel[BUFFER_LEVEL_SIZE]; #endif /* BUF_H */ diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h index 0652bdf..1a019ac 100644 --- a/src/include/storage/buf_internals.h +++ b/src/include/storage/buf_internals.h @@ -104,6 +104,23 @@ typedef struct buftag #define BufMappingPartitionLock(hashcode) \ ((LWLockId) (FirstBufMappingLock + BufTableHashPartition(hashcode))) +/** + * Shared descriptor of buffer level. Each level contains index of super + * and lower level. {@code BUFFER_LEVEL_END_OF_LIST} in lower level means end of list, + * and {@code BUFFER_LEVEL_END_OF_LIST} in super means begin of list. This structure allows + * us to define tree-like structure of levels. + * + * Note: Currently we use only 2 levels; 1st Level is standard level, 2nd + * level is designed for use with index pages (when requested). + */ +typedef struct sbuflevel { + BufferLevel index; + + /** Not used currently. */ + BufferLevel super; + BufferLevel lower; +} BufferLevelDesc; + /* * BufferDesc -- shared descriptor/state data for a single shared buffer. * @@ -142,10 +159,28 @@ typedef struct sbufdesc int buf_id; /* buffer's index number (from 0) */ int freeNext; /* link in freelist chain */ + /** Holds level of buffer. */ + BufferLevel buf_level; LWLockId io_in_progress_lock; /* to wait for I/O to complete */ LWLockId content_lock; /* to lock access to buffer contents */ } BufferDesc; +/** Struct for holding parameters for getting buffer. We emulate polymorphic + * methods here*/ +typedef struct _StrategyGetBufferOptsV1 { + int version; + BufferLevel level; +}StrategyGetBufferOptsV1; + +typedef union _StrategyGetBufferUnion { + StrategyGetBufferOptsV1 optsV1; +}StrategyGetBufferUnion; + +typedef struct _StrategyGetBufferOpts { + int version; + StrategyGetBufferOptsV1 opts; +}StrategyGetBufferOpts; + #define BufferDescriptorGetBuffer(bdesc) ((bdesc)->buf_id + 1) /* @@ -174,14 +209,18 @@ extern PGDLLIMPORT BufferDesc *BufferDescriptors; /* in localbuf.c */ extern BufferDesc *LocalBufferDescriptors; +/** Shared table for buffer levels */ +extern PGDLLIMPORT BufferLevelDesc *bufferLevels; /* * Internal routines: only called by bufmgr */ /* freelist.c */ -extern volatile BufferDesc *StrategyGetBuffer(BufferAccessStrategy strategy, - bool *lock_held); +extern volatile BufferDesc *StrategyGetBuffer(BufferAccessStrategy strategy, bool *lock_held); + +extern volatile BufferDesc * StrategyGetBufferLevel(BufferAccessStrategy strategy, bool *lock_held, BufferLevel level); + extern void StrategyFreeBuffer(volatile BufferDesc *buf); extern bool StrategyRejectBuffer(BufferAccessStrategy strategy, volatile BufferDesc *buf); diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h index b8fc87e..d8b1b46 100644 --- a/src/include/storage/bufmgr.h +++ b/src/include/storage/bufmgr.h @@ -59,6 +59,9 @@ extern PGDLLIMPORT int NLocBuffer; extern PGDLLIMPORT Block *LocalBufferBlockPointers; extern PGDLLIMPORT int32 *LocalRefCount; +/** Dumps informations about shared buffers. */ +extern Datum dump_shared_buffers_info(PG_FUNCTION_ARGS); + /* special block number for ReadBuffer() */ #define P_NEW InvalidBlockNumber /* grow the file to get a new page */ @@ -157,12 +160,21 @@ extern PGDLLIMPORT int32 *LocalRefCount; extern void PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum); extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum); +extern Buffer ReadBufferLevel(Relation reln, BlockNumber blockNum, BufferLevel bufferLevel); extern Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy); +extern Buffer ReadBufferExtendedLevel(Relation reln, ForkNumber forkNum, + BlockNumber blockNum, ReadBufferMode mode, + BufferAccessStrategy strategy, + BufferLevel bufferLevel); extern Buffer ReadBufferWithoutRelcache(RelFileNode rnode, ForkNumber forkNum, BlockNumber blockNum, ReadBufferMode mode, BufferAccessStrategy strategy); +extern Buffer ReadBufferWithoutRelcacheLevel(RelFileNode rnode, + ForkNumber forkNum, BlockNumber blockNum, + ReadBufferMode mode, BufferAccessStrategy strategy, + BufferLevel bufferLevel); extern void ReleaseBuffer(Buffer buffer); extern void UnlockReleaseBuffer(Buffer buffer); extern void MarkBufferDirty(Buffer buffer);