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 (HeapTupleHeader tup)
CommandId	HeapTupleHeaderGetCmax (HeapTupleHeader tup)
void	HeapTupleHeaderAdjustCmax (HeapTupleHeader 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(), 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	(	HeapTupleHeader	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

(

HeapTupleHeader

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

(

HeapTupleHeader

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().