104 lines
2.9 KiB
C++
104 lines
2.9 KiB
C++
#include "Facade.h"
|
|
#include "Internal.h"
|
|
|
|
#include <nanobench.h>
|
|
|
|
void monotonicallyIncreasing() {
|
|
constexpr int kWindow = 1000;
|
|
ankerl::nanobench::Bench bench;
|
|
Facade facade{kWindow + 1};
|
|
|
|
bench.minEpochIterations(kWindow * 10);
|
|
|
|
bench.warmup(kWindow).run("monotonically increasing", [&] {
|
|
const int64_t remove = __builtin_bswap64(facade.getVersion() - kWindow);
|
|
const int64_t next = __builtin_bswap64(facade.getVersion());
|
|
weaselab::VersionedMap::Mutation mutations[] = {
|
|
{(const uint8_t *)&remove, nullptr, 8, 0,
|
|
weaselab::VersionedMap::Clear},
|
|
{(const uint8_t *)&next, (const uint8_t *)&next, 8, 8,
|
|
weaselab::VersionedMap::Set},
|
|
};
|
|
facade.addMutations(mutations, sizeof(mutations) / sizeof(mutations[0]),
|
|
facade.getVersion() + 1);
|
|
facade.setOldestVersion(facade.getVersion() - kWindow);
|
|
});
|
|
|
|
const auto v = facade.getVersion() - kWindow / 2;
|
|
const auto begin = facade.versioned.begin(v);
|
|
const auto end = facade.versioned.end(v);
|
|
auto iter = begin;
|
|
|
|
bench.run("deref", [&] { bench.doNotOptimizeAway(*iter); });
|
|
|
|
iter = begin;
|
|
bench.run("++iter", [&] {
|
|
++iter;
|
|
if (iter == end) {
|
|
iter = begin;
|
|
}
|
|
});
|
|
|
|
iter = end;
|
|
bench.run("--iter", [&] {
|
|
--iter;
|
|
if (iter == begin) {
|
|
iter = end;
|
|
}
|
|
});
|
|
|
|
bench.run("begin", [&] { facade.versioned.begin(v); });
|
|
|
|
bench.run("begin (firstGeq)", [&] {
|
|
weaselab::VersionedMap::Key key{nullptr, 0};
|
|
weaselab::VersionedMap::Iterator iter;
|
|
facade.versioned.firstGeq(&key, &v, &iter, 1);
|
|
});
|
|
|
|
bench.run("end", [&] { facade.versioned.end(v); });
|
|
}
|
|
|
|
void bulkFirstGeq() {
|
|
constexpr int kNumKeys = 100000;
|
|
constexpr int kNumQueries = 100;
|
|
ankerl::nanobench::Bench bench;
|
|
bench.batch(kNumQueries);
|
|
|
|
// Initialize `versionedMap`
|
|
weaselab::VersionedMap versionedMap{0};
|
|
for (int64_t i = 0; i < kNumKeys; ++i) {
|
|
const auto bigEndian = __builtin_bswap64(i);
|
|
weaselab::VersionedMap::Mutation m;
|
|
m.param1 = (const uint8_t *)&bigEndian;
|
|
m.param1Len = sizeof(bigEndian);
|
|
m.param2 = (const uint8_t *)&bigEndian;
|
|
m.param2Len = sizeof(bigEndian);
|
|
m.type = weaselab::VersionedMap::Set;
|
|
versionedMap.addMutations(&m, 1, i + 1);
|
|
}
|
|
|
|
// Prepare queries
|
|
Arena arena;
|
|
auto *keys = new (arena) weaselab::VersionedMap::Key[kNumQueries];
|
|
auto *versions = new (arena) int64_t[kNumQueries];
|
|
for (int64_t i = 0; i < kNumQueries; ++i) {
|
|
int64_t version = i * kNumKeys / kNumQueries;
|
|
versions[i] = version;
|
|
const auto bigEndian = __builtin_bswap64(version);
|
|
uint8_t *k = new (arena) uint8_t[sizeof(bigEndian)];
|
|
memcpy(k, &bigEndian, sizeof(bigEndian));
|
|
keys[i].p = k;
|
|
keys[i].len = sizeof(bigEndian);
|
|
}
|
|
|
|
// Bench
|
|
bench.run("bulkFirstGeq", [&] {
|
|
weaselab::VersionedMap::Iterator iterators[kNumQueries];
|
|
versionedMap.firstGeq(keys, versions, iterators, kNumQueries);
|
|
});
|
|
}
|
|
|
|
int main() {
|
|
monotonicallyIncreasing();
|
|
bulkFirstGeq();
|
|
} |