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 1 of file freepage.h.

FreePageManager

typedef struct FreePageManager FreePageManager

Definition at line 1 of file freepage.h.

FreePageSpanLeader

typedef struct FreePageSpanLeader FreePageSpanLeader

Definition at line 1 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
	)