freepage.h File Reference

#include "storage/lwlock.h"
#include "utils/relptr.h"

Include dependency graph for freepage.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	FreePageManager

Macros
#define	FPM_PAGE_SIZE   4096
#define	FPM_NUM_FREELISTS   129
#define	fpm_page_to_pointer(base, page)
#define	fpm_pointer_to_page(base, ptr)    (((Size) (((char *) (ptr)) - (base))) / FPM_PAGE_SIZE)
#define	fpm_size_to_pages(sz)    (((sz) + FPM_PAGE_SIZE - 1) / FPM_PAGE_SIZE)
#define	fpm_pointer_is_page_aligned(base, ptr)    (((Size) (((char *) (ptr)) - (base))) % FPM_PAGE_SIZE == 0)
#define	fpm_relptr_is_page_aligned(base, relptr)    (relptr_offset(relptr) % FPM_PAGE_SIZE == 0)
#define	fpm_segment_base(fpm)    (((char *) fpm) - relptr_offset(fpm->self))
#define	fpm_largest(fpm)    (fpm->contiguous_pages)

Typedefs
typedef struct FreePageSpanLeader	FreePageSpanLeader
typedef struct FreePageBtree	FreePageBtree
typedef struct FreePageManager	FreePageManager

Functions
	relptr_declare (FreePageBtree, RelptrFreePageBtree)
	relptr_declare (FreePageManager, RelptrFreePageManager)
	relptr_declare (FreePageSpanLeader, RelptrFreePageSpanLeader)
void	FreePageManagerInitialize (FreePageManager *fpm, char *base)
bool	FreePageManagerGet (FreePageManager *fpm, Size npages, Size *first_page)
void	FreePageManagerPut (FreePageManager *fpm, Size first_page, Size npages)
char *	FreePageManagerDump (FreePageManager *fpm)

Macro Definition Documentation

fpm_largest

#define fpm_largest

(

fpm

)

(fpm->contiguous_pages)

Definition at line 88 of file freepage.h.

FPM_NUM_FREELISTS

#define FPM_NUM_FREELISTS   129

Definition at line 40 of file freepage.h.

FPM_PAGE_SIZE

#define FPM_PAGE_SIZE   4096

Definition at line 30 of file freepage.h.

fpm_page_to_pointer

#define fpm_page_to_pointer	(		base,
			page
	)

Value:

    (AssertVariableIsOfTypeMacro(page, Size), \
     (base) + FPM_PAGE_SIZE * (page))

Definition at line 67 of file freepage.h.

fpm_pointer_is_page_aligned

#define fpm_pointer_is_page_aligned	(		base,
			ptr
	)		(((Size) (((char *) (ptr)) - (base))) % FPM_PAGE_SIZE == 0)

Definition at line 78 of file freepage.h.

fpm_pointer_to_page

#define fpm_pointer_to_page	(		base,
			ptr
	)		(((Size) (((char *) (ptr)) - (base))) / FPM_PAGE_SIZE)

Definition at line 70 of file freepage.h.

fpm_relptr_is_page_aligned

#define fpm_relptr_is_page_aligned	(		base,
			relptr
	)		(relptr_offset(relptr) % FPM_PAGE_SIZE == 0)

Definition at line 80 of file freepage.h.

fpm_segment_base

#define fpm_segment_base

(

fpm

)

(((char *) fpm) - relptr_offset(fpm->self))

Definition at line 84 of file freepage.h.

fpm_size_to_pages

#define fpm_size_to_pages

(

sz

)

(((sz) + FPM_PAGE_SIZE - 1) / FPM_PAGE_SIZE)

Definition at line 74 of file freepage.h.

Typedef Documentation

FreePageBtree

typedef struct FreePageBtree FreePageBtree

Definition at line 22 of file freepage.h.

FreePageManager

typedef struct FreePageManager FreePageManager

Definition at line 23 of file freepage.h.

FreePageSpanLeader

typedef struct FreePageSpanLeader FreePageSpanLeader

Definition at line 21 of file freepage.h.

Function Documentation

FreePageManagerDump()

char * FreePageManagerDump

(

FreePageManager *

fpm

)

Definition at line 424 of file freepage.c.

{
    char       *base = fpm_segment_base(fpm);
    StringInfoData buf;
    FreePageSpanLeader *recycle;
    bool        dumped_any_freelist = false;
    Size        f;
 
    /* Initialize output buffer. */
    initStringInfo(&buf);
 
    /* Dump general stuff. */
    appendStringInfo(&buf, "metadata: self %zu max contiguous pages = %zu\n",
                     relptr_offset(fpm->self), fpm->contiguous_pages);
 
    /* Dump btree. */
    if (fpm->btree_depth > 0)
    {
        FreePageBtree *root;
 
        appendStringInfo(&buf, "btree depth %u:\n", fpm->btree_depth);
        root = relptr_access(base, fpm->btree_root);
        FreePageManagerDumpBtree(fpm, root, NULL, 0, &buf);
    }
    else if (fpm->singleton_npages > 0)
    {
        appendStringInfo(&buf, "singleton: %zu(%zu)\n",
                         fpm->singleton_first_page, fpm->singleton_npages);
    }
 
    /* Dump btree recycle list. */
    recycle = relptr_access(base, fpm->btree_recycle);
    if (recycle != NULL)
    {
        appendStringInfoString(&buf, "btree recycle:");
        FreePageManagerDumpSpans(fpm, recycle, 1, &buf);
    }
 
    /* Dump free lists. */
    for (f = 0; f < FPM_NUM_FREELISTS; ++f)
    {
        FreePageSpanLeader *span;
 
        if (relptr_is_null(fpm->freelist[f]))
            continue;
        if (!dumped_any_freelist)
        {
            appendStringInfoString(&buf, "freelists:\n");
            dumped_any_freelist = true;
        }
        appendStringInfo(&buf, "  %zu:", f + 1);
        span = relptr_access(base, fpm->freelist[f]);
        FreePageManagerDumpSpans(fpm, span, f + 1, &buf);
    }
 
    /* And return result to caller. */
    return buf.data;
}

References appendStringInfo(), appendStringInfoString(), FreePageManager::btree_depth, FreePageManager::btree_recycle, FreePageManager::btree_root, buf, FreePageManager::contiguous_pages, FPM_NUM_FREELISTS, fpm_segment_base, FreePageManager::freelist, FreePageManagerDumpBtree(), FreePageManagerDumpSpans(), initStringInfo(), relptr_access, relptr_is_null, relptr_offset, root, FreePageManager::self, FreePageManager::singleton_first_page, and FreePageManager::singleton_npages.

FreePageManagerGet()

bool FreePageManagerGet	(	FreePageManager *	fpm,
		Size	npages,
		Size *	first_page
	)

Definition at line 210 of file freepage.c.

{
    bool        result;
    Size        contiguous_pages;
 
    result = FreePageManagerGetInternal(fpm, npages, first_page);
 
    /*
     * It's a bit counterintuitive, but allocating pages can actually create
     * opportunities for cleanup that create larger ranges.  We might pull a
     * key out of the btree that enables the item at the head of the btree
     * recycle list to be inserted; and then if there are more items behind it
     * one of those might cause two currently-separated ranges to merge,
     * creating a single range of contiguous pages larger than any that
     * existed previously.  It might be worth trying to improve the cleanup
     * algorithm to avoid such corner cases, but for now we just notice the
     * condition and do the appropriate reporting.
     */
    contiguous_pages = FreePageBtreeCleanup(fpm);
    if (fpm->contiguous_pages < contiguous_pages)
        fpm->contiguous_pages = contiguous_pages;
 
    /*
     * FreePageManagerGetInternal may have set contiguous_pages_dirty.
     * Recompute contiguous_pages if so.
     */
    FreePageManagerUpdateLargest(fpm);
 
#ifdef FPM_EXTRA_ASSERTS
    if (result)
    {
        Assert(fpm->free_pages >= npages);
        fpm->free_pages -= npages;
    }
    Assert(fpm->free_pages == sum_free_pages(fpm));
    Assert(fpm->contiguous_pages == FreePageManagerLargestContiguous(fpm));
#endif
    return result;
}

References Assert, FreePageManager::contiguous_pages, FreePageBtreeCleanup(), FreePageManagerGetInternal(), FreePageManagerLargestContiguous(), and FreePageManagerUpdateLargest().

Referenced by dsa_allocate_extended(), dsm_create(), and ensure_active_superblock().

FreePageManagerInitialize()

void FreePageManagerInitialize	(	FreePageManager *	fpm,
		char *	base
	)

Definition at line 183 of file freepage.c.

{
    Size        f;
 
    relptr_store(base, fpm->self, fpm);
    relptr_store(base, fpm->btree_root, (FreePageBtree *) NULL);
    relptr_store(base, fpm->btree_recycle, (FreePageSpanLeader *) NULL);
    fpm->btree_depth = 0;
    fpm->btree_recycle_count = 0;
    fpm->singleton_first_page = 0;
    fpm->singleton_npages = 0;
    fpm->contiguous_pages = 0;
    fpm->contiguous_pages_dirty = true;
#ifdef FPM_EXTRA_ASSERTS
    fpm->free_pages = 0;
#endif
 
    for (f = 0; f < FPM_NUM_FREELISTS; f++)
        relptr_store(base, fpm->freelist[f], (FreePageSpanLeader *) NULL);
}

References FreePageManager::btree_depth, FreePageManager::btree_recycle, FreePageManager::btree_recycle_count, FreePageManager::btree_root, FreePageManager::contiguous_pages, FreePageManager::contiguous_pages_dirty, FPM_NUM_FREELISTS, FreePageManager::freelist, relptr_store, FreePageManager::self, FreePageManager::singleton_first_page, and FreePageManager::singleton_npages.

Referenced by create_internal(), dsm_shmem_init(), and make_new_segment().

FreePageManagerPut()

void FreePageManagerPut	(	FreePageManager *	fpm,
		Size	first_page,
		Size	npages
	)

Definition at line 379 of file freepage.c.

{
    Size        contiguous_pages;
 
    Assert(npages > 0);
 
    /* Record the new pages. */
    contiguous_pages =
        FreePageManagerPutInternal(fpm, first_page, npages, false);
 
    /*
     * If the new range we inserted into the page manager was contiguous with
     * an existing range, it may have opened up cleanup opportunities.
     */
    if (contiguous_pages > npages)
    {
        Size        cleanup_contiguous_pages;
 
        cleanup_contiguous_pages = FreePageBtreeCleanup(fpm);
        if (cleanup_contiguous_pages > contiguous_pages)
            contiguous_pages = cleanup_contiguous_pages;
    }
 
    /* See if we now have a new largest chunk. */
    if (fpm->contiguous_pages < contiguous_pages)
        fpm->contiguous_pages = contiguous_pages;
 
    /*
     * The earlier call to FreePageManagerPutInternal may have set
     * contiguous_pages_dirty if it needed to allocate internal pages, so
     * recompute contiguous_pages if necessary.
     */
    FreePageManagerUpdateLargest(fpm);
 
#ifdef FPM_EXTRA_ASSERTS
    fpm->free_pages += npages;
    Assert(fpm->free_pages == sum_free_pages(fpm));
    Assert(fpm->contiguous_pages == FreePageManagerLargestContiguous(fpm));
#endif
}

References Assert, FreePageManager::contiguous_pages, FreePageBtreeCleanup(), FreePageManagerLargestContiguous(), FreePageManagerPutInternal(), and FreePageManagerUpdateLargest().

Referenced by create_internal(), destroy_superblock(), dsa_free(), dsm_create(), dsm_detach(), dsm_shmem_init(), dsm_unpin_segment(), and make_new_segment().

relptr_declare() [1/3]

relptr_declare	(	FreePageBtree	,
		RelptrFreePageBtree
	)

relptr_declare() [2/3]

relptr_declare	(	FreePageManager	,
		RelptrFreePageManager
	)

relptr_declare() [3/3]

relptr_declare	(	FreePageSpanLeader	,
		RelptrFreePageSpanLeader
	)