From c834c29bdd5f15fba248224069f15181dedcc9b9 Mon Sep 17 00:00:00 2001 From: Nikhil Sontakke Date: Mon, 5 Mar 2018 21:41:17 +0530 Subject: [PATCH 1/6] Cleaning up and addition of new flags in ReorderBufferTXN structure --- src/backend/replication/logical/reorderbuffer.c | 32 +++++++-------- src/include/replication/reorderbuffer.h | 52 +++++++++++++++++-------- 2 files changed, 51 insertions(+), 33 deletions(-) diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index c72a611a39..d22e116aa1 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -623,7 +623,7 @@ AssertTXNLsnOrder(ReorderBuffer *rb) if (prev_first_lsn != InvalidXLogRecPtr) Assert(prev_first_lsn < cur_txn->first_lsn); - Assert(!cur_txn->is_known_as_subxact); + Assert(!rbtxn_is_subxact(cur_txn)); prev_first_lsn = cur_txn->first_lsn; } #endif @@ -641,7 +641,7 @@ ReorderBufferGetOldestTXN(ReorderBuffer *rb) txn = dlist_head_element(ReorderBufferTXN, node, &rb->toplevel_by_lsn); - Assert(!txn->is_known_as_subxact); + Assert(!rbtxn_is_subxact(txn)); Assert(txn->first_lsn != InvalidXLogRecPtr); return txn; } @@ -675,9 +675,9 @@ ReorderBufferAssignChild(ReorderBuffer *rb, TransactionId xid, dlist_push_tail(&txn->subtxns, &subtxn->node); txn->nsubtxns++; } - else if (!subtxn->is_known_as_subxact) + else if (!rbtxn_is_subxact(subtxn)) { - subtxn->is_known_as_subxact = true; + subtxn->txn_flags |= RBTXN_IS_SUBXACT; Assert(subtxn->nsubtxns == 0); /* remove from lsn order list of top-level transactions */ @@ -738,9 +738,9 @@ ReorderBufferCommitChild(ReorderBuffer *rb, TransactionId xid, subtxn->final_lsn = commit_lsn; subtxn->end_lsn = end_lsn; - if (!subtxn->is_known_as_subxact) + if (!rbtxn_is_subxact(subtxn)) { - subtxn->is_known_as_subxact = true; + subtxn->txn_flags |= RBTXN_IS_SUBXACT; Assert(subtxn->nsubtxns == 0); /* remove from lsn order list of top-level transactions */ @@ -849,7 +849,7 @@ ReorderBufferIterTXNInit(ReorderBuffer *rb, ReorderBufferTXN *txn) { ReorderBufferChange *cur_change; - if (txn->serialized) + if (rbtxn_is_serialized(txn)) { /* serialize remaining changes */ ReorderBufferSerializeTXN(rb, txn); @@ -878,7 +878,7 @@ ReorderBufferIterTXNInit(ReorderBuffer *rb, ReorderBufferTXN *txn) { ReorderBufferChange *cur_change; - if (cur_txn->serialized) + if (rbtxn_is_serialized(cur_txn)) { /* serialize remaining changes */ ReorderBufferSerializeTXN(rb, cur_txn); @@ -1044,7 +1044,7 @@ ReorderBufferCleanupTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) * they originally were happening inside another subtxn, so we won't * ever recurse more than one level deep here. */ - Assert(subtxn->is_known_as_subxact); + Assert(rbtxn_is_subxact(subtxn)); Assert(subtxn->nsubtxns == 0); ReorderBufferCleanupTXN(rb, subtxn); @@ -1083,7 +1083,7 @@ ReorderBufferCleanupTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) /* * Remove TXN from its containing list. * - * Note: if txn->is_known_as_subxact, we are deleting the TXN from its + * Note: if txn is known as subxact, we are deleting the TXN from its * parent's list of known subxacts; this leaves the parent's nsubxacts * count too high, but we don't care. Otherwise, we are deleting the TXN * from the LSN-ordered list of toplevel TXNs. @@ -1098,7 +1098,7 @@ ReorderBufferCleanupTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) Assert(found); /* remove entries spilled to disk */ - if (txn->serialized) + if (rbtxn_is_serialized(txn)) ReorderBufferRestoreCleanup(rb, txn); /* deallocate */ @@ -1115,7 +1115,7 @@ ReorderBufferBuildTupleCidHash(ReorderBuffer *rb, ReorderBufferTXN *txn) dlist_iter iter; HASHCTL hash_ctl; - if (!txn->has_catalog_changes || dlist_is_empty(&txn->tuplecids)) + if (!rbtxn_has_catalog_changes(txn) || dlist_is_empty(&txn->tuplecids)) return; memset(&hash_ctl, 0, sizeof(hash_ctl)); @@ -1688,7 +1688,7 @@ ReorderBufferAbortOld(ReorderBuffer *rb, TransactionId oldestRunningXid) * final_lsn to that of their last change; this causes * ReorderBufferRestoreCleanup to do the right thing. */ - if (txn->serialized && txn->final_lsn == 0) + if (rbtxn_is_serialized(txn) && txn->final_lsn == 0) { ReorderBufferChange *last = dlist_tail_element(ReorderBufferChange, node, &txn->changes); @@ -1934,7 +1934,7 @@ ReorderBufferXidSetCatalogChanges(ReorderBuffer *rb, TransactionId xid, txn = ReorderBufferTXNByXid(rb, xid, true, NULL, lsn, true); - txn->has_catalog_changes = true; + txn->txn_flags |= RBTXN_HAS_CATALOG_CHANGES; } /* @@ -1951,7 +1951,7 @@ ReorderBufferXidHasCatalogChanges(ReorderBuffer *rb, TransactionId xid) if (txn == NULL) return false; - return txn->has_catalog_changes; + return rbtxn_has_catalog_changes(txn); } /* @@ -2095,7 +2095,7 @@ ReorderBufferSerializeTXN(ReorderBuffer *rb, ReorderBufferTXN *txn) Assert(spilled == txn->nentries_mem); Assert(dlist_is_empty(&txn->changes)); txn->nentries_mem = 0; - txn->serialized = true; + txn->txn_flags |= RBTXN_SERIALIZED; if (fd != -1) CloseTransientFile(fd); diff --git a/src/include/replication/reorderbuffer.h b/src/include/replication/reorderbuffer.h index 0970abca52..d6b00654c2 100644 --- a/src/include/replication/reorderbuffer.h +++ b/src/include/replication/reorderbuffer.h @@ -137,21 +137,48 @@ typedef struct ReorderBufferChange dlist_node node; } ReorderBufferChange; +/* ReorderBufferTXN flags */ +#define RBTXN_HAS_CATALOG_CHANGES 0x0001 +#define RBTXN_IS_SUBXACT 0x0002 +#define RBTXN_SERIALIZED 0x0004 +#define RBTXN_PREPARE 0x0008 +#define RBTXN_COMMIT_PREPARED 0x0010 +#define RBTXN_ROLLBACK_PREPARED 0x0020 +#define RBTXN_COMMIT 0x0040 +#define RBTXN_ROLLBACK 0x0080 + +/* does the txn have catalog changes */ +#define rbtxn_has_catalog_changes(txn) (txn->txn_flags & RBTXN_HAS_CATALOG_CHANGES) +/* is the txn known as a subxact? */ +#define rbtxn_is_subxact(txn) (txn->txn_flags & RBTXN_IS_SUBXACT) +/* + * Has this transaction been spilled to disk? It's not always possible to + * deduce that fact by comparing nentries with nentries_mem, because e.g. + * subtransactions of a large transaction might get serialized together + * with the parent - if they're restored to memory they'd have + * nentries_mem == nentries. + */ +#define rbtxn_is_serialized(txn) (txn->txn_flags & RBTXN_SERIALIZED) +/* is this txn prepared? */ +#define rbtxn_prepared(txn) (txn->txn_flags & RBTXN_PREPARE) +/* was this prepared txn committed in the meanwhile? */ +#define rbtxn_commit_prepared(txn) (txn->txn_flags & RBTXN_COMMIT_PREPARED) +/* was this prepared txn aborted in the meanwhile? */ +#define rbtxn_rollback_prepared(txn) (txn->txn_flags & RBTXN_ROLLBACK_PREPARED) +/* was this txn committed in the meanwhile? */ +#define rbtxn_commit(txn) (txn->txn_flags & RBTXN_COMMIT) +/* was this prepared txn aborted in the meanwhile? */ +#define rbtxn_rollback(txn) (txn->txn_flags & RBTXN_ROLLBACK) + typedef struct ReorderBufferTXN { + int txn_flags; + /* * The transactions transaction id, can be a toplevel or sub xid. */ TransactionId xid; - /* did the TX have catalog changes */ - bool has_catalog_changes; - - /* - * Do we know this is a subxact? - */ - bool is_known_as_subxact; - /* * LSN of the first data carrying, WAL record with knowledge about this * xid. This is allowed to *not* be first record adorned with this xid, if @@ -214,15 +241,6 @@ typedef struct ReorderBufferTXN */ uint64 nentries_mem; - /* - * Has this transaction been spilled to disk? It's not always possible to - * deduce that fact by comparing nentries with nentries_mem, because e.g. - * subtransactions of a large transaction might get serialized together - * with the parent - if they're restored to memory they'd have - * nentries_mem == nentries. - */ - bool serialized; - /* * List of ReorderBufferChange structs, including new Snapshots and new * CommandIds -- 2.14.3 (Apple Git-98)