combocid.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/xact.h"
#include "miscadmin.h"
#include "storage/shmem.h"
#include "utils/combocid.h"
#include "utils/hsearch.h"
#include "utils/memutils.h"

Include dependency graph for combocid.c:

Go to the source code of this file.

Data Structures
struct	ComboCidKeyData
struct	ComboCidEntryData

Macros
#define	CCID_HASH_SIZE   100
#define	CCID_ARRAY_SIZE   100

Typedefs
typedef ComboCidKeyData *	ComboCidKey
typedef ComboCidEntryData *	ComboCidEntry

Functions
static CommandId	GetComboCommandId (CommandId cmin, CommandId cmax)
static CommandId	GetRealCmin (CommandId combocid)
static CommandId	GetRealCmax (CommandId combocid)
CommandId	HeapTupleHeaderGetCmin (const HeapTupleHeaderData *tup)
CommandId	HeapTupleHeaderGetCmax (const HeapTupleHeaderData *tup)
void	HeapTupleHeaderAdjustCmax (const HeapTupleHeaderData *tup, CommandId *cmax, bool *iscombo)
void	AtEOXact_ComboCid (void)
Size	EstimateComboCIDStateSpace (void)
void	SerializeComboCIDState (Size maxsize, char *start_address)
void	RestoreComboCIDState (char *comboCIDstate)

Variables
static HTAB *	comboHash = NULL
static ComboCidKey	comboCids = NULL
static int	usedComboCids = 0
static int	sizeComboCids = 0

Macro Definition Documentation

CCID_ARRAY_SIZE

#define CCID_ARRAY_SIZE   100

Definition at line 85 of file combocid.c.

CCID_HASH_SIZE

#define CCID_HASH_SIZE   100

Definition at line 73 of file combocid.c.

Typedef Documentation

ComboCidEntry

typedef ComboCidEntryData* ComboCidEntry

Definition at line 70 of file combocid.c.

ComboCidKey

typedef ComboCidKeyData* ComboCidKey

Definition at line 62 of file combocid.c.

Function Documentation

AtEOXact_ComboCid()

void AtEOXact_ComboCid

(

void

)

Definition at line 182 of file combocid.c.

{
    /*
     * Don't bother to pfree. These are allocated in TopTransactionContext, so
     * they're going to go away at the end of transaction anyway.
     */
    comboHash = NULL;
 
    comboCids = NULL;
    usedComboCids = 0;
    sizeComboCids = 0;
}

References comboCids, comboHash, sizeComboCids, and usedComboCids.

Referenced by AbortTransaction(), CommitTransaction(), and PrepareTransaction().

EstimateComboCIDStateSpace()

Size EstimateComboCIDStateSpace

(

void

)

Definition at line 297 of file combocid.c.

{
    Size        size;
 
    /* Add space required for saving usedComboCids */
    size = sizeof(int);
 
    /* Add space required for saving ComboCidKeyData */
    size = add_size(size, mul_size(sizeof(ComboCidKeyData), usedComboCids));
 
    return size;
}

References add_size(), mul_size(), and usedComboCids.

Referenced by InitializeParallelDSM().

GetComboCommandId()

static CommandId GetComboCommandId ( CommandId  cmin, CommandId  cmax  )

static

Definition at line 204 of file combocid.c.

{
    CommandId   combocid;
    ComboCidKeyData key;
    ComboCidEntry entry;
    bool        found;
 
    /*
     * Create the hash table and array the first time we need to use combo
     * cids in the transaction.
     */
    if (comboHash == NULL)
    {
        HASHCTL     hash_ctl;
 
        /* Make array first; existence of hash table asserts array exists */
        comboCids = (ComboCidKeyData *)
            MemoryContextAlloc(TopTransactionContext,
                               sizeof(ComboCidKeyData) * CCID_ARRAY_SIZE);
        sizeComboCids = CCID_ARRAY_SIZE;
        usedComboCids = 0;
 
        hash_ctl.keysize = sizeof(ComboCidKeyData);
        hash_ctl.entrysize = sizeof(ComboCidEntryData);
        hash_ctl.hcxt = TopTransactionContext;
 
        comboHash = hash_create("Combo CIDs",
                                CCID_HASH_SIZE,
                                &hash_ctl,
                                HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
    }
 
    /*
     * Grow the array if there's not at least one free slot.  We must do this
     * before possibly entering a new hashtable entry, else failure to
     * repalloc would leave a corrupt hashtable entry behind.
     */
    if (usedComboCids >= sizeComboCids)
    {
        int         newsize = sizeComboCids * 2;
 
        comboCids = (ComboCidKeyData *)
            repalloc(comboCids, sizeof(ComboCidKeyData) * newsize);
        sizeComboCids = newsize;
    }
 
    /* Lookup or create a hash entry with the desired cmin/cmax */
 
    /* We assume there is no struct padding in ComboCidKeyData! */
    key.cmin = cmin;
    key.cmax = cmax;
    entry = (ComboCidEntry) hash_search(comboHash,
                                        &key,
                                        HASH_ENTER,
                                        &found);
 
    if (found)
    {
        /* Reuse an existing combo CID */
        return entry->combocid;
    }
 
    /* We have to create a new combo CID; we already made room in the array */
    combocid = usedComboCids;
 
    comboCids[combocid].cmin = cmin;
    comboCids[combocid].cmax = cmax;
    usedComboCids++;
 
    entry->combocid = combocid;
 
    return combocid;
}

References CCID_ARRAY_SIZE, CCID_HASH_SIZE, ComboCidKeyData::cmax, ComboCidKeyData::cmin, ComboCidEntryData::combocid, comboCids, comboHash, HASHCTL::entrysize, HASH_BLOBS, HASH_CONTEXT, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), HASHCTL::hcxt, sort-test::key, HASHCTL::keysize, MemoryContextAlloc(), repalloc(), sizeComboCids, TopTransactionContext, and usedComboCids.

Referenced by HeapTupleHeaderAdjustCmax(), and RestoreComboCIDState().

GetRealCmax()

static CommandId GetRealCmax ( CommandId  combocid )

static

Definition at line 286 of file combocid.c.

{
    Assert(combocid < usedComboCids);
    return comboCids[combocid].cmax;
}

References Assert(), ComboCidKeyData::cmax, comboCids, and usedComboCids.

Referenced by HeapTupleHeaderGetCmax().

GetRealCmin()

static CommandId GetRealCmin ( CommandId  combocid )

static

Definition at line 279 of file combocid.c.

{
    Assert(combocid < usedComboCids);
    return comboCids[combocid].cmin;
}

References Assert(), ComboCidKeyData::cmin, comboCids, and usedComboCids.

Referenced by HeapTupleHeaderGetCmin().

HeapTupleHeaderAdjustCmax()

void HeapTupleHeaderAdjustCmax	(	const HeapTupleHeaderData *	tup,
		CommandId *	cmax,
		bool *	iscombo
	)

Definition at line 153 of file combocid.c.

{
    /*
     * If we're marking a tuple deleted that was inserted by (any
     * subtransaction of) our transaction, we need to use a combo command id.
     * Test for HeapTupleHeaderXminCommitted() first, because it's cheaper
     * than a TransactionIdIsCurrentTransactionId call.
     */
    if (!HeapTupleHeaderXminCommitted(tup) &&
        TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetRawXmin(tup)))
    {
        CommandId   cmin = HeapTupleHeaderGetCmin(tup);
 
        *cmax = GetComboCommandId(cmin, *cmax);
        *iscombo = true;
    }
    else
    {
        *iscombo = false;
    }
}

References GetComboCommandId(), HeapTupleHeaderGetCmin(), HeapTupleHeaderGetRawXmin(), HeapTupleHeaderXminCommitted(), and TransactionIdIsCurrentTransactionId().

Referenced by heap_delete(), and heap_update().

HeapTupleHeaderGetCmax()

CommandId HeapTupleHeaderGetCmax

(

const HeapTupleHeaderData *

tup

)

Definition at line 118 of file combocid.c.

{
    CommandId   cid = HeapTupleHeaderGetRawCommandId(tup);
 
    Assert(!(tup->t_infomask & HEAP_MOVED));
 
    /*
     * Because GetUpdateXid() performs memory allocations if xmax is a
     * multixact we can't Assert() if we're inside a critical section. This
     * weakens the check, but not using GetCmax() inside one would complicate
     * things too much.
     */
    Assert(CritSectionCount > 0 ||
           TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetUpdateXid(tup)));
 
    if (tup->t_infomask & HEAP_COMBOCID)
        return GetRealCmax(cid);
    else
        return cid;
}

References Assert(), CritSectionCount, GetRealCmax(), HEAP_COMBOCID, HEAP_MOVED, HeapTupleHeaderGetRawCommandId(), HeapTupleHeaderGetUpdateXid(), HeapTupleHeaderData::t_infomask, and TransactionIdIsCurrentTransactionId().

Referenced by heap_delete(), heap_lock_tuple(), heap_update(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesUpdate(), and log_heap_new_cid().

HeapTupleHeaderGetCmin()

CommandId HeapTupleHeaderGetCmin

(

const HeapTupleHeaderData *

tup

)

Definition at line 104 of file combocid.c.

{
    CommandId   cid = HeapTupleHeaderGetRawCommandId(tup);
 
    Assert(!(tup->t_infomask & HEAP_MOVED));
    Assert(TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(tup)));
 
    if (tup->t_infomask & HEAP_COMBOCID)
        return GetRealCmin(cid);
    else
        return cid;
}

References Assert(), GetRealCmin(), HEAP_COMBOCID, HEAP_MOVED, HeapTupleHeaderGetRawCommandId(), HeapTupleHeaderGetXmin(), HeapTupleHeaderData::t_infomask, and TransactionIdIsCurrentTransactionId().

Referenced by heapam_tuple_lock(), HeapTupleHeaderAdjustCmax(), HeapTupleSatisfiesMVCC(), HeapTupleSatisfiesUpdate(), and log_heap_new_cid().

RestoreComboCIDState()

void RestoreComboCIDState

(

char *

comboCIDstate

)

Definition at line 342 of file combocid.c.

{
    int         num_elements;
    ComboCidKeyData *keydata;
    int         i;
    CommandId   cid;
 
    Assert(!comboCids && !comboHash);
 
    /* First, we retrieve the number of combo CIDs that were serialized. */
    num_elements = *(int *) comboCIDstate;
    keydata = (ComboCidKeyData *) (comboCIDstate + sizeof(int));
 
    /* Use GetComboCommandId to restore each combo CID. */
    for (i = 0; i < num_elements; i++)
    {
        cid = GetComboCommandId(keydata[i].cmin, keydata[i].cmax);
 
        /* Verify that we got the expected answer. */
        if (cid != i)
            elog(ERROR, "unexpected command ID while restoring combo CIDs");
    }
}

References Assert(), comboCids, comboHash, elog, ERROR, GetComboCommandId(), and i.

Referenced by ParallelWorkerMain().

SerializeComboCIDState()

void SerializeComboCIDState	(	Size	maxsize,
		char *	start_address
	)

Definition at line 316 of file combocid.c.

{
    char       *endptr;
 
    /* First, we store the number of currently-existing combo CIDs. */
    *(int *) start_address = usedComboCids;
 
    /* If maxsize is too small, throw an error. */
    endptr = start_address + sizeof(int) +
        (sizeof(ComboCidKeyData) * usedComboCids);
    if (endptr < start_address || endptr > start_address + maxsize)
        elog(ERROR, "not enough space to serialize ComboCID state");
 
    /* Now, copy the actual cmin/cmax pairs. */
    if (usedComboCids > 0)
        memcpy(start_address + sizeof(int), comboCids,
               (sizeof(ComboCidKeyData) * usedComboCids));
}

References comboCids, elog, ERROR, and usedComboCids.

Referenced by InitializeParallelDSM().

Variable Documentation

comboCids

ComboCidKey comboCids = NULL

static

Definition at line 80 of file combocid.c.

Referenced by AtEOXact_ComboCid(), GetComboCommandId(), GetRealCmax(), GetRealCmin(), RestoreComboCIDState(), and SerializeComboCIDState().

comboHash

HTAB* comboHash = NULL

static

Definition at line 53 of file combocid.c.

Referenced by AtEOXact_ComboCid(), GetComboCommandId(), and RestoreComboCIDState().

sizeComboCids

int sizeComboCids = 0

static

Definition at line 82 of file combocid.c.

Referenced by AtEOXact_ComboCid(), and GetComboCommandId().

usedComboCids

int usedComboCids = 0

static

Definition at line 81 of file combocid.c.

Referenced by AtEOXact_ComboCid(), EstimateComboCIDStateSpace(), GetComboCommandId(), GetRealCmax(), GetRealCmin(), and SerializeComboCIDState().