1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
/*-------------------------------------------------------------------------
*
* freepage.h
* Management of page-organized free memory.
*
* Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* src/include/utils/freepage.h
*
*-------------------------------------------------------------------------
*/
#ifndef FREEPAGE_H
#define FREEPAGE_H
#include "storage/lwlock.h"
#include "utils/relptr.h"
/* Forward declarations. */
typedef struct FreePageSpanLeader FreePageSpanLeader;
typedef struct FreePageBtree FreePageBtree;
typedef struct FreePageManager FreePageManager;
/*
* PostgreSQL normally uses 8kB pages for most things, but many common
* architecture/operating system pairings use a 4kB page size for memory
* allocation, so we do that here also.
*/
#define FPM_PAGE_SIZE 4096
/*
* Each freelist except for the last contains only spans of one particular
* size. Everything larger goes on the last one. In some sense this seems
* like a waste since most allocations are in a few common sizes, but it
* means that small allocations can simply pop the head of the relevant list
* without needing to worry about whether the object we find there is of
* precisely the correct size (because we know it must be).
*/
#define FPM_NUM_FREELISTS 129
/* Define relative pointer types. */
relptr_declare(FreePageBtree, RelptrFreePageBtree);
relptr_declare(FreePageManager, RelptrFreePageManager);
relptr_declare(FreePageSpanLeader, RelptrFreePageSpanLeader);
/* Everything we need in order to manage free pages (see freepage.c) */
struct FreePageManager
{
RelptrFreePageManager self;
RelptrFreePageBtree btree_root;
RelptrFreePageSpanLeader btree_recycle;
unsigned btree_depth;
unsigned btree_recycle_count;
Size singleton_first_page;
Size singleton_npages;
Size contiguous_pages;
bool contiguous_pages_dirty;
RelptrFreePageSpanLeader freelist[FPM_NUM_FREELISTS];
#ifdef FPM_EXTRA_ASSERTS
/* For debugging only, pages put minus pages gotten. */
Size free_pages;
#endif
};
/* Macros to convert between page numbers (expressed as Size) and pointers. */
#define fpm_page_to_pointer(base, page) \
(AssertVariableIsOfTypeMacro(page, Size), \
(base) + FPM_PAGE_SIZE * (page))
#define fpm_pointer_to_page(base, ptr) \
(((Size) (((char *) (ptr)) - (base))) / FPM_PAGE_SIZE)
/* Macro to convert an allocation size to a number of pages. */
#define fpm_size_to_pages(sz) \
(((sz) + FPM_PAGE_SIZE - 1) / FPM_PAGE_SIZE)
/* Macros to check alignment of absolute and relative pointers. */
#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).relptr_off % FPM_PAGE_SIZE == 0)
/* Macro to find base address of the segment containing a FreePageManager. */
#define fpm_segment_base(fpm) \
(((char *) fpm) - fpm->self.relptr_off)
/* Macro to access a FreePageManager's largest consecutive run of pages. */
#define fpm_largest(fpm) \
(fpm->contiguous_pages)
/* Functions to manipulate the free page map. */
extern void FreePageManagerInitialize(FreePageManager *fpm, char *base);
extern bool FreePageManagerGet(FreePageManager *fpm, Size npages,
Size *first_page);
extern void FreePageManagerPut(FreePageManager *fpm, Size first_page,
Size npages);
extern char *FreePageManagerDump(FreePageManager *fpm);
#endif /* FREEPAGE_H */
|
