*t,
coll_root);
return transaction_manager->submit_transaction(
- std::move(t));
+ *t);
});
});
}).safe_then([this] {
// destruction in debug mode, which need to be done before calling
// submit_transaction().
ctx.onodes.clear();
- return transaction_manager->submit_transaction(std::move(ctx.transaction));
+ return transaction_manager->submit_transaction(*ctx.transaction);
}).safe_then([&ctx]() {
for (auto i : {
ctx.ext_transaction.get_on_applied(),
return transaction_manager->update_root_meta(
*t, key, value
).safe_then([this, &t] {
- return transaction_manager->submit_transaction(std::move(t));
+ return transaction_manager->submit_transaction(*t);
});
});
}).handle_error(
[this](auto &tref) {
return with_trans_intr(*tref, [this, &tref](auto &t) {
return rewrite_dirty(t, get_dirty_tail()
- ).si_then([this, &tref] {
+ ).si_then([this, &t] {
return ecb->submit_transaction_direct(
- std::move(tref));
+ t);
});
});
});
}
});
}
- ).si_then([this, &tref] {
+ ).si_then([this, &t] {
if (scan_cursor->is_complete()) {
- tref->mark_segment_to_release(scan_cursor->get_offset().segment);
+ t.mark_segment_to_release(scan_cursor->get_offset().segment);
}
- return ecb->submit_transaction_direct(std::move(tref));
+ return ecb->submit_transaction_direct(t);
});
});
});
using submit_transaction_direct_ret =
submit_transaction_direct_iertr::future<>;
virtual submit_transaction_direct_ret submit_transaction_direct(
- TransactionRef t) = 0;
+ Transaction &t) = 0;
};
private:
return with_trans_intr(
*transaction,
[this, FNAME, &transaction](auto&) {
- return submit_transaction_direct(std::move(transaction));
+ return submit_transaction_direct(*transaction);
}
).handle_error(
crimson::ct_error::eagain::handle([] {
TransactionManager::submit_transaction_iertr::future<>
TransactionManager::submit_transaction(
- TransactionRef t)
+ Transaction &t)
{
LOG_PREFIX(TransactionManager::submit_transaction);
- DEBUGT("about to await throttle", *t);
- auto &tref = *t;
+ DEBUGT("about to await throttle", t);
return trans_intr::make_interruptible(
- tref.handle.enter(write_pipeline.wait_throttle)
+ t.handle.enter(write_pipeline.wait_throttle)
).then_interruptible([this] {
return trans_intr::make_interruptible(segment_cleaner->await_hard_limits());
- }).then_interruptible([this, t=std::move(t)]() mutable {
- return submit_transaction_direct(std::move(t));
+ }).then_interruptible([this, &t]() {
+ return submit_transaction_direct(t);
});
}
TransactionManager::submit_transaction_direct_ret
TransactionManager::submit_transaction_direct(
- TransactionRef t)
+ Transaction &tref)
{
LOG_PREFIX(TransactionManager::submit_transaction_direct);
- DEBUGT("about to prepare", *t);
- auto &tref = *t;
+ DEBUGT("about to prepare", tref);
return trans_intr::make_interruptible(
tref.handle.enter(write_pipeline.prepare)
).then_interruptible([this, FNAME, &tref]() mutable
crimson::ct_error::all_same_way([](auto e) {
ceph_assert(0 == "Hit error submitting to journal");
}));
- }).finally([t=std::move(t)]() mutable {
- t->handle.exit();
+ }).finally([&tref]() {
+ tref.handle.exit();
});
}
* Atomically submits transaction to persistence
*/
using submit_transaction_iertr = base_iertr;
- submit_transaction_iertr::future<> submit_transaction(TransactionRef);
+ submit_transaction_iertr::future<> submit_transaction(Transaction &);
/// SegmentCleaner::ExtentCallbackInterface
using SegmentCleaner::ExtentCallbackInterface::submit_transaction_direct_ret;
submit_transaction_direct_ret submit_transaction_direct(
- TransactionRef t) final;
+ Transaction &t) final;
using SegmentCleaner::ExtentCallbackInterface::get_next_dirty_extents_ret;
get_next_dirty_extents_ret get_next_dirty_extents(
INT_FORWARD(reserve_region)
INT_FORWARD(find_hole)
PARAM_INT_FORWARD(alloc_extents)
-
-
- auto submit_transaction(TransactionRef t) const {
- return with_trans_intr(
- *t,
- [this, t=std::move(t)](auto &) mutable {
- return tm.submit_transaction(std::move(t));
- });
- }
+ INT_FORWARD(submit_transaction)
INT_FORWARD(read_root_meta)
INT_FORWARD(update_root_meta)
assert(ext->get_bptr().length() == ptr.length());
ext->get_bptr().swap(ptr);
logger().debug("submitting transaction");
- return tm->submit_transaction(std::move(t));
+ return tm->submit_transaction(*t);
});
});
}).handle_error(
[this](auto &t) {
return manager->mkfs(*t
).safe_then([this, &t] {
- return tm->submit_transaction(std::move(t));
+ return tm->submit_transaction(*t);
});
});
}).safe_then([this] {
void with_transaction(F&& f) {
auto t = tm->create_transaction();
std::invoke(f, *t);
- tm->submit_transaction(std::move(t)).unsafe_get0();
+ submit_transaction(std::move(t));
segment_cleaner->run_until_halt().get0();
}
{
auto t = tm->create_transaction();
tree->bootstrap(*t).unsafe_get();
- tm->submit_transaction(std::move(t)).unsafe_get();
+ submit_transaction(std::move(t));
segment_cleaner->run_until_halt().get0();
}
{
auto t = tm->create_transaction();
tree->insert(*t).unsafe_get();
- tm->submit_transaction(std::move(t)).unsafe_get();
+ submit_transaction(std::move(t));
segment_cleaner->run_until_halt().get0();
}
{
{
auto t = tm->create_transaction();
tree->erase(*t, kvs.size() / 4 * 3).unsafe_get();
- tm->submit_transaction(std::move(t)).unsafe_get();
+ submit_transaction(std::move(t));
segment_cleaner->run_until_halt().get0();
}
{
{
auto t = tm->create_transaction();
tree->erase(*t, kvs.size()).unsafe_get();
- tm->submit_transaction(std::move(t)).unsafe_get();
+ submit_transaction(std::move(t));
segment_cleaner->run_until_halt().get0();
}
{
++num_ops;
repeat_eagain([this, &tree, &num_ops_eagain] {
++num_ops_eagain;
- auto t = tm->create_transaction();
- return tree->bootstrap(*t
- ).safe_then([this, t = std::move(t)] () mutable {
- return tm->submit_transaction(std::move(t));
- });
+ return seastar::do_with(
+ tm->create_transaction(),
+ [this, &tree](auto &t) {
+ return tree->bootstrap(*t
+ ).safe_then([this, &t] {
+ return tm->submit_transaction(*t);
+ });
+ });
}).unsafe_get0();
segment_cleaner->run_until_halt().get0();
++num_ops;
repeat_eagain([this, &tree, &num_ops_eagain, &iter] {
++num_ops_eagain;
- auto t = tm->create_transaction();
- return tree->insert_one(*t, iter
- ).safe_then([this, t = std::move(t)] (auto cursor) mutable {
- cursor.invalidate();
- return tm->submit_transaction(std::move(t));
- });
+ return seastar::do_with(
+ tm->create_transaction(),
+ [this, &tree, &iter](auto &t) {
+ return tree->insert_one(*t, iter
+ ).safe_then([this, &t](auto cursor) {
+ cursor.invalidate();
+ return tm->submit_transaction(*t);
+ });
+ });
}).unsafe_get0();
segment_cleaner->run_until_halt().get0();
++iter;
++num_ops;
repeat_eagain([this, &tree, &num_ops_eagain, &iter] {
++num_ops_eagain;
- auto t = tm->create_transaction();
- return tree->erase_one(*t, iter
- ).safe_then([this, t = std::move(t)] () mutable {
- return tm->submit_transaction(std::move(t));
- });
+ return seastar::do_with(
+ tm->create_transaction(),
+ [this, &tree, &iter](auto &t) {
+ return tree->erase_one(*t, iter
+ ).safe_then([this, &t] () mutable {
+ return tm->submit_transaction(*t);
+ });
+ });
}).unsafe_get0();
segment_cleaner->run_until_halt().get0();
++iter;
auto t = tm->create_transaction();
checking_mappings(coll_root, *t);
}
-
- void submit_transaction(TransactionRef &&t) {
- tm->submit_transaction(std::move(t)).unsafe_get0();
- segment_cleaner->run_until_halt().get0();
- }
};
TEST_F(collection_manager_test_t, basic)
object_data_handler_test_t() {}
auto submit_transaction(TransactionRef &&t) {
- return tm->submit_transaction(std::move(t)
+ return tm->submit_transaction(*t
).safe_then([this] {
return segment_cleaner->run_until_halt();
});
omap_manager = omap_manager::create_omap_manager(*tm);
logger().debug("{}: end", __func__);
}
-
- void submit_transaction(TransactionRef &&t) {
- tm->submit_transaction(std::move(t)).unsafe_get0();
- segment_cleaner->run_until_halt().get0();
- }
};
TEST_F(omap_manager_test_t, basic)
bool try_submit_transaction(test_transaction_t t) {
using ertr = with_trans_ertr<TransactionManager::submit_transaction_iertr>;
using ret = ertr::future<bool>;
- bool success = tm->submit_transaction(std::move(t.t)
+ bool success = tm->submit_transaction(*t.t
).safe_then([]() -> ret {
return ertr::make_ready_future<bool>(true);
}).handle_error(
crimson::ct_error::assert_all{"Error in teardown"}
);
}
+
+ void submit_transaction(TransactionRef t) {
+ tm->submit_transaction(*t).unsafe_get0();
+ segment_cleaner->run_until_halt().get0();
+ }
};
class TestSegmentManagerWrapper final : public SegmentManager {
{
auto t = tm->create_transaction();
tree->bootstrap(*t).unsafe_get();
- tm->submit_transaction(std::move(t)).unsafe_get();
- segment_cleaner->run_until_halt().get0();
+ submit_transaction(std::move(t));
}
{
auto t = tm->create_transaction();
tree->insert(*t).unsafe_get();
auto start_time = mono_clock::now();
- tm->submit_transaction(std::move(t)).unsafe_get();
- segment_cleaner->run_until_halt().get0();
+ submit_transaction(std::move(t));
std::chrono::duration<double> duration = mono_clock::now() - start_time;
logger().warn("submit_transaction() done! {}s", duration.count());
}
{
auto t = tm->create_transaction();
tree->erase(*t, kvs.size() * erase_ratio).unsafe_get();
- tm->submit_transaction(std::move(t)).unsafe_get();
- segment_cleaner->run_until_halt().get0();
+ submit_transaction(std::move(t));
}
{
auto t = tm->create_transaction();