open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use size_t consistently in dsa.{ch}.

Browse Source 
Takeshi Ideriha complained that there is a mixture of Size and size_t
in dsa.c and corresponding header.  Let's use size_t.  Back-patch to 10
where dsa.c landed, to make future back-patching easy.

Discussion: https://postgr.es/m/4E72940DA2BF16479384A86D54D0988A6F19ABD9%40G01JPEXMBKW04
pull/34/head
Thomas Munro 7 years ago
parent ce9cf8e7e6
commit f025bd2ddd
2 changed files with 53 additions and 53 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 96
      src/backend/utils/mmgr/dsa.c
  2. 10
      src/include/utils/dsa.h

96
src/backend/utils/mmgr/dsa.c
Unescape View File

@ -65,7 +65,7 @@
* double this size, and so on. Larger segments may be created if necessary
* to satisfy large requests.
*/
#define DSA_INITIAL_SEGMENT_SIZE ((Size) (1 * 1024 * 1024))
#define DSA_INITIAL_SEGMENT_SIZE ((size_t) (1 * 1024 * 1024))
/*
* How many segments to create before we double the segment size. If this is
@ -98,7 +98,7 @@
#define DSA_OFFSET_BITMASK (((dsa_pointer) 1 << DSA_OFFSET_WIDTH) - 1)
/* The maximum size of a DSM segment. */
#define DSA_MAX_SEGMENT_SIZE ((Size) 1 << DSA_OFFSET_WIDTH)
#define DSA_MAX_SEGMENT_SIZE ((size_t) 1 << DSA_OFFSET_WIDTH)
/* Number of pages (see FPM_PAGE_SIZE) per regular superblock. */
#define DSA_PAGES_PER_SUPERBLOCK 16
@ -121,7 +121,7 @@
#define DSA_EXTRACT_OFFSET(dp) ((dp) & DSA_OFFSET_BITMASK)
/* The type used for index segment indexes (zero based). */
typedef Size dsa_segment_index;
typedef size_t dsa_segment_index;
/* Sentinel value for dsa_segment_index indicating 'none' or 'end'. */
#define DSA_SEGMENT_INDEX_NONE (~(dsa_segment_index)0)
@ -153,9 +153,9 @@ typedef struct
/* Sanity check magic value. */
uint32 magic;
/* Total number of pages in this segment (excluding metadata area). */
Size usable_pages;
size_t usable_pages;
/* Total size of this segment in bytes. */
Size size;
size_t size;
/*
* Index of the segment that precedes this one in the same segment bin, or
@ -169,7 +169,7 @@ typedef struct
*/
dsa_segment_index next;
/* The index of the bin that contains this segment. */
Size bin;
size_t bin;
/*
* A flag raised to indicate that this segment is being returned to the
@ -197,7 +197,7 @@ typedef struct
dsa_pointer prevspan; /* Previous span. */
dsa_pointer nextspan; /* Next span. */
dsa_pointer start; /* Starting address. */
Size npages; /* Length of span in pages. */
size_t npages; /* Length of span in pages. */
uint16 size_class; /* Size class. */
uint16 ninitialized; /* Maximum number of objects ever allocated. */
uint16 nallocatable; /* Number of objects currently allocatable. */
@ -308,9 +308,9 @@ typedef struct
/* The object pools for each size class. */
dsa_area_pool pools[DSA_NUM_SIZE_CLASSES];
/* The total size of all active segments. */
Size total_segment_size;
size_t total_segment_size;
/* The maximum total size of backing storage we are allowed. */
Size max_total_segment_size;
size_t max_total_segment_size;
/* Highest used segment index in the history of this area. */
dsa_segment_index high_segment_index;
/* The reference count for this area. */
@ -318,7 +318,7 @@ typedef struct
/* A flag indicating that this area has been pinned. */
bool pinned;
/* The number of times that segments have been freed. */
Size freed_segment_counter;
size_t freed_segment_counter;
/* The LWLock tranche ID. */
int lwlock_tranche_id;
/* The general lock (protects everything except object pools). */
@ -371,7 +371,7 @@ struct dsa_area
dsa_segment_index high_segment_index;
/* The last observed freed_segment_counter. */
Size freed_segment_counter;
size_t freed_segment_counter;
};
#define DSA_SPAN_NOTHING_FREE ((uint16) -1)
@ -382,7 +382,7 @@ struct dsa_area
(segment_map_ptr - &area->segment_maps[0])
static void init_span(dsa_area *area, dsa_pointer span_pointer,
dsa_area_pool *pool, dsa_pointer start, Size npages,
dsa_area_pool *pool, dsa_pointer start, size_t npages,
uint16 size_class);
static bool transfer_first_span(dsa_area *area, dsa_area_pool *pool,
int fromclass, int toclass);
@ -396,8 +396,8 @@ static void unlink_span(dsa_area *area, dsa_area_span *span);
static void add_span_to_fullness_class(dsa_area *area, dsa_area_span *span,
dsa_pointer span_pointer, int fclass);
static void unlink_segment(dsa_area *area, dsa_segment_map *segment_map);
static dsa_segment_map *get_best_segment(dsa_area *area, Size npages);
static dsa_segment_map *make_new_segment(dsa_area *area, Size requested_pages);
static dsa_segment_map *get_best_segment(dsa_area *area, size_t npages);
static dsa_segment_map *make_new_segment(dsa_area *area, size_t requested_pages);
static dsa_area *create_internal(void *place, size_t size,
int tranche_id,
dsm_handle control_handle,
@ -662,7 +662,7 @@ dsa_pin_mapping(dsa_area *area)
* flags.
*/
dsa_pointer
dsa_allocate_extended(dsa_area *area, Size size, int flags)
dsa_allocate_extended(dsa_area *area, size_t size, int flags)
{
uint16 size_class;
dsa_pointer start_pointer;
@ -685,8 +685,8 @@ dsa_allocate_extended(dsa_area *area, Size size, int flags)
*/
if (size > dsa_size_classes[lengthof(dsa_size_classes) - 1])
{
Size npages = fpm_size_to_pages(size);
Size first_page;
size_t npages = fpm_size_to_pages(size);
size_t first_page;
dsa_pointer span_pointer;
dsa_area_pool *pool = &area->control->pools[DSA_SCLASS_SPAN_LARGE];
@ -818,7 +818,7 @@ dsa_free(dsa_area *area, dsa_pointer dp)
dsa_area_span *span;
char *superblock;
char *object;
Size size;
size_t size;
int size_class;
/* Make sure we don't have a stale segment in the slot 'dp' refers to. */
@ -925,7 +925,7 @@ void *
dsa_get_address(dsa_area *area, dsa_pointer dp)
{
dsa_segment_index index;
Size offset;
size_t offset;
/* Convert InvalidDsaPointer to NULL. */
if (!DsaPointerIsValid(dp))
@ -998,7 +998,7 @@ dsa_unpin(dsa_area *area)
* backends that have attached to them.
*/
void
dsa_set_size_limit(dsa_area *area, Size limit)
dsa_set_size_limit(dsa_area *area, size_t limit)
{
LWLockAcquire(DSA_AREA_LOCK(area), LW_EXCLUSIVE);
area->control->max_total_segment_size = limit;
@ -1057,7 +1057,7 @@ dsa_trim(dsa_area *area)
void
dsa_dump(dsa_area *area)
{
Size i,
size_t i,
j;
/*
@ -1158,10 +1158,10 @@ dsa_dump(dsa_area *area)
* Return the smallest size that you can successfully provide to
* dsa_create_in_place.
*/
Size
size_t
dsa_minimum_size(void)
{
Size size;
size_t size;
int pages = 0;
size = MAXALIGN(sizeof(dsa_area_control)) +
@ -1189,9 +1189,9 @@ create_internal(void *place, size_t size,
dsa_area_control *control;
dsa_area *area;
dsa_segment_map *segment_map;
Size usable_pages;
Size total_pages;
Size metadata_bytes;
size_t usable_pages;
size_t total_pages;
size_t metadata_bytes;
int i;
/* Sanity check on the space we have to work in. */
@ -1224,7 +1224,7 @@ create_internal(void *place, size_t size,
control->segment_header.freed = false;
control->segment_header.size = DSA_INITIAL_SEGMENT_SIZE;
control->handle = control_handle;
control->max_total_segment_size = (Size) -1;
control->max_total_segment_size = (size_t) -1;
control->total_segment_size = size;
memset(&control->segment_handles[0], 0,
sizeof(dsm_handle) * DSA_MAX_SEGMENTS);
@ -1337,11 +1337,11 @@ attach_internal(void *place, dsm_segment *segment, dsa_handle handle)
static void
init_span(dsa_area *area,
dsa_pointer span_pointer,
dsa_area_pool *pool, dsa_pointer start, Size npages,
dsa_area_pool *pool, dsa_pointer start, size_t npages,
uint16 size_class)
{
dsa_area_span *span = dsa_get_address(area, span_pointer);
Size obsize = dsa_size_classes[size_class];
size_t obsize = dsa_size_classes[size_class];
/*
* The per-pool lock must be held because we manipulate the span list for
@ -1437,7 +1437,7 @@ alloc_object(dsa_area *area, int size_class)
dsa_pointer block;
dsa_pointer result;
char *object;
Size size;
size_t size;
/*
* Even though ensure_active_superblock can in turn call alloc_object if
@ -1523,12 +1523,12 @@ ensure_active_superblock(dsa_area *area, dsa_area_pool *pool,
{
dsa_pointer span_pointer;
dsa_pointer start_pointer;
Size obsize = dsa_size_classes[size_class];
Size nmax;
size_t obsize = dsa_size_classes[size_class];
size_t nmax;
int fclass;
Size npages = 1;
Size first_page;
Size i;
size_t npages = 1;
size_t first_page;
size_t i;
dsa_segment_map *segment_map;
Assert(LWLockHeldByMe(DSA_SCLASS_LOCK(area, size_class)));
@ -1959,9 +1959,9 @@ unlink_segment(dsa_area *area, dsa_segment_map *segment_map)
* pages map.
*/
static dsa_segment_map *
get_best_segment(dsa_area *area, Size npages)
get_best_segment(dsa_area *area, size_t npages)
{
Size bin;
size_t bin;
Assert(LWLockHeldByMe(DSA_AREA_LOCK(area)));
check_for_freed_segments_locked(area);
@ -1978,7 +1978,7 @@ get_best_segment(dsa_area *area, Size npages)
* The minimum contiguous size that any segment in this bin should
* have. We'll re-bin if we see segments with fewer.
*/
Size threshold = (Size) 1 << (bin - 1);
size_t threshold = (size_t) 1 << (bin - 1);
dsa_segment_index segment_index;
/* Search this bin for a segment with enough contiguous space. */
@ -1987,7 +1987,7 @@ get_best_segment(dsa_area *area, Size npages)
{
dsa_segment_map *segment_map;
dsa_segment_index next_segment_index;
Size contiguous_pages;
size_t contiguous_pages;
segment_map = get_segment_by_index(area, segment_index);
next_segment_index = segment_map->header->next;
@ -2003,7 +2003,7 @@ get_best_segment(dsa_area *area, Size npages)
/* Re-bin it if it's no longer in the appropriate bin. */
if (contiguous_pages < threshold)
{
Size new_bin;
size_t new_bin;
new_bin = contiguous_pages_to_segment_bin(contiguous_pages);
@ -2051,13 +2051,13 @@ get_best_segment(dsa_area *area, Size npages)
* segments would be exceeded.
*/
static dsa_segment_map *
make_new_segment(dsa_area *area, Size requested_pages)
make_new_segment(dsa_area *area, size_t requested_pages)
{
dsa_segment_index new_index;
Size metadata_bytes;
Size total_size;
Size total_pages;
Size usable_pages;
size_t metadata_bytes;
size_t total_size;
size_t total_pages;
size_t usable_pages;
dsa_segment_map *segment_map;
dsm_segment *segment;
@ -2095,7 +2095,7 @@ make_new_segment(dsa_area *area, Size requested_pages)
* pages we can fit.
*/
total_size = DSA_INITIAL_SEGMENT_SIZE *
((Size) 1 << (new_index / DSA_NUM_SEGMENTS_AT_EACH_SIZE));
((size_t) 1 << (new_index / DSA_NUM_SEGMENTS_AT_EACH_SIZE));
total_size = Min(total_size, DSA_MAX_SEGMENT_SIZE);
total_size = Min(total_size,
area->control->max_total_segment_size -
@ -2222,7 +2222,7 @@ make_new_segment(dsa_area *area, Size requested_pages)
static void
check_for_freed_segments(dsa_area *area)
{
Size freed_segment_counter;
size_t freed_segment_counter;
/*
* Any other process that has freed a segment has incremented
@ -2258,7 +2258,7 @@ check_for_freed_segments(dsa_area *area)
static void
check_for_freed_segments_locked(dsa_area *area)
{
Size freed_segment_counter;
size_t freed_segment_counter;
int i;
Assert(LWLockHeldByMe(DSA_AREA_LOCK(area)));

10
src/include/utils/dsa.h
Unescape View File

@ -22,7 +22,7 @@ struct dsa_area;
typedef struct dsa_area dsa_area;
/*
* If this system only uses a 32-bit value for Size, then use the 32-bit
* If this system only uses a 32-bit value for size_t, then use the 32-bit
* implementation of DSA. This limits the amount of DSA that can be created
* to something significantly less than the entire 4GB address space because
* the DSA pointer must encode both a segment identifier and an offset, but
@ -102,7 +102,7 @@ typedef dsm_handle dsa_handle;
extern void dsa_startup(void);
extern dsa_area *dsa_create(int tranche_id);
extern dsa_area *dsa_create_in_place(void *place, Size size,
extern dsa_area *dsa_create_in_place(void *place, size_t size,
int tranche_id, dsm_segment *segment);
extern dsa_area *dsa_attach(dsa_handle handle);
extern dsa_area *dsa_attach_in_place(void *place, dsm_segment *segment);
@ -113,10 +113,10 @@ extern void dsa_pin_mapping(dsa_area *area);
extern void dsa_detach(dsa_area *area);
extern void dsa_pin(dsa_area *area);
extern void dsa_unpin(dsa_area *area);
extern void dsa_set_size_limit(dsa_area *area, Size limit);
extern Size dsa_minimum_size(void);
extern void dsa_set_size_limit(dsa_area *area, size_t limit);
extern size_t dsa_minimum_size(void);
extern dsa_handle dsa_get_handle(dsa_area *area);
extern dsa_pointer dsa_allocate_extended(dsa_area *area, Size size, int flags);
extern dsa_pointer dsa_allocate_extended(dsa_area *area, size_t size, int flags);
extern void dsa_free(dsa_area *area, dsa_pointer dp);
extern void *dsa_get_address(dsa_area *area, dsa_pointer dp);
extern void dsa_trim(dsa_area *area);

Write Preview
Loading…
Cancel
Save