From c7d5bbd2e0df08091e1d2bf6624f04f69ccab7ef Mon Sep 17 00:00:00 2001 From: sfc-gh-tclinkenbeard Date: Fri, 30 Apr 2021 12:05:58 -0700 Subject: [PATCH] Make ThreadSafeTransaction implementation less verbose --- fdbclient/ThreadSafeTransaction.cpp | 76 ++++++++++------------------- 1 file changed, 26 insertions(+), 50 deletions(-) diff --git a/fdbclient/ThreadSafeTransaction.cpp b/fdbclient/ThreadSafeTransaction.cpp index eff6f63000..f46d159313 100644 --- a/fdbclient/ThreadSafeTransaction.cpp +++ b/fdbclient/ThreadSafeTransaction.cpp @@ -133,10 +133,10 @@ ThreadSafeTransaction::ThreadSafeTransaction(DatabaseContext* cx) { // because the reference count of the DatabaseContext is solely managed from the main thread. If cx is destructed // immediately after this call, it will defer the DatabaseContext::delref (and onMainThread preserves the order of // these operations). - ISingleThreadTransaction* tr = this->tr = ReadYourWritesTransaction::allocateOnForeignThread(); + this->tr = ReadYourWritesTransaction::allocateOnForeignThread(); // No deferred error -- if the construction of the RYW transaction fails, we have no where to put it onMainThreadVoid( - [tr, cx]() { + [tr = this->tr, cx]() { cx->addref(); new (tr) ReadYourWritesTransaction(Database(cx)); }, @@ -150,18 +150,15 @@ ThreadSafeTransaction::~ThreadSafeTransaction() { } void ThreadSafeTransaction::cancel() { - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr]() { tr->cancel(); }, nullptr); + onMainThreadVoid([tr = this->tr]() { tr->cancel(); }, nullptr); } void ThreadSafeTransaction::setVersion(Version v) { - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr, v]() { tr->setVersion(v); }, &tr->getMutableDeferredError()); + onMainThreadVoid([tr = this->tr, v]() { tr->setVersion(v); }, &tr->getMutableDeferredError()); } ThreadFuture ThreadSafeTransaction::getReadVersion() { - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr]() -> Future { + return onMainThread([tr = this->tr]() -> Future { tr->checkDeferredError(); return tr->getReadVersion(); }); @@ -170,8 +167,7 @@ ThreadFuture ThreadSafeTransaction::getReadVersion() { ThreadFuture> ThreadSafeTransaction::get(const KeyRef& key, bool snapshot) { Key k = key; - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr, k, snapshot]() -> Future> { + return onMainThread([tr = this->tr, k, snapshot]() -> Future> { tr->checkDeferredError(); return tr->get(k, snapshot); }); @@ -180,8 +176,7 @@ ThreadFuture> ThreadSafeTransaction::get(const KeyRef& key, bool ThreadFuture ThreadSafeTransaction::getKey(const KeySelectorRef& key, bool snapshot) { KeySelector k = key; - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr, k, snapshot]() -> Future { + return onMainThread([tr = this->tr, k, snapshot]() -> Future { tr->checkDeferredError(); return tr->getKey(k, snapshot); }); @@ -190,8 +185,7 @@ ThreadFuture ThreadSafeTransaction::getKey(const KeySelectorRef& key, bool ThreadFuture ThreadSafeTransaction::getEstimatedRangeSizeBytes(const KeyRangeRef& keys) { KeyRange r = keys; - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr, r]() -> Future { + return onMainThread([tr = this->tr, r]() -> Future { tr->checkDeferredError(); return tr->getEstimatedRangeSizeBytes(r); }); @@ -201,8 +195,7 @@ ThreadFuture>> ThreadSafeTransaction::getRangeSplit int64_t chunkSize) { KeyRange r = range; - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr, r, chunkSize]() -> Future>> { + return onMainThread([tr = this->tr, r, chunkSize]() -> Future>> { tr->checkDeferredError(); return tr->getRangeSplitPoints(r, chunkSize); }); @@ -241,8 +234,7 @@ ThreadFuture> ThreadSafeTransaction::getRange(const K ThreadFuture>> ThreadSafeTransaction::getAddressesForKey(const KeyRef& key) { Key k = key; - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr, k]() -> Future>> { + return onMainThread([tr = this->tr, k]() -> Future>> { tr->checkDeferredError(); return tr->getAddressesForKey(k); }); @@ -251,21 +243,18 @@ ThreadFuture>> ThreadSafeTransaction::getAddre void ThreadSafeTransaction::addReadConflictRange(const KeyRangeRef& keys) { KeyRange r = keys; - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr, r]() { tr->addReadConflictRange(r); }, &tr->getMutableDeferredError()); + onMainThreadVoid([tr = this->tr, r]() { tr->addReadConflictRange(r); }, &tr->getMutableDeferredError()); } void ThreadSafeTransaction::makeSelfConflicting() { - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr]() { tr->makeSelfConflicting(); }, &tr->getMutableDeferredError()); + onMainThreadVoid([tr = this->tr]() { tr->makeSelfConflicting(); }, &tr->getMutableDeferredError()); } void ThreadSafeTransaction::atomicOp(const KeyRef& key, const ValueRef& value, uint32_t operationType) { Key k = key; Value v = value; - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr, k, v, operationType]() { tr->atomicOp(k, v, operationType); }, + onMainThreadVoid([tr = this->tr, k, v, operationType]() { tr->atomicOp(k, v, operationType); }, &tr->getMutableDeferredError()); } @@ -273,24 +262,21 @@ void ThreadSafeTransaction::set(const KeyRef& key, const ValueRef& value) { Key k = key; Value v = value; - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr, k, v]() { tr->set(k, v); }, &tr->getMutableDeferredError()); + onMainThreadVoid([tr = this->tr, k, v]() { tr->set(k, v); }, &tr->getMutableDeferredError()); } void ThreadSafeTransaction::clear(const KeyRangeRef& range) { KeyRange r = range; - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr, r]() { tr->clear(r); }, &tr->getMutableDeferredError()); + onMainThreadVoid([tr = this->tr, r]() { tr->clear(r); }, &tr->getMutableDeferredError()); } void ThreadSafeTransaction::clear(const KeyRef& begin, const KeyRef& end) { Key b = begin; Key e = end; - ISingleThreadTransaction* tr = this->tr; onMainThreadVoid( - [tr, b, e]() { + [tr = this->tr, b, e]() { if (b > e) throw inverted_range(); @@ -302,15 +288,13 @@ void ThreadSafeTransaction::clear(const KeyRef& begin, const KeyRef& end) { void ThreadSafeTransaction::clear(const KeyRef& key) { Key k = key; - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr, k]() { tr->clear(k); }, &tr->getMutableDeferredError()); + onMainThreadVoid([tr = this->tr, k]() { tr->clear(k); }, &tr->getMutableDeferredError()); } ThreadFuture ThreadSafeTransaction::watch(const KeyRef& key) { Key k = key; - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr, k]() -> Future { + return onMainThread([tr = this->tr, k]() -> Future { tr->checkDeferredError(); return tr->watch(k); }); @@ -319,13 +303,11 @@ ThreadFuture ThreadSafeTransaction::watch(const KeyRef& key) { void ThreadSafeTransaction::addWriteConflictRange(const KeyRangeRef& keys) { KeyRange r = keys; - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr, r]() { tr->addWriteConflictRange(r); }, &tr->getMutableDeferredError()); + onMainThreadVoid([tr = this->tr, r]() { tr->addWriteConflictRange(r); }, &tr->getMutableDeferredError()); } ThreadFuture ThreadSafeTransaction::commit() { - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr]() -> Future { + return onMainThread([tr = this->tr]() -> Future { tr->checkDeferredError(); return tr->commit(); }); @@ -337,13 +319,11 @@ Version ThreadSafeTransaction::getCommittedVersion() { } ThreadFuture ThreadSafeTransaction::getApproximateSize() { - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr]() -> Future { return tr->getApproximateSize(); }); + return onMainThread([tr = this->tr]() -> Future { return tr->getApproximateSize(); }); } ThreadFuture> ThreadSafeTransaction::getVersionstamp() { - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr]() -> Future> { return tr->getVersionstamp(); }); + return onMainThread([tr = this->tr]() -> Future> { return tr->getVersionstamp(); }); } void ThreadSafeTransaction::setOption(FDBTransactionOptions::Option option, Optional value) { @@ -352,17 +332,15 @@ void ThreadSafeTransaction::setOption(FDBTransactionOptions::Option option, Opti TraceEvent("UnknownTransactionOption").detail("Option", option); throw invalid_option(); } - ISingleThreadTransaction* tr = this->tr; Standalone> passValue = value; // ThreadSafeTransaction is not allowed to do anything with options except pass them through to RYW. - onMainThreadVoid([tr, option, passValue]() { tr->setOption(option, passValue.contents()); }, + onMainThreadVoid([tr = this->tr, option, passValue]() { tr->setOption(option, passValue.contents()); }, &tr->getMutableDeferredError()); } ThreadFuture ThreadSafeTransaction::checkDeferredError() { - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr]() { + return onMainThread([tr = this->tr]() { try { tr->checkDeferredError(); } catch (Error& e) { @@ -374,8 +352,7 @@ ThreadFuture ThreadSafeTransaction::checkDeferredError() { } ThreadFuture ThreadSafeTransaction::onError(Error const& e) { - ISingleThreadTransaction* tr = this->tr; - return onMainThread([tr, e]() { return tr->onError(e); }); + return onMainThread([tr = this->tr, e]() { return tr->onError(e); }); } void ThreadSafeTransaction::operator=(ThreadSafeTransaction&& r) noexcept { @@ -389,8 +366,7 @@ ThreadSafeTransaction::ThreadSafeTransaction(ThreadSafeTransaction&& r) noexcept } void ThreadSafeTransaction::reset() { - ISingleThreadTransaction* tr = this->tr; - onMainThreadVoid([tr]() { tr->reset(); }, nullptr); + onMainThreadVoid([tr = this->tr]() { tr->reset(); }, nullptr); } extern const char* getSourceVersion();