PostgreSQL Source Code  git master
shmem.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * shmem.c
4  * create shared memory and initialize shared memory data structures.
5  *
6  * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/storage/ipc/shmem.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 /*
16  * POSTGRES processes share one or more regions of shared memory.
17  * The shared memory is created by a postmaster and is inherited
18  * by each backend via fork() (or, in some ports, via other OS-specific
19  * methods). The routines in this file are used for allocating and
20  * binding to shared memory data structures.
21  *
22  * NOTES:
23  * (a) There are three kinds of shared memory data structures
24  * available to POSTGRES: fixed-size structures, queues and hash
25  * tables. Fixed-size structures contain things like global variables
26  * for a module and should never be allocated after the shared memory
27  * initialization phase. Hash tables have a fixed maximum size, but
28  * their actual size can vary dynamically. When entries are added
29  * to the table, more space is allocated. Queues link data structures
30  * that have been allocated either within fixed-size structures or as hash
31  * buckets. Each shared data structure has a string name to identify
32  * it (assigned in the module that declares it).
33  *
34  * (b) During initialization, each module looks for its
35  * shared data structures in a hash table called the "Shmem Index".
36  * If the data structure is not present, the caller can allocate
37  * a new one and initialize it. If the data structure is present,
38  * the caller "attaches" to the structure by initializing a pointer
39  * in the local address space.
40  * The shmem index has two purposes: first, it gives us
41  * a simple model of how the world looks when a backend process
42  * initializes. If something is present in the shmem index,
43  * it is initialized. If it is not, it is uninitialized. Second,
44  * the shmem index allows us to allocate shared memory on demand
45  * instead of trying to preallocate structures and hard-wire the
46  * sizes and locations in header files. If you are using a lot
47  * of shared memory in a lot of different places (and changing
48  * things during development), this is important.
49  *
50  * (c) In standard Unix-ish environments, individual backends do not
51  * need to re-establish their local pointers into shared memory, because
52  * they inherit correct values of those variables via fork() from the
53  * postmaster. However, this does not work in the EXEC_BACKEND case.
54  * In ports using EXEC_BACKEND, new backends have to set up their local
55  * pointers using the method described in (b) above.
56  *
57  * (d) memory allocation model: shared memory can never be
58  * freed, once allocated. Each hash table has its own free list,
59  * so hash buckets can be reused when an item is deleted. However,
60  * if one hash table grows very large and then shrinks, its space
61  * cannot be redistributed to other tables. We could build a simple
62  * hash bucket garbage collector if need be. Right now, it seems
63  * unnecessary.
64  */
65 
66 #include "postgres.h"
67 
68 #include "access/transam.h"
69 #include "fmgr.h"
70 #include "funcapi.h"
71 #include "miscadmin.h"
72 #include "storage/lwlock.h"
73 #include "storage/pg_shmem.h"
74 #include "storage/shmem.h"
75 #include "storage/spin.h"
76 #include "utils/builtins.h"
77 
78 static void *ShmemAllocRaw(Size size, Size *allocated_size);
79 
80 /* shared memory global variables */
81 
82 static PGShmemHeader *ShmemSegHdr; /* shared mem segment header */
83 
84 static void *ShmemBase; /* start address of shared memory */
85 
86 static void *ShmemEnd; /* end+1 address of shared memory */
87 
88 slock_t *ShmemLock; /* spinlock for shared memory and LWLock
89  * allocation */
90 
91 static HTAB *ShmemIndex = NULL; /* primary index hashtable for shmem */
92 
93 
94 /*
95  * InitShmemAccess() --- set up basic pointers to shared memory.
96  *
97  * Note: the argument should be declared "PGShmemHeader *seghdr",
98  * but we use void to avoid having to include ipc.h in shmem.h.
99  */
100 void
101 InitShmemAccess(void *seghdr)
102 {
103  PGShmemHeader *shmhdr = (PGShmemHeader *) seghdr;
104 
105  ShmemSegHdr = shmhdr;
106  ShmemBase = (void *) shmhdr;
107  ShmemEnd = (char *) ShmemBase + shmhdr->totalsize;
108 }
109 
110 /*
111  * InitShmemAllocation() --- set up shared-memory space allocation.
112  *
113  * This should be called only in the postmaster or a standalone backend.
114  */
115 void
117 {
118  PGShmemHeader *shmhdr = ShmemSegHdr;
119  char *aligned;
120 
121  Assert(shmhdr != NULL);
122 
123  /*
124  * Initialize the spinlock used by ShmemAlloc. We must use
125  * ShmemAllocUnlocked, since obviously ShmemAlloc can't be called yet.
126  */
128 
130 
131  /*
132  * Allocations after this point should go through ShmemAlloc, which
133  * expects to allocate everything on cache line boundaries. Make sure the
134  * first allocation begins on a cache line boundary.
135  */
136  aligned = (char *)
137  (CACHELINEALIGN((((char *) shmhdr) + shmhdr->freeoffset)));
138  shmhdr->freeoffset = aligned - (char *) shmhdr;
139 
140  /* ShmemIndex can't be set up yet (need LWLocks first) */
141  shmhdr->index = NULL;
142  ShmemIndex = (HTAB *) NULL;
143 
144  /*
145  * Initialize ShmemVariableCache for transaction manager. (This doesn't
146  * really belong here, but not worth moving.)
147  */
149  ShmemAlloc(sizeof(*ShmemVariableCache));
150  memset(ShmemVariableCache, 0, sizeof(*ShmemVariableCache));
151 }
152 
153 /*
154  * ShmemAlloc -- allocate max-aligned chunk from shared memory
155  *
156  * Throws error if request cannot be satisfied.
157  *
158  * Assumes ShmemLock and ShmemSegHdr are initialized.
159  */
160 void *
162 {
163  void *newSpace;
164  Size allocated_size;
165 
166  newSpace = ShmemAllocRaw(size, &allocated_size);
167  if (!newSpace)
168  ereport(ERROR,
169  (errcode(ERRCODE_OUT_OF_MEMORY),
170  errmsg("out of shared memory (%zu bytes requested)",
171  size)));
172  return newSpace;
173 }
174 
175 /*
176  * ShmemAllocNoError -- allocate max-aligned chunk from shared memory
177  *
178  * As ShmemAlloc, but returns NULL if out of space, rather than erroring.
179  */
180 void *
182 {
183  Size allocated_size;
184 
185  return ShmemAllocRaw(size, &allocated_size);
186 }
187 
188 /*
189  * ShmemAllocRaw -- allocate align chunk and return allocated size
190  *
191  * Also sets *allocated_size to the number of bytes allocated, which will
192  * be equal to the number requested plus any padding we choose to add.
193  */
194 static void *
195 ShmemAllocRaw(Size size, Size *allocated_size)
196 {
197  Size newStart;
198  Size newFree;
199  void *newSpace;
200 
201  /*
202  * Ensure all space is adequately aligned. We used to only MAXALIGN this
203  * space but experience has proved that on modern systems that is not good
204  * enough. Many parts of the system are very sensitive to critical data
205  * structures getting split across cache line boundaries. To avoid that,
206  * attempt to align the beginning of the allocation to a cache line
207  * boundary. The calling code will still need to be careful about how it
208  * uses the allocated space - e.g. by padding each element in an array of
209  * structures out to a power-of-two size - but without this, even that
210  * won't be sufficient.
211  */
212  size = CACHELINEALIGN(size);
213  *allocated_size = size;
214 
215  Assert(ShmemSegHdr != NULL);
216 
218 
219  newStart = ShmemSegHdr->freeoffset;
220 
221  newFree = newStart + size;
222  if (newFree <= ShmemSegHdr->totalsize)
223  {
224  newSpace = (void *) ((char *) ShmemBase + newStart);
225  ShmemSegHdr->freeoffset = newFree;
226  }
227  else
228  newSpace = NULL;
229 
231 
232  /* note this assert is okay with newSpace == NULL */
233  Assert(newSpace == (void *) CACHELINEALIGN(newSpace));
234 
235  return newSpace;
236 }
237 
238 /*
239  * ShmemAllocUnlocked -- allocate max-aligned chunk from shared memory
240  *
241  * Allocate space without locking ShmemLock. This should be used for,
242  * and only for, allocations that must happen before ShmemLock is ready.
243  *
244  * We consider maxalign, rather than cachealign, sufficient here.
245  */
246 void *
248 {
249  Size newStart;
250  Size newFree;
251  void *newSpace;
252 
253  /*
254  * Ensure allocated space is adequately aligned.
255  */
256  size = MAXALIGN(size);
257 
258  Assert(ShmemSegHdr != NULL);
259 
260  newStart = ShmemSegHdr->freeoffset;
261 
262  newFree = newStart + size;
263  if (newFree > ShmemSegHdr->totalsize)
264  ereport(ERROR,
265  (errcode(ERRCODE_OUT_OF_MEMORY),
266  errmsg("out of shared memory (%zu bytes requested)",
267  size)));
268  ShmemSegHdr->freeoffset = newFree;
269 
270  newSpace = (void *) ((char *) ShmemBase + newStart);
271 
272  Assert(newSpace == (void *) MAXALIGN(newSpace));
273 
274  return newSpace;
275 }
276 
277 /*
278  * ShmemAddrIsValid -- test if an address refers to shared memory
279  *
280  * Returns true if the pointer points within the shared memory segment.
281  */
282 bool
283 ShmemAddrIsValid(const void *addr)
284 {
285  return (addr >= ShmemBase) && (addr < ShmemEnd);
286 }
287 
288 /*
289  * InitShmemIndex() --- set up or attach to shmem index table.
290  */
291 void
293 {
294  HASHCTL info;
295 
296  /*
297  * Create the shared memory shmem index.
298  *
299  * Since ShmemInitHash calls ShmemInitStruct, which expects the ShmemIndex
300  * hashtable to exist already, we have a bit of a circularity problem in
301  * initializing the ShmemIndex itself. The special "ShmemIndex" hash
302  * table name will tell ShmemInitStruct to fake it.
303  */
305  info.entrysize = sizeof(ShmemIndexEnt);
306 
307  ShmemIndex = ShmemInitHash("ShmemIndex",
309  &info,
311 }
312 
313 /*
314  * ShmemInitHash -- Create and initialize, or attach to, a
315  * shared memory hash table.
316  *
317  * We assume caller is doing some kind of synchronization
318  * so that two processes don't try to create/initialize the same
319  * table at once. (In practice, all creations are done in the postmaster
320  * process; child processes should always be attaching to existing tables.)
321  *
322  * max_size is the estimated maximum number of hashtable entries. This is
323  * not a hard limit, but the access efficiency will degrade if it is
324  * exceeded substantially (since it's used to compute directory size and
325  * the hash table buckets will get overfull).
326  *
327  * init_size is the number of hashtable entries to preallocate. For a table
328  * whose maximum size is certain, this should be equal to max_size; that
329  * ensures that no run-time out-of-shared-memory failures can occur.
330  *
331  * *infoP and hash_flags must specify at least the entry sizes and key
332  * comparison semantics (see hash_create()). Flag bits and values specific
333  * to shared-memory hash tables are added here, except that callers may
334  * choose to specify HASH_PARTITION and/or HASH_FIXED_SIZE.
335  *
336  * Note: before Postgres 9.0, this function returned NULL for some failure
337  * cases. Now, it always throws error instead, so callers need not check
338  * for NULL.
339  */
340 HTAB *
341 ShmemInitHash(const char *name, /* table string name for shmem index */
342  long init_size, /* initial table size */
343  long max_size, /* max size of the table */
344  HASHCTL *infoP, /* info about key and bucket size */
345  int hash_flags) /* info about infoP */
346 {
347  bool found;
348  void *location;
349 
350  /*
351  * Hash tables allocated in shared memory have a fixed directory; it can't
352  * grow or other backends wouldn't be able to find it. So, make sure we
353  * make it big enough to start with.
354  *
355  * The shared memory allocator must be specified too.
356  */
357  infoP->dsize = infoP->max_dsize = hash_select_dirsize(max_size);
358  infoP->alloc = ShmemAllocNoError;
359  hash_flags |= HASH_SHARED_MEM | HASH_ALLOC | HASH_DIRSIZE;
360 
361  /* look it up in the shmem index */
362  location = ShmemInitStruct(name,
363  hash_get_shared_size(infoP, hash_flags),
364  &found);
365 
366  /*
367  * if it already exists, attach to it rather than allocate and initialize
368  * new space
369  */
370  if (found)
371  hash_flags |= HASH_ATTACH;
372 
373  /* Pass location of hashtable header to hash_create */
374  infoP->hctl = (HASHHDR *) location;
375 
376  return hash_create(name, init_size, infoP, hash_flags);
377 }
378 
379 /*
380  * ShmemInitStruct -- Create/attach to a structure in shared memory.
381  *
382  * This is called during initialization to find or allocate
383  * a data structure in shared memory. If no other process
384  * has created the structure, this routine allocates space
385  * for it. If it exists already, a pointer to the existing
386  * structure is returned.
387  *
388  * Returns: pointer to the object. *foundPtr is set true if the object was
389  * already in the shmem index (hence, already initialized).
390  *
391  * Note: before Postgres 9.0, this function returned NULL for some failure
392  * cases. Now, it always throws error instead, so callers need not check
393  * for NULL.
394  */
395 void *
396 ShmemInitStruct(const char *name, Size size, bool *foundPtr)
397 {
398  ShmemIndexEnt *result;
399  void *structPtr;
400 
401  LWLockAcquire(ShmemIndexLock, LW_EXCLUSIVE);
402 
403  if (!ShmemIndex)
404  {
405  PGShmemHeader *shmemseghdr = ShmemSegHdr;
406 
407  /* Must be trying to create/attach to ShmemIndex itself */
408  Assert(strcmp(name, "ShmemIndex") == 0);
409 
410  if (IsUnderPostmaster)
411  {
412  /* Must be initializing a (non-standalone) backend */
413  Assert(shmemseghdr->index != NULL);
414  structPtr = shmemseghdr->index;
415  *foundPtr = true;
416  }
417  else
418  {
419  /*
420  * If the shmem index doesn't exist, we are bootstrapping: we must
421  * be trying to init the shmem index itself.
422  *
423  * Notice that the ShmemIndexLock is released before the shmem
424  * index has been initialized. This should be OK because no other
425  * process can be accessing shared memory yet.
426  */
427  Assert(shmemseghdr->index == NULL);
428  structPtr = ShmemAlloc(size);
429  shmemseghdr->index = structPtr;
430  *foundPtr = false;
431  }
432  LWLockRelease(ShmemIndexLock);
433  return structPtr;
434  }
435 
436  /* look it up in the shmem index */
437  result = (ShmemIndexEnt *)
438  hash_search(ShmemIndex, name, HASH_ENTER_NULL, foundPtr);
439 
440  if (!result)
441  {
442  LWLockRelease(ShmemIndexLock);
443  ereport(ERROR,
444  (errcode(ERRCODE_OUT_OF_MEMORY),
445  errmsg("could not create ShmemIndex entry for data structure \"%s\"",
446  name)));
447  }
448 
449  if (*foundPtr)
450  {
451  /*
452  * Structure is in the shmem index so someone else has allocated it
453  * already. The size better be the same as the size we are trying to
454  * initialize to, or there is a name conflict (or worse).
455  */
456  if (result->size != size)
457  {
458  LWLockRelease(ShmemIndexLock);
459  ereport(ERROR,
460  (errmsg("ShmemIndex entry size is wrong for data structure"
461  " \"%s\": expected %zu, actual %zu",
462  name, size, result->size)));
463  }
464  structPtr = result->location;
465  }
466  else
467  {
468  Size allocated_size;
469 
470  /* It isn't in the table yet. allocate and initialize it */
471  structPtr = ShmemAllocRaw(size, &allocated_size);
472  if (structPtr == NULL)
473  {
474  /* out of memory; remove the failed ShmemIndex entry */
475  hash_search(ShmemIndex, name, HASH_REMOVE, NULL);
476  LWLockRelease(ShmemIndexLock);
477  ereport(ERROR,
478  (errcode(ERRCODE_OUT_OF_MEMORY),
479  errmsg("not enough shared memory for data structure"
480  " \"%s\" (%zu bytes requested)",
481  name, size)));
482  }
483  result->size = size;
484  result->allocated_size = allocated_size;
485  result->location = structPtr;
486  }
487 
488  LWLockRelease(ShmemIndexLock);
489 
490  Assert(ShmemAddrIsValid(structPtr));
491 
492  Assert(structPtr == (void *) CACHELINEALIGN(structPtr));
493 
494  return structPtr;
495 }
496 
497 
498 /*
499  * Add two Size values, checking for overflow
500  */
501 Size
503 {
504  Size result;
505 
506  result = s1 + s2;
507  /* We are assuming Size is an unsigned type here... */
508  if (result < s1 || result < s2)
509  ereport(ERROR,
510  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
511  errmsg("requested shared memory size overflows size_t")));
512  return result;
513 }
514 
515 /*
516  * Multiply two Size values, checking for overflow
517  */
518 Size
520 {
521  Size result;
522 
523  if (s1 == 0 || s2 == 0)
524  return 0;
525  result = s1 * s2;
526  /* We are assuming Size is an unsigned type here... */
527  if (result / s2 != s1)
528  ereport(ERROR,
529  (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
530  errmsg("requested shared memory size overflows size_t")));
531  return result;
532 }
533 
534 /* SQL SRF showing allocated shared memory */
535 Datum
537 {
538 #define PG_GET_SHMEM_SIZES_COLS 4
539  ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
540  TupleDesc tupdesc;
541  Tuplestorestate *tupstore;
542  MemoryContext per_query_ctx;
543  MemoryContext oldcontext;
544  HASH_SEQ_STATUS hstat;
545  ShmemIndexEnt *ent;
546  Size named_allocated = 0;
548  bool nulls[PG_GET_SHMEM_SIZES_COLS];
549 
550  /* check to see if caller supports us returning a tuplestore */
551  if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo))
552  ereport(ERROR,
553  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
554  errmsg("set-valued function called in context that cannot accept a set")));
555  if (!(rsinfo->allowedModes & SFRM_Materialize))
556  ereport(ERROR,
557  (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
558  errmsg("materialize mode required, but it is not allowed in this context")));
559 
560  /* Build a tuple descriptor for our result type */
561  if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
562  elog(ERROR, "return type must be a row type");
563 
564  per_query_ctx = rsinfo->econtext->ecxt_per_query_memory;
565  oldcontext = MemoryContextSwitchTo(per_query_ctx);
566 
567  tupstore = tuplestore_begin_heap(true, false, work_mem);
568  rsinfo->returnMode = SFRM_Materialize;
569  rsinfo->setResult = tupstore;
570  rsinfo->setDesc = tupdesc;
571 
572  MemoryContextSwitchTo(oldcontext);
573 
574  LWLockAcquire(ShmemIndexLock, LW_SHARED);
575 
576  hash_seq_init(&hstat, ShmemIndex);
577 
578  /* output all allocated entries */
579  memset(nulls, 0, sizeof(nulls));
580  while ((ent = (ShmemIndexEnt *) hash_seq_search(&hstat)) != NULL)
581  {
582  values[0] = CStringGetTextDatum(ent->key);
583  values[1] = Int64GetDatum((char *) ent->location - (char *) ShmemSegHdr);
584  values[2] = Int64GetDatum(ent->size);
585  values[3] = Int64GetDatum(ent->allocated_size);
586  named_allocated += ent->allocated_size;
587 
588  tuplestore_putvalues(tupstore, tupdesc, values, nulls);
589  }
590 
591  /* output shared memory allocated but not counted via the shmem index */
592  values[0] = CStringGetTextDatum("<anonymous>");
593  nulls[1] = true;
594  values[2] = Int64GetDatum(ShmemSegHdr->freeoffset - named_allocated);
595  values[3] = values[2];
596  tuplestore_putvalues(tupstore, tupdesc, values, nulls);
597 
598  /* output as-of-yet unused shared memory */
599  nulls[0] = true;
600  values[1] = Int64GetDatum(ShmemSegHdr->freeoffset);
601  nulls[1] = false;
602  values[2] = Int64GetDatum(ShmemSegHdr->totalsize - ShmemSegHdr->freeoffset);
603  values[3] = values[2];
604  tuplestore_putvalues(tupstore, tupdesc, values, nulls);
605 
606  LWLockRelease(ShmemIndexLock);
607 
608  tuplestore_donestoring(tupstore);
609 
610  return (Datum) 0;
611 }
void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, Datum *values, bool *isnull)
Definition: tuplestore.c:750
int slock_t
Definition: s_lock.h:934
VariableCacheData * VariableCache
Definition: transam.h:250
#define IsA(nodeptr, _type_)
Definition: nodes.h:579
static PGShmemHeader * ShmemSegHdr
Definition: shmem.c:82
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, Oid *resultTypeId, TupleDesc *resultTupleDesc)
Definition: funcapi.c:207
#define SHMEM_INDEX_SIZE
Definition: shmem.h:55
#define HASH_ELEM
Definition: hsearch.h:95
void InitShmemAccess(void *seghdr)
Definition: shmem.c:101
#define SpinLockInit(lock)
Definition: spin.h:60
#define PG_GET_SHMEM_SIZES_COLS
Size size
Definition: shmem.h:62
#define tuplestore_donestoring(state)
Definition: tuplestore.h:60
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:109
Size entrysize
Definition: hsearch.h:76
int errcode(int sqlerrcode)
Definition: elog.c:704
void * ShmemAllocNoError(Size size)
Definition: shmem.c:181
void * ShmemAlloc(Size size)
Definition: shmem.c:161
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:954
static void * ShmemBase
Definition: shmem.c:84
#define HASH_SHARED_MEM
Definition: hsearch.h:103
long dsize
Definition: hsearch.h:72
#define HASH_ATTACH
Definition: hsearch.h:104
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1810
static HTAB * ShmemIndex
Definition: shmem.c:91
#define SpinLockAcquire(lock)
Definition: spin.h:62
Definition: dynahash.c:219
long max_dsize
Definition: hsearch.h:73
#define ERROR
Definition: elog.h:45
char * s1
void * location
Definition: shmem.h:61
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:396
HashAllocFunc alloc
Definition: hsearch.h:84
static void * ShmemEnd
Definition: shmem.c:86
bool IsUnderPostmaster
Definition: globals.c:110
VariableCache ShmemVariableCache
Definition: varsup.c:34
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:349
Datum pg_get_shmem_allocations(PG_FUNCTION_ARGS)
Definition: shmem.c:536
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1700
static void * ShmemAllocRaw(Size size, Size *allocated_size)
Definition: shmem.c:195
#define SpinLockRelease(lock)
Definition: spin.h:64
Tuplestorestate * tuplestore_begin_heap(bool randomAccess, bool interXact, int maxKBytes)
Definition: tuplestore.c:318
Size totalsize
Definition: pg_shmem.h:34
Size mul_size(Size s1, Size s2)
Definition: shmem.c:519
char * s2
uintptr_t Datum
Definition: postgres.h:367
void * ShmemAllocUnlocked(Size size)
Definition: shmem.c:247
Size add_size(Size s1, Size s2)
Definition: shmem.c:502
Size keysize
Definition: hsearch.h:75
int work_mem
Definition: globals.c:122
#define ereport(elevel,...)
Definition: elog.h:155
bool ShmemAddrIsValid(const void *addr)
Definition: shmem.c:283
int allowedModes
Definition: execnodes.h:304
long hash_select_dirsize(long num_entries)
Definition: dynahash.c:827
SetFunctionReturnMode returnMode
Definition: execnodes.h:306
#define Assert(condition)
Definition: c.h:792
#define CACHELINEALIGN(LEN)
Definition: c.h:748
Size freeoffset
Definition: pg_shmem.h:35
size_t Size
Definition: c.h:528
Size allocated_size
Definition: shmem.h:63
#define SHMEM_INDEX_KEYSIZE
Definition: shmem.h:53
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1206
#define MAXALIGN(LEN)
Definition: c.h:745
Size hash_get_shared_size(HASHCTL *info, int flags)
Definition: dynahash.c:851
HASHHDR * hctl
Definition: hsearch.h:88
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1436
MemoryContext ecxt_per_query_memory
Definition: execnodes.h:232
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1426
const char * name
Definition: encode.c:515
Tuplestorestate * setResult
Definition: execnodes.h:309
static Datum values[MAXATTR]
Definition: bootstrap.c:165
ExprContext * econtext
Definition: execnodes.h:302
TupleDesc setDesc
Definition: execnodes.h:310
#define HASH_DIRSIZE
Definition: hsearch.h:94
slock_t * ShmemLock
Definition: shmem.c:88
int errmsg(const char *fmt,...)
Definition: elog.c:915
#define elog(elevel,...)
Definition: elog.h:228
#define HASH_ALLOC
Definition: hsearch.h:101
#define CStringGetTextDatum(s)
Definition: builtins.h:82
void InitShmemIndex(void)
Definition: shmem.c:292
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
void * index
Definition: pg_shmem.h:37
HTAB * ShmemInitHash(const char *name, long init_size, long max_size, HASHCTL *infoP, int hash_flags)
Definition: shmem.c:341
#define HASH_STRINGS
Definition: hsearch.h:96
void InitShmemAllocation(void)
Definition: shmem.c:116