tdlight/benchmark/bench_misc.cpp

462 lines
11 KiB
C++
Raw Normal View History

//
2021-01-01 13:57:46 +01:00
// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2021
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include "td/utils/benchmark.h"
#include "td/utils/common.h"
#include "td/utils/logging.h"
#include "td/utils/port/Clocks.h"
#include "td/utils/port/EventFd.h"
#include "td/utils/port/FileFd.h"
#include "td/utils/port/path.h"
#include "td/utils/port/RwMutex.h"
#include "td/utils/port/Stat.h"
#include "td/utils/port/thread.h"
#include "td/utils/Slice.h"
#include "td/utils/SliceBuilder.h"
2021-08-18 18:26:03 +02:00
#include "td/utils/ThreadSafeCounter.h"
#include "td/telegram/telegram_api.h"
#include "td/telegram/telegram_api.hpp"
#if !TD_WINDOWS
#include <unistd.h>
#include <utime.h>
#endif
#if TD_LINUX || TD_ANDROID || TD_TIZEN
#include <semaphore.h>
#endif
#include <atomic>
#include <cstdint>
class F {
2021-08-18 17:22:41 +02:00
td::uint32 &sum;
public:
2021-08-18 17:22:41 +02:00
explicit F(td::uint32 &sum) : sum(sum) {
}
template <class T>
void operator()(const T &x) const {
2021-08-18 17:22:41 +02:00
sum += static_cast<td::uint32>(x.get_id());
}
};
BENCH(Call, "TL Call") {
2021-08-18 17:22:41 +02:00
td::tl_object_ptr<td::telegram_api::Function> x = td::make_tl_object<td::telegram_api::account_getWallPapers>(0);
td::uint32 res = 0;
F f(res);
for (int i = 0; i < n; i++) {
downcast_call(*x, f);
}
2021-08-18 17:22:41 +02:00
td::do_not_optimize_away(res);
}
#if !TD_EVENTFD_UNSUPPORTED
BENCH(EventFd, "EventFd") {
2021-08-18 17:22:41 +02:00
td::EventFd fd;
fd.init();
for (int i = 0; i < n; i++) {
fd.release();
fd.acquire();
}
fd.close();
}
#endif
BENCH(NewInt, "new int + delete") {
std::uintptr_t res = 0;
for (int i = 0; i < n; i++) {
int *x = new int;
res += reinterpret_cast<std::uintptr_t>(x);
delete x;
}
2021-08-18 17:22:41 +02:00
td::do_not_optimize_away(res);
}
BENCH(NewObj, "new struct, then delete") {
struct A {
2021-08-18 17:22:41 +02:00
td::int32 a = 0;
td::int32 b = 0;
td::int32 c = 0;
td::int32 d = 0;
};
std::uintptr_t res = 0;
A **ptr = new A *[n];
for (int i = 0; i < n; i++) {
ptr[i] = new A();
res += reinterpret_cast<std::uintptr_t>(ptr[i]);
}
for (int i = 0; i < n; i++) {
delete ptr[i];
}
delete[] ptr;
2021-08-18 17:22:41 +02:00
td::do_not_optimize_away(res);
}
#if !TD_THREAD_UNSUPPORTED
BENCH(ThreadNew, "new struct, then delete in several threads") {
2021-08-18 17:22:41 +02:00
NewObjBench a, b;
td::thread ta([&] { a.run(n / 2); });
td::thread tb([&] { b.run(n - n / 2); });
ta.join();
tb.join();
}
#endif
/*
// Too hard for clang (?)
BENCH(Time, "Clocks::monotonic") {
double res = 0;
for (int i = 0; i < n; i++) {
2021-08-18 17:22:41 +02:00
res += td::Clocks::monotonic();
}
2021-08-18 17:22:41 +02:00
td::do_not_optimize_away(res);
}
*/
#if !TD_WINDOWS
2021-08-18 17:22:41 +02:00
class PipeBench final : public td::Benchmark {
public:
int p[2];
2021-08-18 17:22:41 +02:00
td::string get_description() const final {
return "pipe write + read int32";
}
2021-07-03 22:51:36 +02:00
void start_up() final {
int res = pipe(p);
CHECK(res == 0);
}
2021-07-03 22:51:36 +02:00
void run(int n) final {
int res = 0;
for (int i = 0; i < n; i++) {
int val = 1;
auto write_len = write(p[1], &val, sizeof(val));
CHECK(write_len == sizeof(val));
auto read_len = read(p[0], &val, sizeof(val));
CHECK(read_len == sizeof(val));
res += val;
}
2021-08-18 17:22:41 +02:00
td::do_not_optimize_away(res);
}
2021-07-03 22:51:36 +02:00
void tear_down() final {
close(p[0]);
close(p[1]);
}
};
#endif
#if TD_LINUX || TD_ANDROID || TD_TIZEN
2021-08-18 17:22:41 +02:00
class SemBench final : public td::Benchmark {
sem_t sem;
public:
2021-08-18 17:22:41 +02:00
td::string get_description() const final {
return "sem post + wait";
}
2021-07-03 22:51:36 +02:00
void start_up() final {
int err = sem_init(&sem, 0, 0);
CHECK(err != -1);
}
2021-07-03 22:51:36 +02:00
void run(int n) final {
for (int i = 0; i < n; i++) {
sem_post(&sem);
sem_wait(&sem);
}
}
2021-07-03 22:51:36 +02:00
void tear_down() final {
sem_destroy(&sem);
}
};
#endif
#if !TD_WINDOWS
2021-08-18 17:22:41 +02:00
class UtimeBench final : public td::Benchmark {
public:
2021-07-03 22:51:36 +02:00
void start_up() final {
2021-08-18 17:22:41 +02:00
td::FileFd::open("test", td::FileFd::Create | td::FileFd::Write).move_as_ok().close();
}
2021-08-18 17:22:41 +02:00
td::string get_description() const final {
return "utime";
}
2021-07-03 22:51:36 +02:00
void run(int n) final {
for (int i = 0; i < n; i++) {
int err = utime("test", nullptr);
CHECK(err >= 0);
utimbuf buf;
buf.modtime = 123;
buf.actime = 321;
err = utime("test", &buf);
CHECK(err >= 0);
}
}
};
#endif
BENCH(Pwrite, "pwrite") {
2021-08-18 17:22:41 +02:00
auto fd = td::FileFd::open("test", td::FileFd::Create | td::FileFd::Write).move_as_ok();
for (int i = 0; i < n; i++) {
fd.pwrite("a", 0).ok();
}
fd.close();
}
2021-08-18 17:22:41 +02:00
class CreateFileBench final : public td::Benchmark {
td::string get_description() const final {
return "create_file";
}
2021-07-03 22:51:36 +02:00
void start_up() final {
2021-08-18 17:22:41 +02:00
td::mkdir("A").ensure();
}
2021-07-03 22:51:36 +02:00
void run(int n) final {
for (int i = 0; i < n; i++) {
2021-08-18 17:22:41 +02:00
td::FileFd::open(PSLICE() << "A/" << i, td::FileFd::Write | td::FileFd::Create).move_as_ok().close();
}
}
2021-07-03 22:51:36 +02:00
void tear_down() final {
2021-08-18 17:22:41 +02:00
td::walk_path("A/", [&](td::CSlice path, auto type) {
if (type == td::WalkPath::Type::ExitDir) {
2021-08-18 17:22:41 +02:00
td::rmdir(path).ignore();
} else if (type == td::WalkPath::Type::NotDir) {
2021-08-18 17:22:41 +02:00
td::unlink(path).ignore();
}
}).ignore();
}
};
2021-08-18 17:22:41 +02:00
class WalkPathBench final : public td::Benchmark {
td::string get_description() const final {
return "walk_path";
}
2021-07-03 22:51:36 +02:00
void start_up_n(int n) final {
2021-08-18 17:22:41 +02:00
td::mkdir("A").ensure();
for (int i = 0; i < n; i++) {
2021-08-18 17:22:41 +02:00
td::FileFd::open(PSLICE() << "A/" << i, td::FileFd::Write | td::FileFd::Create).move_as_ok().close();
}
}
2021-07-03 22:51:36 +02:00
void run(int n) final {
int cnt = 0;
2021-08-18 17:22:41 +02:00
td::walk_path("A/", [&](td::CSlice path, auto type) {
if (type == td::WalkPath::Type::EnterDir) {
return;
}
2021-08-18 17:22:41 +02:00
td::stat(path).ok();
cnt++;
}).ignore();
}
2021-07-03 22:51:36 +02:00
void tear_down() final {
2021-08-18 17:22:41 +02:00
td::walk_path("A/", [&](td::CSlice path, auto type) {
if (type == td::WalkPath::Type::ExitDir) {
2021-08-18 17:22:41 +02:00
td::rmdir(path).ignore();
} else if (type == td::WalkPath::Type::NotDir) {
2021-08-18 17:22:41 +02:00
td::unlink(path).ignore();
}
}).ignore();
}
};
#if !TD_THREAD_UNSUPPORTED
template <int ThreadN = 2>
2021-08-18 17:22:41 +02:00
class AtomicReleaseIncBench final : public td::Benchmark {
td::string get_description() const final {
return PSTRING() << "AtomicReleaseInc" << ThreadN;
}
2021-08-18 17:22:41 +02:00
static std::atomic<td::uint64> a_;
2021-07-03 22:51:36 +02:00
void run(int n) final {
2021-08-18 17:22:41 +02:00
td::vector<td::thread> threads;
for (int i = 0; i < ThreadN; i++) {
threads.emplace_back([&] {
for (int i = 0; i < n / ThreadN; i++) {
a_.fetch_add(1, std::memory_order_release);
}
});
}
for (auto &thread : threads) {
thread.join();
}
}
};
template <int ThreadN>
2021-08-18 17:22:41 +02:00
std::atomic<td::uint64> AtomicReleaseIncBench<ThreadN>::a_;
template <int ThreadN = 2>
2021-08-18 17:22:41 +02:00
class AtomicReleaseCasIncBench final : public td::Benchmark {
td::string get_description() const final {
return PSTRING() << "AtomicReleaseCasInc" << ThreadN;
}
2021-08-18 17:22:41 +02:00
static std::atomic<td::uint64> a_;
2021-07-03 22:51:36 +02:00
void run(int n) final {
2021-08-18 17:22:41 +02:00
td::vector<td::thread> threads;
for (int i = 0; i < ThreadN; i++) {
threads.emplace_back([&] {
for (int i = 0; i < n / ThreadN; i++) {
auto value = a_.load(std::memory_order_relaxed);
while (!a_.compare_exchange_strong(value, value + 1, std::memory_order_release, std::memory_order_relaxed)) {
}
}
});
}
for (auto &thread : threads) {
thread.join();
}
}
};
template <int ThreadN>
2021-08-18 17:22:41 +02:00
std::atomic<td::uint64> AtomicReleaseCasIncBench<ThreadN>::a_;
2021-08-18 18:26:03 +02:00
template <int ThreadN>
2021-08-18 17:22:41 +02:00
class RwMutexReadBench final : public td::Benchmark {
td::string get_description() const final {
return PSTRING() << "RwMutexRead" << ThreadN;
}
2021-08-18 17:22:41 +02:00
td::RwMutex mutex_;
2021-07-03 22:51:36 +02:00
void run(int n) final {
2021-08-18 17:22:41 +02:00
td::vector<td::thread> threads;
for (int i = 0; i < ThreadN; i++) {
threads.emplace_back([&] {
for (int i = 0; i < n / ThreadN; i++) {
mutex_.lock_read().ensure();
}
});
}
for (auto &thread : threads) {
thread.join();
}
}
};
2021-08-18 18:26:03 +02:00
template <int ThreadN>
2021-08-18 17:22:41 +02:00
class RwMutexWriteBench final : public td::Benchmark {
td::string get_description() const final {
return PSTRING() << "RwMutexWrite" << ThreadN;
}
2021-08-18 17:22:41 +02:00
td::RwMutex mutex_;
2021-07-03 22:51:36 +02:00
void run(int n) final {
2021-08-18 17:22:41 +02:00
td::vector<td::thread> threads;
for (int i = 0; i < ThreadN; i++) {
threads.emplace_back([&] {
for (int i = 0; i < n / ThreadN; i++) {
mutex_.lock_write().ensure();
}
});
}
for (auto &thread : threads) {
thread.join();
}
}
};
2021-08-18 18:26:03 +02:00
class ThreadSafeCounterBench final : public td::Benchmark {
static td::ThreadSafeCounter counter_;
int thread_count_;
td::string get_description() const final {
return PSTRING() << "ThreadSafeCounter" << thread_count_;
}
void run(int n) final {
counter_.clear();
td::vector<td::thread> threads;
for (int i = 0; i < thread_count_; i++) {
threads.emplace_back([n] {
for (int i = 0; i < n; i++) {
counter_.add(1);
}
});
}
for (auto &thread : threads) {
thread.join();
}
CHECK(counter_.sum() == n * thread_count_);
}
public:
explicit ThreadSafeCounterBench(int thread_count) : thread_count_(thread_count) {
}
};
td::ThreadSafeCounter ThreadSafeCounterBench::counter_;
template <bool StrictOrder>
class AtomicCounterBench final : public td::Benchmark {
static std::atomic<td::int64> counter_;
int thread_count_;
td::string get_description() const final {
return PSTRING() << "AtomicCounter" << thread_count_;
}
void run(int n) final {
counter_.store(0);
td::vector<td::thread> threads;
for (int i = 0; i < thread_count_; i++) {
threads.emplace_back([n] {
for (int i = 0; i < n; i++) {
counter_.fetch_add(1, StrictOrder ? std::memory_order_seq_cst : std::memory_order_relaxed);
}
});
}
for (auto &thread : threads) {
thread.join();
}
CHECK(counter_.load() == n * thread_count_);
}
public:
explicit AtomicCounterBench(int thread_count) : thread_count_(thread_count) {
}
};
template <bool StrictOrder>
std::atomic<td::int64> AtomicCounterBench<StrictOrder>::counter_;
#endif
int main() {
SET_VERBOSITY_LEVEL(VERBOSITY_NAME(DEBUG));
#if !TD_THREAD_UNSUPPORTED
2021-08-18 18:26:03 +02:00
for (int i = 1; i <= 16; i *= 2) {
td::bench(ThreadSafeCounterBench(i));
td::bench(AtomicCounterBench<false>(i));
td::bench(AtomicCounterBench<true>(i));
}
2021-08-18 17:22:41 +02:00
td::bench(AtomicReleaseIncBench<1>());
td::bench(AtomicReleaseIncBench<2>());
td::bench(AtomicReleaseCasIncBench<1>());
td::bench(AtomicReleaseCasIncBench<2>());
td::bench(RwMutexWriteBench<1>());
td::bench(RwMutexReadBench<1>());
2021-08-18 18:26:03 +02:00
td::bench(RwMutexWriteBench<2>());
td::bench(RwMutexReadBench<2>());
#endif
#if !TD_WINDOWS
2021-08-18 17:22:41 +02:00
td::bench(UtimeBench());
#endif
2021-08-18 17:22:41 +02:00
td::bench(WalkPathBench());
td::bench(CreateFileBench());
td::bench(PwriteBench());
2021-08-18 17:22:41 +02:00
td::bench(CallBench());
#if !TD_THREAD_UNSUPPORTED
2021-08-18 17:22:41 +02:00
td::bench(ThreadNewBench());
#endif
#if !TD_EVENTFD_UNSUPPORTED
2021-08-18 17:22:41 +02:00
td::bench(EventFdBench());
#endif
2021-08-18 17:22:41 +02:00
td::bench(NewObjBench());
td::bench(NewIntBench());
#if !TD_WINDOWS
2021-08-18 17:22:41 +02:00
td::bench(PipeBench());
#endif
#if TD_LINUX || TD_ANDROID || TD_TIZEN
2021-08-18 17:22:41 +02:00
td::bench(SemBench());
#endif
}