PostgreSQL Source Code  git master
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
dsa.h File Reference
#include "port/atomics.h"
#include "storage/dsm.h"
Include dependency graph for dsa.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define SIZEOF_DSA_POINTER   8
 
#define dsa_pointer_atomic_init   pg_atomic_init_u64
 
#define dsa_pointer_atomic_read   pg_atomic_read_u64
 
#define dsa_pointer_atomic_write   pg_atomic_write_u64
 
#define dsa_pointer_atomic_fetch_add   pg_atomic_fetch_add_u64
 
#define dsa_pointer_atomic_compare_exchange   pg_atomic_compare_exchange_u64
 
#define DSA_POINTER_FORMAT   "%016" INT64_MODIFIER "x"
 
#define DSA_ALLOC_HUGE   0x01 /* allow huge allocation (> 1 GB) */
 
#define DSA_ALLOC_NO_OOM   0x02 /* no failure if out-of-memory */
 
#define DSA_ALLOC_ZERO   0x04 /* zero allocated memory */
 
#define InvalidDsaPointer   ((dsa_pointer) 0)
 
#define DsaPointerIsValid(x)   ((x) != InvalidDsaPointer)
 
#define dsa_allocate(area, size)   dsa_allocate_extended(area, size, 0)
 
#define dsa_allocate0(area, size)   dsa_allocate_extended(area, size, DSA_ALLOC_ZERO)
 

Typedefs

typedef struct dsa_area dsa_area
 
typedef uint64 dsa_pointer
 
typedef pg_atomic_uint64 dsa_pointer_atomic
 
typedef dsm_handle dsa_handle
 

Functions

void dsa_startup (void)
 
dsa_areadsa_create (int tranche_id)
 
dsa_areadsa_create_in_place (void *place, Size size, int tranche_id, dsm_segment *segment)
 
dsa_areadsa_attach (dsa_handle handle)
 
dsa_areadsa_attach_in_place (void *place, dsm_segment *segment)
 
void dsa_release_in_place (void *place)
 
void dsa_on_dsm_detach_release_in_place (dsm_segment *, Datum)
 
void dsa_on_shmem_exit_release_in_place (int, Datum)
 
void dsa_pin_mapping (dsa_area *area)
 
void dsa_detach (dsa_area *area)
 
void dsa_pin (dsa_area *area)
 
void dsa_unpin (dsa_area *area)
 
void dsa_set_size_limit (dsa_area *area, Size limit)
 
Size dsa_minimum_size (void)
 
dsa_handle dsa_get_handle (dsa_area *area)
 
dsa_pointer dsa_allocate_extended (dsa_area *area, Size size, int flags)
 
void dsa_free (dsa_area *area, dsa_pointer dp)
 
void * dsa_get_address (dsa_area *area, dsa_pointer dp)
 
void dsa_trim (dsa_area *area)
 
void dsa_dump (dsa_area *area)
 

Macro Definition Documentation

#define DSA_ALLOC_HUGE   0x01 /* allow huge allocation (> 1 GB) */

Definition at line 73 of file dsa.h.

Referenced by dsa_allocate_extended(), and pagetable_allocate().

#define DSA_ALLOC_NO_OOM   0x02 /* no failure if out-of-memory */

Definition at line 74 of file dsa.h.

Referenced by dsa_allocate_extended().

#define DSA_ALLOC_ZERO   0x04 /* zero allocated memory */

Definition at line 75 of file dsa.h.

Referenced by dsa_allocate_extended(), and pagetable_allocate().

#define dsa_allocate (   area,
  size 
)    dsa_allocate_extended(area, size, 0)

Definition at line 84 of file dsa.h.

Referenced by dshash_create(), insert_into_bucket(), and tbm_prepare_shared_iterate().

#define dsa_allocate0 (   area,
  size 
)    dsa_allocate_extended(area, size, DSA_ALLOC_ZERO)

Definition at line 88 of file dsa.h.

Referenced by resize(), and tbm_prepare_shared_iterate().

#define dsa_pointer_atomic_compare_exchange   pg_atomic_compare_exchange_u64

Definition at line 68 of file dsa.h.

#define dsa_pointer_atomic_fetch_add   pg_atomic_fetch_add_u64

Definition at line 67 of file dsa.h.

#define dsa_pointer_atomic_init   pg_atomic_init_u64

Definition at line 64 of file dsa.h.

#define dsa_pointer_atomic_read   pg_atomic_read_u64

Definition at line 65 of file dsa.h.

#define dsa_pointer_atomic_write   pg_atomic_write_u64

Definition at line 66 of file dsa.h.

#define DSA_POINTER_FORMAT   "%016" INT64_MODIFIER "x"

Definition at line 69 of file dsa.h.

Referenced by dsa_dump().

#define SIZEOF_DSA_POINTER   8

Definition at line 42 of file dsa.h.

Typedef Documentation

Definition at line 22 of file dsa.h.

Definition at line 100 of file dsa.h.

Definition at line 62 of file dsa.h.

Definition at line 63 of file dsa.h.

Function Documentation

dsa_pointer dsa_allocate_extended ( dsa_area area,
Size  size,
int  flags 
)

Definition at line 664 of file dsa.c.

References alloc_object(), AllocHugeSizeIsValid, AllocSizeIsValid, Assert, dsa_area::control, DSA_ALLOC_HUGE, DSA_ALLOC_NO_OOM, DSA_ALLOC_ZERO, DSA_AREA_LOCK, dsa_free(), dsa_get_address(), DSA_MAKE_POINTER, DSA_SCLASS_BLOCK_OF_SPANS, DSA_SCLASS_LOCK, DSA_SCLASS_SPAN_LARGE, DSA_SIZE_CLASS_MAP_QUANTUM, dsa_size_classes, DsaPointerIsValid, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, FATAL, dsa_segment_map::fpm, FPM_PAGE_SIZE, fpm_size_to_pages, FreePageManagerGet(), get_best_segment(), get_segment_index, init_span(), InvalidDsaPointer, lengthof, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), make_new_segment(), MCXT_ALLOC_NO_OOM, NULL, dsa_segment_map::pagemap, dsa_area_control::pools, and result.

Referenced by pagetable_allocate().

665 {
666  uint16 size_class;
667  dsa_pointer start_pointer;
668  dsa_segment_map *segment_map;
670 
671  Assert(size > 0);
672 
673  /* Sanity check on huge individual allocation size. */
674  if (((flags & DSA_ALLOC_HUGE) != 0 && !AllocHugeSizeIsValid(size)) ||
675  ((flags & DSA_ALLOC_HUGE) == 0 && !AllocSizeIsValid(size)))
676  elog(ERROR, "invalid DSA memory alloc request size %zu", size);
677 
678  /*
679  * If bigger than the largest size class, just grab a run of pages from
680  * the free page manager, instead of allocating an object from a pool.
681  * There will still be a span, but it's a special class of span that
682  * manages this whole allocation and simply gives all pages back to the
683  * free page manager when dsa_free is called.
684  */
685  if (size > dsa_size_classes[lengthof(dsa_size_classes) - 1])
686  {
687  Size npages = fpm_size_to_pages(size);
688  Size first_page;
689  dsa_pointer span_pointer;
691 
692  /* Obtain a span object. */
693  span_pointer = alloc_object(area, DSA_SCLASS_BLOCK_OF_SPANS);
694  if (!DsaPointerIsValid(span_pointer))
695  return InvalidDsaPointer;
696 
698 
699  /* Find a segment from which to allocate. */
700  segment_map = get_best_segment(area, npages);
701  if (segment_map == NULL)
702  segment_map = make_new_segment(area, npages);
703  if (segment_map == NULL)
704  {
705  /* Can't make any more segments: game over. */
707  dsa_free(area, span_pointer);
708 
709  /* Raise error unless asked not to. */
710  if ((flags & MCXT_ALLOC_NO_OOM) == 0)
711  ereport(ERROR,
712  (errcode(ERRCODE_OUT_OF_MEMORY),
713  errmsg("out of memory"),
714  errdetail("Failed on DSA request of size %zu.",
715  size)));
716  return InvalidDsaPointer;
717  }
718 
719  /*
720  * Ask the free page manager for a run of pages. This should always
721  * succeed, since both get_best_segment and make_new_segment should
722  * only return a non-NULL pointer if it actually contains enough
723  * contiguous freespace. If it does fail, something in our backend
724  * private state is out of whack, so use FATAL to kill the process.
725  */
726  if (!FreePageManagerGet(segment_map->fpm, npages, &first_page))
727  elog(FATAL,
728  "dsa_allocate could not find %zu free pages", npages);
730 
731  start_pointer = DSA_MAKE_POINTER(get_segment_index(area, segment_map),
732  first_page * FPM_PAGE_SIZE);
733 
734  /* Initialize span and pagemap. */
736  LW_EXCLUSIVE);
737  init_span(area, span_pointer, pool, start_pointer, npages,
739  segment_map->pagemap[first_page] = span_pointer;
741 
742  /* Zero-initialize the memory if requested. */
743  if ((flags & DSA_ALLOC_ZERO) != 0)
744  memset(dsa_get_address(area, start_pointer), 0, size);
745 
746  return start_pointer;
747  }
748 
749  /* Map allocation to a size class. */
751  {
752  int mapidx;
753 
754  /* For smaller sizes we have a lookup table... */
755  mapidx = ((size + DSA_SIZE_CLASS_MAP_QUANTUM - 1) /
756  DSA_SIZE_CLASS_MAP_QUANTUM) - 1;
757  size_class = dsa_size_class_map[mapidx];
758  }
759  else
760  {
761  uint16 min;
762  uint16 max;
763 
764  /* ... and for the rest we search by binary chop. */
766  max = lengthof(dsa_size_classes) - 1;
767 
768  while (min < max)
769  {
770  uint16 mid = (min + max) / 2;
771  uint16 class_size = dsa_size_classes[mid];
772 
773  if (class_size < size)
774  min = mid + 1;
775  else
776  max = mid;
777  }
778 
779  size_class = min;
780  }
781  Assert(size <= dsa_size_classes[size_class]);
782  Assert(size_class == 0 || size > dsa_size_classes[size_class - 1]);
783 
784  /* Attempt to allocate an object from the appropriate pool. */
785  result = alloc_object(area, size_class);
786 
787  /* Check for failure to allocate. */
788  if (!DsaPointerIsValid(result))
789  {
790  /* Raise error unless asked not to. */
791  if ((flags & DSA_ALLOC_NO_OOM) == 0)
792  {
793  ereport(ERROR,
794  (errcode(ERRCODE_OUT_OF_MEMORY),
795  errmsg("out of memory"),
796  errdetail("Failed on DSA request of size %zu.", size)));
797  }
798  return InvalidDsaPointer;
799  }
800 
801  /* Zero-initialize the memory if requested. */
802  if ((flags & DSA_ALLOC_ZERO) != 0)
803  memset(dsa_get_address(area, result), 0, size);
804 
805  return result;
806 }
#define DSA_ALLOC_NO_OOM
Definition: dsa.h:74
#define InvalidDsaPointer
Definition: dsa.h:78
#define DSA_ALLOC_ZERO
Definition: dsa.h:75
static char dsa_size_class_map[]
Definition: dsa.c:259
#define fpm_size_to_pages(sz)
Definition: freepage.h:74
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:18
int errcode(int sqlerrcode)
Definition: elog.c:575
return result
Definition: formatting.c:1633
static dsa_segment_map * get_best_segment(dsa_area *area, Size npages)
Definition: dsa.c:1942
#define lengthof(array)
Definition: c.h:562
uint64 dsa_pointer
Definition: dsa.h:62
FreePageManager * fpm
Definition: dsa.c:344
#define get_segment_index(area, segment_map_ptr)
Definition: dsa.c:381
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
void * dsa_get_address(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:924
bool FreePageManagerGet(FreePageManager *fpm, Size npages, Size *first_page)
Definition: freepage.c:210
unsigned short uint16
Definition: c.h:267
#define ERROR
Definition: elog.h:43
#define FATAL
Definition: elog.h:52
dsa_area_control * control
Definition: dsa.c:357
int errdetail(const char *fmt,...)
Definition: elog.c:873
#define ereport(elevel, rest)
Definition: elog.h:122
static const uint16 dsa_size_classes[]
Definition: dsa.c:236
#define AllocSizeIsValid(size)
Definition: memutils.h:42
static void init_span(dsa_area *area, dsa_pointer span_pointer, dsa_area_pool *pool, dsa_pointer start, Size npages, uint16 size_class)
Definition: dsa.c:1336
static dsa_segment_map * make_new_segment(dsa_area *area, Size requested_pages)
Definition: dsa.c:2033
#define DSA_SCLASS_LOCK(area, sclass)
Definition: dsa.c:144
#define DSA_SIZE_CLASS_MAP_QUANTUM
Definition: dsa.c:269
#define FPM_PAGE_SIZE
Definition: freepage.h:30
#define DSA_SCLASS_BLOCK_OF_SPANS
Definition: dsa.c:250
#define DSA_ALLOC_HUGE
Definition: dsa.h:73
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:676
#define DSA_MAKE_POINTER(segment_number, offset)
Definition: dsa.c:114
dsa_area_pool pools[DSA_NUM_SIZE_CLASSES]
Definition: dsa.c:309
size_t Size
Definition: c.h:356
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
dsa_pointer * pagemap
Definition: dsa.c:345
#define AllocHugeSizeIsValid(size)
Definition: memutils.h:46
#define DsaPointerIsValid(x)
Definition: dsa.h:81
void dsa_free(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:812
int errmsg(const char *fmt,...)
Definition: elog.c:797
static dsa_pointer alloc_object(dsa_area *area, int size_class)
Definition: dsa.c:1431
#define elog
Definition: elog.h:219
#define DSA_AREA_LOCK(area)
Definition: dsa.c:143
#define DSA_SCLASS_SPAN_LARGE
Definition: dsa.c:251
dsa_area* dsa_attach ( dsa_handle  handle)

Definition at line 505 of file dsa.c.

References attach_internal(), dsa_on_dsm_detach_release_in_place(), dsm_attach(), dsm_segment_address(), ereport, errcode(), errmsg(), ERROR, NULL, on_dsm_detach(), and PointerGetDatum.

506 {
507  dsm_segment *segment;
508  dsa_area *area;
509 
510  /*
511  * An area handle is really a DSM segment handle for the first segment, so
512  * we go ahead and attach to that.
513  */
514  segment = dsm_attach(handle);
515  if (segment == NULL)
516  ereport(ERROR,
517  (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
518  errmsg("could not attach to dynamic shared area")));
519 
520  area = attach_internal(dsm_segment_address(segment), segment, handle);
521 
522  /* Clean up when the control segment detaches. */
525 
526  return area;
527 }
#define PointerGetDatum(X)
Definition: postgres.h:562
dsm_segment * dsm_attach(dsm_handle h)
Definition: dsm.c:561
int errcode(int sqlerrcode)
Definition: elog.c:575
static dsa_area * attach_internal(void *place, dsm_segment *segment, dsa_handle handle)
Definition: dsa.c:1285
void on_dsm_detach(dsm_segment *seg, on_dsm_detach_callback function, Datum arg)
Definition: dsm.c:1037
#define ERROR
Definition: elog.h:43
#define ereport(elevel, rest)
Definition: elog.h:122
void dsa_on_dsm_detach_release_in_place(dsm_segment *segment, Datum place)
Definition: dsa.c:571
#define NULL
Definition: c.h:229
void * dsm_segment_address(dsm_segment *seg)
Definition: dsm.c:1000
Definition: dsa.c:354
int errmsg(const char *fmt,...)
Definition: elog.c:797
dsa_area* dsa_attach_in_place ( void *  place,
dsm_segment segment 
)

Definition at line 540 of file dsa.c.

References attach_internal(), dsa_on_dsm_detach_release_in_place(), DSM_HANDLE_INVALID, NULL, on_dsm_detach(), and PointerGetDatum.

Referenced by ParallelQueryMain().

541 {
542  dsa_area *area;
543 
544  area = attach_internal(place, NULL, DSM_HANDLE_INVALID);
545 
546  /*
547  * Clean up when the control segment detaches, if a containing DSM segment
548  * was provided.
549  */
550  if (segment != NULL)
552  PointerGetDatum(place));
553 
554  return area;
555 }
#define PointerGetDatum(X)
Definition: postgres.h:562
static dsa_area * attach_internal(void *place, dsm_segment *segment, dsa_handle handle)
Definition: dsa.c:1285
void on_dsm_detach(dsm_segment *seg, on_dsm_detach_callback function, Datum arg)
Definition: dsm.c:1037
#define DSM_HANDLE_INVALID
Definition: dsm.h:23
void dsa_on_dsm_detach_release_in_place(dsm_segment *segment, Datum place)
Definition: dsa.c:571
#define NULL
Definition: c.h:229
Definition: dsa.c:354
dsa_area* dsa_create ( int  tranche_id)

Definition at line 419 of file dsa.c.

References create_internal(), DSA_INITIAL_SEGMENT_SIZE, dsa_on_dsm_detach_release_in_place(), dsm_create(), dsm_pin_segment(), dsm_segment_address(), dsm_segment_handle(), on_dsm_detach(), and PointerGetDatum.

420 {
421  dsm_segment *segment;
422  dsa_area *area;
423 
424  /*
425  * Create the DSM segment that will hold the shared control object and the
426  * first segment of usable space.
427  */
428  segment = dsm_create(DSA_INITIAL_SEGMENT_SIZE, 0);
429 
430  /*
431  * All segments backing this area are pinned, so that DSA can explicitly
432  * control their lifetime (otherwise a newly created segment belonging to
433  * this area might be freed when the only backend that happens to have it
434  * mapped in ends, corrupting the area).
435  */
436  dsm_pin_segment(segment);
437 
438  /* Create a new DSA area with the control object in this segment. */
439  area = create_internal(dsm_segment_address(segment),
441  tranche_id,
442  dsm_segment_handle(segment), segment);
443 
444  /* Clean up when the control segment detaches. */
447 
448  return area;
449 }
#define PointerGetDatum(X)
Definition: postgres.h:562
dsm_handle dsm_segment_handle(dsm_segment *seg)
Definition: dsm.c:1028
void on_dsm_detach(dsm_segment *seg, on_dsm_detach_callback function, Datum arg)
Definition: dsm.c:1037
void dsm_pin_segment(dsm_segment *seg)
Definition: dsm.c:867
#define DSA_INITIAL_SEGMENT_SIZE
Definition: dsa.c:68
static dsa_area * create_internal(void *place, size_t size, int tranche_id, dsm_handle control_handle, dsm_segment *control_segment)
Definition: dsa.c:1182
void dsa_on_dsm_detach_release_in_place(dsm_segment *segment, Datum place)
Definition: dsa.c:571
dsm_segment * dsm_create(Size size, int flags)
Definition: dsm.c:465
void * dsm_segment_address(dsm_segment *seg)
Definition: dsm.c:1000
Definition: dsa.c:354
dsa_area* dsa_create_in_place ( void *  place,
Size  size,
int  tranche_id,
dsm_segment segment 
)

Definition at line 468 of file dsa.c.

References create_internal(), dsa_on_dsm_detach_release_in_place(), DSM_HANDLE_INVALID, NULL, on_dsm_detach(), and PointerGetDatum.

Referenced by ExecInitParallelPlan().

470 {
471  dsa_area *area;
472 
473  area = create_internal(place, size, tranche_id,
475 
476  /*
477  * Clean up when the control segment detaches, if a containing DSM segment
478  * was provided.
479  */
480  if (segment != NULL)
482  PointerGetDatum(place));
483 
484  return area;
485 }
#define PointerGetDatum(X)
Definition: postgres.h:562
void on_dsm_detach(dsm_segment *seg, on_dsm_detach_callback function, Datum arg)
Definition: dsm.c:1037
#define DSM_HANDLE_INVALID
Definition: dsm.h:23
static dsa_area * create_internal(void *place, size_t size, int tranche_id, dsm_handle control_handle, dsm_segment *control_segment)
Definition: dsa.c:1182
void dsa_on_dsm_detach_release_in_place(dsm_segment *segment, Datum place)
Definition: dsa.c:571
#define NULL
Definition: c.h:229
Definition: dsa.c:354
void dsa_detach ( dsa_area area)

Definition at line 1884 of file dsa.c.

References dsm_detach(), dsa_area::high_segment_index, i, NULL, pfree(), dsa_segment_map::segment, and dsa_area::segment_maps.

Referenced by ExecParallelCleanup(), and ParallelQueryMain().

1885 {
1886  int i;
1887 
1888  /* Detach from all segments. */
1889  for (i = 0; i <= area->high_segment_index; ++i)
1890  if (area->segment_maps[i].segment != NULL)
1891  dsm_detach(area->segment_maps[i].segment);
1892 
1893  /*
1894  * Note that 'detaching' (= detaching from DSM segments) doesn't include
1895  * 'releasing' (= adjusting the reference count). It would be nice to
1896  * combine these operations, but client code might never get around to
1897  * calling dsa_detach because of an error path, and a detach hook on any
1898  * particular segment is too late to detach other segments in the area
1899  * without risking a 'leak' warning in the non-error path.
1900  */
1901 
1902  /* Free the backend-local area object. */
1903  pfree(area);
1904 }
dsa_segment_index high_segment_index
Definition: dsa.c:371
dsm_segment * segment
Definition: dsa.c:341
void pfree(void *pointer)
Definition: mcxt.c:950
#define NULL
Definition: c.h:229
dsa_segment_map segment_maps[DSA_MAX_SEGMENTS]
Definition: dsa.c:368
void dsm_detach(dsm_segment *seg)
Definition: dsm.c:726
int i
void dsa_dump ( dsa_area area)

Definition at line 1057 of file dsa.c.

References dsa_area::control, DSA_AREA_LOCK, DSA_FULLNESS_CLASSES, dsa_get_address(), DSA_NUM_SEGMENT_BINS, DSA_NUM_SIZE_CLASSES, DSA_POINTER_FORMAT, DSA_SCLASS_BLOCK_OF_SPANS, DSA_SCLASS_LOCK, DSA_SCLASS_SPAN_LARGE, DSA_SEGMENT_INDEX_NONE, dsa_size_classes, DsaPointerIsValid, dsa_segment_map::fpm, fpm_largest, get_segment_by_index(), dsa_area_control::handle, dsa_segment_map::header, i, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsa_segment_map::mapped_address, dsa_area_control::max_total_segment_size, dsa_area_span::nallocatable, dsa_segment_header::next, dsa_area_span::nextspan, dsa_area_span::nmax, dsa_area_span::npages, dsa_area_control::pinned, dsa_area_control::pools, dsa_area_control::refcnt, dsa_area_control::segment_bins, dsa_area_pool::spans, dsa_area_span::start, dsa_area_control::total_segment_size, and dsa_segment_header::usable_pages.

1058 {
1059  Size i,
1060  j;
1061 
1062  /*
1063  * Note: This gives an inconsistent snapshot as it acquires and releases
1064  * individual locks as it goes...
1065  */
1066 
1068  fprintf(stderr, "dsa_area handle %x:\n", area->control->handle);
1069  fprintf(stderr, " max_total_segment_size: %zu\n",
1071  fprintf(stderr, " total_segment_size: %zu\n",
1072  area->control->total_segment_size);
1073  fprintf(stderr, " refcnt: %d\n", area->control->refcnt);
1074  fprintf(stderr, " pinned: %c\n", area->control->pinned ? 't' : 'f');
1075  fprintf(stderr, " segment bins:\n");
1076  for (i = 0; i < DSA_NUM_SEGMENT_BINS; ++i)
1077  {
1078  if (area->control->segment_bins[i] != DSA_SEGMENT_INDEX_NONE)
1079  {
1080  dsa_segment_index segment_index;
1081 
1082  fprintf(stderr,
1083  " segment bin %zu (at least %d contiguous pages free):\n",
1084  i, 1 << (i - 1));
1085  segment_index = area->control->segment_bins[i];
1086  while (segment_index != DSA_SEGMENT_INDEX_NONE)
1087  {
1088  dsa_segment_map *segment_map;
1089 
1090  segment_map =
1091  get_segment_by_index(area, segment_index);
1092 
1093  fprintf(stderr,
1094  " segment index %zu, usable_pages = %zu, "
1095  "contiguous_pages = %zu, mapped at %p\n",
1096  segment_index,
1097  segment_map->header->usable_pages,
1098  fpm_largest(segment_map->fpm),
1099  segment_map->mapped_address);
1100  segment_index = segment_map->header->next;
1101  }
1102  }
1103  }
1105 
1106  fprintf(stderr, " pools:\n");
1107  for (i = 0; i < DSA_NUM_SIZE_CLASSES; ++i)
1108  {
1109  bool found = false;
1110 
1112  for (j = 0; j < DSA_FULLNESS_CLASSES; ++j)
1113  if (DsaPointerIsValid(area->control->pools[i].spans[j]))
1114  found = true;
1115  if (found)
1116  {
1117  if (i == DSA_SCLASS_BLOCK_OF_SPANS)
1118  fprintf(stderr, " pool for blocks of span objects:\n");
1119  else if (i == DSA_SCLASS_SPAN_LARGE)
1120  fprintf(stderr, " pool for large object spans:\n");
1121  else
1122  fprintf(stderr,
1123  " pool for size class %zu (object size %hu bytes):\n",
1124  i, dsa_size_classes[i]);
1125  for (j = 0; j < DSA_FULLNESS_CLASSES; ++j)
1126  {
1127  if (!DsaPointerIsValid(area->control->pools[i].spans[j]))
1128  fprintf(stderr, " fullness class %zu is empty\n", j);
1129  else
1130  {
1131  dsa_pointer span_pointer = area->control->pools[i].spans[j];
1132 
1133  fprintf(stderr, " fullness class %zu:\n", j);
1134  while (DsaPointerIsValid(span_pointer))
1135  {
1136  dsa_area_span *span;
1137 
1138  span = dsa_get_address(area, span_pointer);
1139  fprintf(stderr,
1140  " span descriptor at "
1141  DSA_POINTER_FORMAT ", superblock at "
1143  ", pages = %zu, objects free = %hu/%hu\n",
1144  span_pointer, span->start, span->npages,
1145  span->nallocatable, span->nmax);
1146  span_pointer = span->nextspan;
1147  }
1148  }
1149  }
1150  }
1151  LWLockRelease(DSA_SCLASS_LOCK(area, i));
1152  }
1153 }
uint16 nmax
Definition: dsa.c:205
dsa_segment_index segment_bins[DSA_NUM_SEGMENT_BINS]
Definition: dsa.c:307
dsa_pointer nextspan
Definition: dsa.c:198
Size max_total_segment_size
Definition: dsa.c:313
#define DSA_NUM_SIZE_CLASSES
Definition: dsa.c:247
bool pinned
Definition: dsa.c:319
#define DSA_FULLNESS_CLASSES
Definition: dsa.c:277
dsa_pointer start
Definition: dsa.c:199
uint64 dsa_pointer
Definition: dsa.h:62
FreePageManager * fpm
Definition: dsa.c:344
dsa_segment_header * header
Definition: dsa.c:343
Size total_segment_size
Definition: dsa.c:311
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
void * dsa_get_address(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:924
#define DSA_POINTER_FORMAT
Definition: dsa.h:69
int refcnt
Definition: dsa.c:317
dsa_segment_index next
Definition: dsa.c:170
dsa_area_control * control
Definition: dsa.c:357
#define DSA_NUM_SEGMENT_BINS
Definition: dsa.c:133
static const uint16 dsa_size_classes[]
Definition: dsa.c:236
Size dsa_segment_index
Definition: dsa.c:124
Size npages
Definition: dsa.c:200
#define DSA_SCLASS_LOCK(area, sclass)
Definition: dsa.c:144
#define DSA_SCLASS_BLOCK_OF_SPANS
Definition: dsa.c:250
#define fpm_largest(fpm)
Definition: freepage.h:88
#define DSA_SEGMENT_INDEX_NONE
Definition: dsa.c:127
dsa_area_pool pools[DSA_NUM_SIZE_CLASSES]
Definition: dsa.c:309
size_t Size
Definition: c.h:356
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
dsa_pointer spans[DSA_FULLNESS_CLASSES]
Definition: dsa.c:290
char * mapped_address
Definition: dsa.c:342
#define DsaPointerIsValid(x)
Definition: dsa.h:81
Size usable_pages
Definition: dsa.c:156
uint16 nallocatable
Definition: dsa.c:203
int i
#define DSA_AREA_LOCK(area)
Definition: dsa.c:143
#define DSA_SCLASS_SPAN_LARGE
Definition: dsa.c:251
dsa_handle handle
Definition: dsa.c:303
static dsa_segment_map * get_segment_by_index(dsa_area *area, dsa_segment_index index)
Definition: dsa.c:1714
void dsa_free ( dsa_area area,
dsa_pointer  dp 
)

Definition at line 812 of file dsa.c.

References add_span_to_fullness_class(), Assert, check_for_freed_segments(), destroy_superblock(), DSA_AREA_LOCK, DSA_EXTRACT_OFFSET, DSA_EXTRACT_SEGMENT_NUMBER, dsa_free(), DSA_FULLNESS_CLASSES, dsa_get_address(), DSA_SCLASS_LOCK, DSA_SCLASS_SPAN_LARGE, dsa_size_classes, DSA_SUPERBLOCK_SIZE, dsa_area_span::fclass, dsa_area_span::firstfree, dsa_segment_map::fpm, FPM_PAGE_SIZE, FreePageManagerPut(), get_segment_by_index(), InvalidDsaPointer, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsa_area_span::nallocatable, NextFreeObjectIndex, dsa_area_span::nmax, dsa_area_span::npages, dsa_segment_map::pagemap, dsa_area_span::prevspan, dsa_area_span::size_class, dsa_area_span::start, and unlink_span().

Referenced by delete_item_from_bucket(), delete_key_from_bucket(), destroy_superblock(), dsa_allocate_extended(), dsa_free(), dshash_destroy(), ensure_active_superblock(), pagetable_free(), resize(), and tbm_free_shared_area().

813 {
814  dsa_segment_map *segment_map;
815  int pageno;
816  dsa_pointer span_pointer;
817  dsa_area_span *span;
818  char *superblock;
819  char *object;
820  Size size;
821  int size_class;
822 
823  /* Make sure we don't have a stale segment in the slot 'dp' refers to. */
825 
826  /* Locate the object, span and pool. */
827  segment_map = get_segment_by_index(area, DSA_EXTRACT_SEGMENT_NUMBER(dp));
828  pageno = DSA_EXTRACT_OFFSET(dp) / FPM_PAGE_SIZE;
829  span_pointer = segment_map->pagemap[pageno];
830  span = dsa_get_address(area, span_pointer);
831  superblock = dsa_get_address(area, span->start);
832  object = dsa_get_address(area, dp);
833  size_class = span->size_class;
834  size = dsa_size_classes[size_class];
835 
836  /*
837  * Special case for large objects that live in a special span: we return
838  * those pages directly to the free page manager and free the span.
839  */
840  if (span->size_class == DSA_SCLASS_SPAN_LARGE)
841  {
842 
843 #ifdef CLOBBER_FREED_MEMORY
844  memset(object, 0x7f, span->npages * FPM_PAGE_SIZE);
845 #endif
846 
847  /* Give pages back to free page manager. */
849  FreePageManagerPut(segment_map->fpm,
851  span->npages);
853  /* Unlink span. */
855  LW_EXCLUSIVE);
856  unlink_span(area, span);
858  /* Free the span object so it can be reused. */
859  dsa_free(area, span_pointer);
860  return;
861  }
862 
863 #ifdef CLOBBER_FREED_MEMORY
864  memset(object, 0x7f, size);
865 #endif
866 
867  LWLockAcquire(DSA_SCLASS_LOCK(area, size_class), LW_EXCLUSIVE);
868 
869  /* Put the object on the span's freelist. */
870  Assert(object >= superblock);
871  Assert(object < superblock + DSA_SUPERBLOCK_SIZE);
872  Assert((object - superblock) % size == 0);
873  NextFreeObjectIndex(object) = span->firstfree;
874  span->firstfree = (object - superblock) / size;
875  ++span->nallocatable;
876 
877  /*
878  * See if the span needs to moved to a different fullness class, or be
879  * freed so its pages can be given back to the segment.
880  */
881  if (span->nallocatable == 1 && span->fclass == DSA_FULLNESS_CLASSES - 1)
882  {
883  /*
884  * The block was completely full and is located in the
885  * highest-numbered fullness class, which is never scanned for free
886  * chunks. We must move it to the next-lower fullness class.
887  */
888  unlink_span(area, span);
889  add_span_to_fullness_class(area, span, span_pointer,
891 
892  /*
893  * If this is the only span, and there is no active span, then we
894  * should probably move this span to fullness class 1. (Otherwise if
895  * you allocate exactly all the objects in the only span, it moves to
896  * class 3, then you free them all, it moves to 2, and then is given
897  * back, leaving no active span).
898  */
899  }
900  else if (span->nallocatable == span->nmax &&
901  (span->fclass != 1 || span->prevspan != InvalidDsaPointer))
902  {
903  /*
904  * This entire block is free, and it's not the active block for this
905  * size class. Return the memory to the free page manager. We don't
906  * do this for the active block to prevent hysteresis: if we
907  * repeatedly allocate and free the only chunk in the active block, it
908  * will be very inefficient if we deallocate and reallocate the block
909  * every time.
910  */
911  destroy_superblock(area, span_pointer);
912  }
913 
914  LWLockRelease(DSA_SCLASS_LOCK(area, size_class));
915 }
uint16 nmax
Definition: dsa.c:205
#define DSA_SUPERBLOCK_SIZE
Definition: dsa.c:378
#define InvalidDsaPointer
Definition: dsa.h:78
#define DSA_FULLNESS_CLASSES
Definition: dsa.c:277
dsa_pointer start
Definition: dsa.c:199
uint64 dsa_pointer
Definition: dsa.h:62
void FreePageManagerPut(FreePageManager *fpm, Size first_page, Size npages)
Definition: freepage.c:379
FreePageManager * fpm
Definition: dsa.c:344
uint16 fclass
Definition: dsa.c:206
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
void * dsa_get_address(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:924
uint16 size_class
Definition: dsa.c:201
static const uint16 dsa_size_classes[]
Definition: dsa.c:236
static void unlink_span(dsa_area *area, dsa_area_span *span)
Definition: dsa.c:1838
Size npages
Definition: dsa.c:200
#define DSA_SCLASS_LOCK(area, sclass)
Definition: dsa.c:144
dsa_pointer prevspan
Definition: dsa.c:197
#define FPM_PAGE_SIZE
Definition: freepage.h:30
static void add_span_to_fullness_class(dsa_area *area, dsa_area_span *span, dsa_pointer span_pointer, int fclass)
Definition: dsa.c:1861
#define DSA_EXTRACT_SEGMENT_NUMBER(dp)
Definition: dsa.c:118
#define Assert(condition)
Definition: c.h:676
#define DSA_EXTRACT_OFFSET(dp)
Definition: dsa.c:121
size_t Size
Definition: c.h:356
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
dsa_pointer * pagemap
Definition: dsa.c:345
static void destroy_superblock(dsa_area *area, dsa_pointer span_pointer)
Definition: dsa.c:1775
void dsa_free(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:812
uint16 nallocatable
Definition: dsa.c:203
static void check_for_freed_segments(dsa_area *area)
Definition: dsa.c:2202
uint16 firstfree
Definition: dsa.c:204
#define DSA_AREA_LOCK(area)
Definition: dsa.c:143
#define DSA_SCLASS_SPAN_LARGE
Definition: dsa.c:251
#define NextFreeObjectIndex(object)
Definition: dsa.c:213
static dsa_segment_map * get_segment_by_index(dsa_area *area, dsa_segment_index index)
Definition: dsa.c:1714
void* dsa_get_address ( dsa_area area,
dsa_pointer  dp 
)

Definition at line 924 of file dsa.c.

References Assert, check_for_freed_segments(), DSA_EXTRACT_OFFSET, DSA_EXTRACT_SEGMENT_NUMBER, DSA_MAX_SEGMENTS, DsaPointerIsValid, get_segment_by_index(), dsa_segment_map::mapped_address, NULL, dsa_area::segment_maps, and unlikely.

Referenced by add_span_to_fullness_class(), alloc_object(), delete_item_from_bucket(), delete_key_from_bucket(), destroy_superblock(), dsa_allocate_extended(), dsa_dump(), dsa_free(), dsa_trim(), dshash_attach(), dshash_create(), dshash_destroy(), dshash_dump(), ensure_active_superblock(), ensure_valid_bucket_pointers(), find_in_bucket(), init_span(), insert_into_bucket(), insert_item_into_bucket(), pagetable_allocate(), resize(), tbm_attach_shared_iterate(), tbm_free_shared_area(), tbm_prepare_shared_iterate(), transfer_first_span(), and unlink_span().

925 {
927  Size offset;
928 
929  /* Convert InvalidDsaPointer to NULL. */
930  if (!DsaPointerIsValid(dp))
931  return NULL;
932 
933  /* Process any requests to detach from freed segments. */
935 
936  /* Break the dsa_pointer into its components. */
937  index = DSA_EXTRACT_SEGMENT_NUMBER(dp);
938  offset = DSA_EXTRACT_OFFSET(dp);
939  Assert(index < DSA_MAX_SEGMENTS);
940 
941  /* Check if we need to cause this segment to be mapped in. */
942  if (unlikely(area->segment_maps[index].mapped_address == NULL))
943  {
944  /* Call for effect (we don't need the result). */
945  get_segment_by_index(area, index);
946  }
947 
948  return area->segment_maps[index].mapped_address + offset;
949 }
Definition: type.h:89
Size dsa_segment_index
Definition: dsa.c:124
#define NULL
Definition: c.h:229
#define DSA_EXTRACT_SEGMENT_NUMBER(dp)
Definition: dsa.c:118
#define Assert(condition)
Definition: c.h:676
#define DSA_EXTRACT_OFFSET(dp)
Definition: dsa.c:121
size_t Size
Definition: c.h:356
char * mapped_address
Definition: dsa.c:342
#define DSA_MAX_SEGMENTS
Definition: dsa.c:94
#define DsaPointerIsValid(x)
Definition: dsa.h:81
dsa_segment_map segment_maps[DSA_MAX_SEGMENTS]
Definition: dsa.c:368
static void check_for_freed_segments(dsa_area *area)
Definition: dsa.c:2202
#define unlikely(x)
Definition: c.h:963
static dsa_segment_map * get_segment_by_index(dsa_area *area, dsa_segment_index index)
Definition: dsa.c:1714
dsa_handle dsa_get_handle ( dsa_area area)

Definition at line 493 of file dsa.c.

References Assert, dsa_area::control, DSM_HANDLE_INVALID, and dsa_area_control::handle.

494 {
496  return area->control->handle;
497 }
#define DSM_HANDLE_INVALID
Definition: dsm.h:23
dsa_area_control * control
Definition: dsa.c:357
#define Assert(condition)
Definition: c.h:676
dsa_handle handle
Definition: dsa.c:303
Size dsa_minimum_size ( void  )

Definition at line 1160 of file dsa.c.

References FPM_PAGE_SIZE, and MAXALIGN.

Referenced by create_internal(), and ExecInitParallelPlan().

1161 {
1162  Size size;
1163  int pages = 0;
1164 
1165  size = MAXALIGN(sizeof(dsa_area_control)) +
1166  MAXALIGN(sizeof(FreePageManager));
1167 
1168  /* Figure out how many pages we need, including the page map... */
1169  while (((size + FPM_PAGE_SIZE - 1) / FPM_PAGE_SIZE) > pages)
1170  {
1171  ++pages;
1172  size += sizeof(dsa_pointer);
1173  }
1174 
1175  return pages * FPM_PAGE_SIZE;
1176 }
uint64 dsa_pointer
Definition: dsa.h:62
#define FPM_PAGE_SIZE
Definition: freepage.h:30
size_t Size
Definition: c.h:356
#define MAXALIGN(LEN)
Definition: c.h:588
void dsa_on_dsm_detach_release_in_place ( dsm_segment ,
Datum   
)

Definition at line 571 of file dsa.c.

References DatumGetPointer, and dsa_release_in_place().

Referenced by dsa_attach(), dsa_attach_in_place(), dsa_create(), and dsa_create_in_place().

572 {
574 }
void dsa_release_in_place(void *place)
Definition: dsa.c:600
#define DatumGetPointer(X)
Definition: postgres.h:555
void dsa_on_shmem_exit_release_in_place ( int  ,
Datum   
)

Definition at line 585 of file dsa.c.

References DatumGetPointer, and dsa_release_in_place().

586 {
588 }
void dsa_release_in_place(void *place)
Definition: dsa.c:600
#define DatumGetPointer(X)
Definition: postgres.h:555
void dsa_pin ( dsa_area area)

Definition at line 957 of file dsa.c.

References dsa_area::control, DSA_AREA_LOCK, elog, ERROR, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsa_area_control::pinned, and dsa_area_control::refcnt.

958 {
960  if (area->control->pinned)
961  {
963  elog(ERROR, "dsa_area already pinned");
964  }
965  area->control->pinned = true;
966  ++area->control->refcnt;
968 }
bool pinned
Definition: dsa.c:319
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
int refcnt
Definition: dsa.c:317
#define ERROR
Definition: elog.h:43
dsa_area_control * control
Definition: dsa.c:357
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
#define elog
Definition: elog.h:219
#define DSA_AREA_LOCK(area)
Definition: dsa.c:143
void dsa_pin_mapping ( dsa_area area)

Definition at line 630 of file dsa.c.

References Assert, dsm_pin_mapping(), dsa_area::high_segment_index, i, dsa_area::mapping_pinned, NULL, dsa_segment_map::segment, and dsa_area::segment_maps.

631 {
632  int i;
633 
634  Assert(!area->mapping_pinned);
635  area->mapping_pinned = true;
636 
637  for (i = 0; i <= area->high_segment_index; ++i)
638  if (area->segment_maps[i].segment != NULL)
640 }
bool mapping_pinned
Definition: dsa.c:360
dsa_segment_index high_segment_index
Definition: dsa.c:371
dsm_segment * segment
Definition: dsa.c:341
void dsm_pin_mapping(dsm_segment *seg)
Definition: dsm.c:827
#define NULL
Definition: c.h:229
#define Assert(condition)
Definition: c.h:676
dsa_segment_map segment_maps[DSA_MAX_SEGMENTS]
Definition: dsa.c:368
int i
void dsa_release_in_place ( void *  place)

Definition at line 600 of file dsa.c.

References Assert, DSA_SEGMENT_HEADER_MAGIC, DSM_HANDLE_INVALID, dsm_unpin_segment(), dsa_area_control::handle, dsa_area_control::high_segment_index, i, dsa_area_control::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsa_segment_header::magic, dsa_area_control::refcnt, dsa_area_control::segment_handles, and dsa_area_control::segment_header.

Referenced by dsa_on_dsm_detach_release_in_place(), and dsa_on_shmem_exit_release_in_place().

601 {
602  dsa_area_control *control = (dsa_area_control *) place;
603  int i;
604 
605  LWLockAcquire(&control->lock, LW_EXCLUSIVE);
606  Assert(control->segment_header.magic ==
607  (DSA_SEGMENT_HEADER_MAGIC ^ control->handle ^ 0));
608  Assert(control->refcnt > 0);
609  if (--control->refcnt == 0)
610  {
611  for (i = 0; i <= control->high_segment_index; ++i)
612  {
613  dsm_handle handle;
614 
615  handle = control->segment_handles[i];
616  if (handle != DSM_HANDLE_INVALID)
617  dsm_unpin_segment(handle);
618  }
619  }
620  LWLockRelease(&control->lock);
621 }
uint32 dsm_handle
Definition: dsm_impl.h:55
dsa_segment_index high_segment_index
Definition: dsa.c:315
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
#define DSM_HANDLE_INVALID
Definition: dsm.h:23
LWLock lock
Definition: dsa.c:325
int refcnt
Definition: dsa.c:317
void dsm_unpin_segment(dsm_handle handle)
Definition: dsm.c:899
dsa_segment_header segment_header
Definition: dsa.c:301
#define Assert(condition)
Definition: c.h:676
dsm_handle segment_handles[DSA_MAX_SEGMENTS]
Definition: dsa.c:305
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
int i
#define DSA_SEGMENT_HEADER_MAGIC
Definition: dsa.c:111
uint32 magic
Definition: dsa.c:154
dsa_handle handle
Definition: dsa.c:303
void dsa_set_size_limit ( dsa_area area,
Size  limit 
)

Definition at line 1000 of file dsa.c.

References dsa_area::control, DSA_AREA_LOCK, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), and dsa_area_control::max_total_segment_size.

1001 {
1003  area->control->max_total_segment_size = limit;
1005 }
Size max_total_segment_size
Definition: dsa.c:313
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
dsa_area_control * control
Definition: dsa.c:357
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
#define DSA_AREA_LOCK(area)
Definition: dsa.c:143
void dsa_startup ( void  )
void dsa_trim ( dsa_area area)

Definition at line 1012 of file dsa.c.

References dsa_area::control, destroy_superblock(), dsa_get_address(), DSA_NUM_SIZE_CLASSES, DSA_SCLASS_LOCK, DSA_SCLASS_SPAN_LARGE, DsaPointerIsValid, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsa_area_span::nallocatable, next, dsa_area_span::nextspan, dsa_area_span::nmax, dsa_area_control::pools, and dsa_area_pool::spans.

1013 {
1014  int size_class;
1015 
1016  /*
1017  * Trim in reverse pool order so we get to the spans-of-spans last, just
1018  * in case any become entirely free while processing all the other pools.
1019  */
1020  for (size_class = DSA_NUM_SIZE_CLASSES - 1; size_class >= 0; --size_class)
1021  {
1022  dsa_area_pool *pool = &area->control->pools[size_class];
1023  dsa_pointer span_pointer;
1024 
1025  if (size_class == DSA_SCLASS_SPAN_LARGE)
1026  {
1027  /* Large object frees give back segments aggressively already. */
1028  continue;
1029  }
1030 
1031  /*
1032  * Search fullness class 1 only. That is where we expect to find an
1033  * entirely empty superblock (entirely empty superblocks in other
1034  * fullness classes are returned to the free page map by dsa_free).
1035  */
1036  LWLockAcquire(DSA_SCLASS_LOCK(area, size_class), LW_EXCLUSIVE);
1037  span_pointer = pool->spans[1];
1038  while (DsaPointerIsValid(span_pointer))
1039  {
1040  dsa_area_span *span = dsa_get_address(area, span_pointer);
1041  dsa_pointer next = span->nextspan;
1042 
1043  if (span->nallocatable == span->nmax)
1044  destroy_superblock(area, span_pointer);
1045 
1046  span_pointer = next;
1047  }
1048  LWLockRelease(DSA_SCLASS_LOCK(area, size_class));
1049  }
1050 }
uint16 nmax
Definition: dsa.c:205
dsa_pointer nextspan
Definition: dsa.c:198
static int32 next
Definition: blutils.c:210
#define DSA_NUM_SIZE_CLASSES
Definition: dsa.c:247
uint64 dsa_pointer
Definition: dsa.h:62
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
void * dsa_get_address(dsa_area *area, dsa_pointer dp)
Definition: dsa.c:924
dsa_area_control * control
Definition: dsa.c:357
#define DSA_SCLASS_LOCK(area, sclass)
Definition: dsa.c:144
dsa_area_pool pools[DSA_NUM_SIZE_CLASSES]
Definition: dsa.c:309
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
dsa_pointer spans[DSA_FULLNESS_CLASSES]
Definition: dsa.c:290
#define DsaPointerIsValid(x)
Definition: dsa.h:81
static void destroy_superblock(dsa_area *area, dsa_pointer span_pointer)
Definition: dsa.c:1775
uint16 nallocatable
Definition: dsa.c:203
#define DSA_SCLASS_SPAN_LARGE
Definition: dsa.c:251
void dsa_unpin ( dsa_area area)

Definition at line 976 of file dsa.c.

References Assert, dsa_area::control, DSA_AREA_LOCK, elog, ERROR, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), dsa_area_control::pinned, and dsa_area_control::refcnt.

977 {
979  Assert(area->control->refcnt > 1);
980  if (!area->control->pinned)
981  {
983  elog(ERROR, "dsa_area not pinned");
984  }
985  area->control->pinned = false;
986  --area->control->refcnt;
988 }
bool pinned
Definition: dsa.c:319
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1715
int refcnt
Definition: dsa.c:317
#define ERROR
Definition: elog.h:43
dsa_area_control * control
Definition: dsa.c:357
#define Assert(condition)
Definition: c.h:676
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1111
#define elog
Definition: elog.h:219
#define DSA_AREA_LOCK(area)
Definition: dsa.c:143