96ece11cdd
Summary:
This change introduces a pure virtual initial implementation of the transaction
engine which is then implemented in two versions: single node and distributed.
The interface classes now have the following hierarchy:
```
Engine (pure interface)
|
+----+---------- EngineDistributed (common logic)
| |
EngineSingleNode +-------+--------+
| |
EngineMaster EngineWorker
```
In addition to this layout the `EngineMaster` uses `EngineSingleNode` as its
underlying storage engine and only changes the necessary functions to make
them work with the `EngineWorker`.
After this change I recommend that you delete the following leftover files:
```
rm src/distributed/transactional_cache_cleaner_rpc_messages.*
rm src/transactions/common.*
rm src/transactions/engine_rpc_messages.*
```
Reviewers: teon.banek, msantl, buda
Reviewed By: teon.banek
Subscribers: pullbot
Differential Revision: https://phabricator.memgraph.io/D1589
84 lines
2.2 KiB
C++
84 lines
2.2 KiB
C++
#include "gtest/gtest.h"
|
|
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#include "data_structures/concurrent/skiplist.hpp"
|
|
#include "transactions/single_node/engine_single_node.hpp"
|
|
#include "transactions/transaction.hpp"
|
|
|
|
using namespace tx;
|
|
|
|
TEST(Engine, GcSnapshot) {
|
|
EngineSingleNode engine;
|
|
ASSERT_EQ(engine.GlobalGcSnapshot(), Snapshot({1}));
|
|
|
|
std::vector<Transaction *> transactions;
|
|
// create transactions and check the GC snapshot
|
|
for (int i = 0; i < 5; ++i) {
|
|
transactions.push_back(engine.Begin());
|
|
EXPECT_EQ(engine.GlobalGcSnapshot(), Snapshot({1}));
|
|
}
|
|
|
|
// commit transactions in the middle, expect
|
|
// the GcSnapshot did not change
|
|
engine.Commit(*transactions[1]);
|
|
EXPECT_EQ(engine.GlobalGcSnapshot(), Snapshot({1}));
|
|
engine.Commit(*transactions[2]);
|
|
EXPECT_EQ(engine.GlobalGcSnapshot(), Snapshot({1}));
|
|
|
|
// have the first three transactions committed
|
|
engine.Commit(*transactions[0]);
|
|
EXPECT_EQ(engine.GlobalGcSnapshot(), Snapshot({1, 2, 3, 4}));
|
|
|
|
// commit all
|
|
engine.Commit(*transactions[3]);
|
|
engine.Commit(*transactions[4]);
|
|
EXPECT_EQ(engine.GlobalGcSnapshot(), Snapshot({6}));
|
|
}
|
|
|
|
TEST(Engine, Advance) {
|
|
EngineSingleNode engine;
|
|
|
|
auto t0 = engine.Begin();
|
|
auto t1 = engine.Begin();
|
|
EXPECT_EQ(t0->cid(), 1);
|
|
engine.Advance(t0->id_);
|
|
EXPECT_EQ(t0->cid(), 2);
|
|
engine.Advance(t0->id_);
|
|
EXPECT_EQ(t0->cid(), 3);
|
|
EXPECT_EQ(t1->cid(), 1);
|
|
}
|
|
|
|
TEST(Engine, ConcurrentBegin) {
|
|
EngineSingleNode engine;
|
|
std::vector<std::thread> threads;
|
|
SkipList<TransactionId> tx_ids;
|
|
for (int i = 0; i < 10; ++i) {
|
|
threads.emplace_back([&engine, accessor = tx_ids.access() ]() mutable {
|
|
for (int j = 0; j < 100; ++j) {
|
|
auto t = engine.Begin();
|
|
accessor.insert(t->id_);
|
|
}
|
|
});
|
|
}
|
|
for (auto &t : threads) t.join();
|
|
EXPECT_EQ(tx_ids.access().size(), 1000);
|
|
}
|
|
|
|
TEST(Engine, RunningTransaction) {
|
|
EngineSingleNode engine;
|
|
auto t0 = engine.Begin();
|
|
auto t1 = engine.Begin();
|
|
EXPECT_EQ(t0, engine.RunningTransaction(t0->id_));
|
|
EXPECT_NE(t1, engine.RunningTransaction(t0->id_));
|
|
EXPECT_EQ(t1, engine.RunningTransaction(t1->id_));
|
|
}
|
|
|
|
TEST(Engine, EnsureTxIdGreater) {
|
|
EngineSingleNode engine;
|
|
ASSERT_LE(engine.Begin()->id_, 40);
|
|
engine.EnsureNextIdGreater(42);
|
|
EXPECT_EQ(engine.Begin()->id_, 43);
|
|
}
|