shmem_hash.c File Reference

#include "postgres.h"
#include "storage/shmem.h"
#include "storage/shmem_internal.h"
#include "utils/memutils.h"

Include dependency graph for shmem_hash.c:

Go to the source code of this file.

Data Structures
struct	shmem_hash_allocator

Typedefs
typedef struct shmem_hash_allocator	shmem_hash_allocator

Functions
static void *	ShmemHashAlloc (Size size, void *alloc_arg)
void	ShmemRequestHashWithOpts (const ShmemHashOpts *options)
void	shmem_hash_init (void *location, ShmemStructOpts *base_options)
void	shmem_hash_attach (void *location, ShmemStructOpts *base_options)
HTAB *	ShmemInitHash (const char *name, int64 nelems, HASHCTL *infoP, int hash_flags)
HTAB *	shmem_hash_create (void *location, size_t size, bool found, const char *name, int64 nelems, HASHCTL *infoP, int hash_flags)

Typedef Documentation

shmem_hash_allocator

typedef struct shmem_hash_allocator shmem_hash_allocator

Function Documentation

shmem_hash_attach()

void shmem_hash_attach	(	void *	location,
		ShmemStructOpts *	base_options
	)

Definition at line 79 of file shmem_hash.c.

{
    ShmemHashOpts *options = (ShmemHashOpts *) base_options;
    int         hash_flags = options->hash_flags;
    HTAB       *htab;
 
    /* attach to it rather than allocate and initialize new space */
    hash_flags |= HASH_ATTACH;
    options->hash_info.hctl = location;
    Assert(options->hash_info.hctl != NULL);
    htab = shmem_hash_create(location, options->base.size, true,
                             options->name,
                             options->nelems, &options->hash_info, hash_flags);
 
    if (options->ptr)
        *options->ptr = htab;
}

References Assert, fb(), HASH_ATTACH, and shmem_hash_create().

Referenced by AttachShmemIndexEntry().

shmem_hash_create()

HTAB * shmem_hash_create	(	void *	location,
		size_t	size,
		bool	found,
		const char *	name,
		int64	nelems,
		HASHCTL *	infoP,
		int	hash_flags
	)

Definition at line 149 of file shmem_hash.c.

{
    shmem_hash_allocator allocator;
 
    /*
     * Hash tables allocated in shared memory have a fixed directory and have
     * all elements allocated upfront.  We don't support growing because we'd
     * need to grow the underlying shmem region with it.
     *
     * The shared memory allocator must be specified too.
     */
    infoP->alloc = ShmemHashAlloc;
    infoP->alloc_arg = NULL;
    hash_flags |= HASH_SHARED_MEM | HASH_ALLOC | HASH_FIXED_SIZE;
 
    /*
     * if it already exists, attach to it rather than allocate and initialize
     * new space
     */
    if (!found)
    {
        allocator.next = (char *) location;
        allocator.end = (char *) location + size;
        infoP->alloc_arg = &allocator;
    }
    else
    {
        /* Pass location of hashtable header to hash_create */
        infoP->hctl = (HASHHDR *) location;
        hash_flags |= HASH_ATTACH;
    }
 
    return hash_create(name, nelems, infoP, hash_flags);
}

References fb(), HASH_ALLOC, HASH_ATTACH, hash_create(), HASH_FIXED_SIZE, HASH_SHARED_MEM, name, shmem_hash_allocator::next, and ShmemHashAlloc().

Referenced by InitShmemAllocator(), shmem_hash_attach(), shmem_hash_init(), and ShmemInitHash().

shmem_hash_init()

void shmem_hash_init	(	void *	location,
		ShmemStructOpts *	base_options
	)

Definition at line 63 of file shmem_hash.c.

{
    ShmemHashOpts *options = (ShmemHashOpts *) base_options;
    int         hash_flags = options->hash_flags;
    HTAB       *htab;
 
    options->hash_info.hctl = location;
    htab = shmem_hash_create(location, options->base.size, false,
                             options->name,
                             options->nelems, &options->hash_info, hash_flags);
 
    if (options->ptr)
        *options->ptr = htab;
}

References fb(), and shmem_hash_create().

Referenced by InitShmemIndexEntry().

ShmemHashAlloc()

static void * ShmemHashAlloc ( Size  size, void *  alloc_arg  )

static

Definition at line 193 of file shmem_hash.c.

{
    shmem_hash_allocator *allocator = (shmem_hash_allocator *) alloc_arg;
    void       *result;
 
    size = MAXALIGN(size);
 
    if (allocator->end - allocator->next < size)
        return NULL;
    result = allocator->next;
    allocator->next += size;
 
    return result;
}

References fb(), MAXALIGN, and result.

Referenced by shmem_hash_create().

ShmemInitHash()

HTAB * ShmemInitHash	(	const char *	name,
		int64	nelems,
		HASHCTL *	infoP,
		int	hash_flags
	)

Definition at line 117 of file shmem_hash.c.

{
    bool        found;
    size_t      size;
    void       *location;
 
    size = hash_estimate_size(nelems, infoP->entrysize);
 
    /*
     * Look it up in the shmem index or allocate.
     *
     * NOTE: The area is requested internally as SHMEM_KIND_STRUCT instead of
     * SHMEM_KIND_HASH.  That's correct because we do the hash table
     * initialization by calling shmem_hash_create() ourselves.  (We don't
     * expose the request kind to users; if we did, that would be confusing.)
     */
    location = ShmemInitStruct(name, size, &found);
 
    return shmem_hash_create(location, size, found,
                             name, nelems, infoP, hash_flags);
}

References fb(), hash_estimate_size(), name, shmem_hash_create(), and ShmemInitStruct().

ShmemRequestHashWithOpts()

void ShmemRequestHashWithOpts

(

const ShmemHashOpts *

options

)

Definition at line 44 of file shmem_hash.c.

{
    ShmemHashOpts *options_copy;
 
    Assert(options->name != NULL);
 
    options_copy = MemoryContextAlloc(TopMemoryContext,
                                      sizeof(ShmemHashOpts));
    memcpy(options_copy, options, sizeof(ShmemHashOpts));
 
    /* Set options for the fixed-size area holding the hash table */
    options_copy->base.name = options->name;
    options_copy->base.size = hash_estimate_size(options_copy->nelems,
                                                 options_copy->hash_info.entrysize);
 
    ShmemRequestInternal(&options_copy->base, SHMEM_KIND_HASH);
}

References Assert, fb(), hash_estimate_size(), memcpy(), MemoryContextAlloc(), SHMEM_KIND_HASH, ShmemRequestInternal(), and TopMemoryContext.