ClickHouse/src/Coordination/InMemoryLogStore.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

49 lines
1.2 KiB
C++
Raw Normal View History

2021-01-13 10:32:20 +00:00
#pragma once
#include <atomic>
#include <map>
#include <mutex>
#include <Core/Types.h>
Support for Clang Thread Safety Analysis (TSA) - TSA is a static analyzer build by Google which finds race conditions and deadlocks at compile time. - It works by associating a shared member variable with a synchronization primitive that protects it. The compiler can then check at each access if proper locking happened before. A good introduction are [0] and [1]. - TSA requires some help by the programmer via annotations. Luckily, LLVM's libcxx already has annotations for std::mutex, std::lock_guard, std::shared_mutex and std::scoped_lock. This commit enables them (--> contrib/libcxx-cmake/CMakeLists.txt). - Further, this commit adds convenience macros for the low-level annotations for use in ClickHouse (--> base/defines.h). For demonstration, they are leveraged in a few places. - As we compile with "-Wall -Wextra -Weverything", the required compiler flag "-Wthread-safety-analysis" was already enabled. Negative checks are an experimental feature of TSA and disabled (--> cmake/warnings.cmake). Compile times did not increase noticeably. - TSA is used in a few places with simple locking. I tried TSA also where locking is more complex. The problem was usually that it is unclear which data is protected by which lock :-(. But there was definitely some weird code where locking looked broken. So there is some potential to find bugs. *** Limitations of TSA besides the ones listed in [1]: - The programmer needs to know which lock protects which piece of shared data. This is not always easy for large classes. - Two synchronization primitives used in ClickHouse are not annotated in libcxx: (1) std::unique_lock: A releaseable lock handle often together with std::condition_variable, e.g. in solve producer-consumer problems. (2) std::recursive_mutex: A re-entrant mutex variant. Its usage can be considered a design flaw + typically it is slower than a standard mutex. In this commit, one std::recursive_mutex was converted to std::mutex and annotated with TSA. - For free-standing functions (e.g. helper functions) which are passed shared data members, it can be tricky to specify the associated lock. This is because the annotations use the normal C++ rules for symbol resolution. [0] https://clang.llvm.org/docs/ThreadSafetyAnalysis.html [1] https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/42958.pdf
2022-06-14 22:35:55 +00:00
#include <base/defines.h>
2021-10-27 23:10:39 +00:00
#include <libnuraft/log_store.hxx>
2021-01-13 10:32:20 +00:00
namespace DB
{
class InMemoryLogStore : public nuraft::log_store
{
public:
InMemoryLogStore();
2021-04-08 14:17:57 +00:00
uint64_t start_index() const override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
uint64_t next_slot() const override;
2021-01-13 10:32:20 +00:00
nuraft::ptr<nuraft::log_entry> last_entry() const override;
2021-04-08 14:17:57 +00:00
uint64_t append(nuraft::ptr<nuraft::log_entry> & entry) override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
void write_at(uint64_t index, nuraft::ptr<nuraft::log_entry> & entry) override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
nuraft::ptr<std::vector<nuraft::ptr<nuraft::log_entry>>> log_entries(uint64_t start, uint64_t end) override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
nuraft::ptr<nuraft::log_entry> entry_at(uint64_t index) override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
uint64_t term_at(uint64_t index) override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
nuraft::ptr<nuraft::buffer> pack(uint64_t index, Int32 cnt) override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
void apply_pack(uint64_t index, nuraft::buffer & pack) override;
2021-01-13 10:32:20 +00:00
2021-04-08 14:17:57 +00:00
bool compact(uint64_t last_log_index) override;
2021-01-13 10:32:20 +00:00
bool flush() override { return true; }
private:
Support for Clang Thread Safety Analysis (TSA) - TSA is a static analyzer build by Google which finds race conditions and deadlocks at compile time. - It works by associating a shared member variable with a synchronization primitive that protects it. The compiler can then check at each access if proper locking happened before. A good introduction are [0] and [1]. - TSA requires some help by the programmer via annotations. Luckily, LLVM's libcxx already has annotations for std::mutex, std::lock_guard, std::shared_mutex and std::scoped_lock. This commit enables them (--> contrib/libcxx-cmake/CMakeLists.txt). - Further, this commit adds convenience macros for the low-level annotations for use in ClickHouse (--> base/defines.h). For demonstration, they are leveraged in a few places. - As we compile with "-Wall -Wextra -Weverything", the required compiler flag "-Wthread-safety-analysis" was already enabled. Negative checks are an experimental feature of TSA and disabled (--> cmake/warnings.cmake). Compile times did not increase noticeably. - TSA is used in a few places with simple locking. I tried TSA also where locking is more complex. The problem was usually that it is unclear which data is protected by which lock :-(. But there was definitely some weird code where locking looked broken. So there is some potential to find bugs. *** Limitations of TSA besides the ones listed in [1]: - The programmer needs to know which lock protects which piece of shared data. This is not always easy for large classes. - Two synchronization primitives used in ClickHouse are not annotated in libcxx: (1) std::unique_lock: A releaseable lock handle often together with std::condition_variable, e.g. in solve producer-consumer problems. (2) std::recursive_mutex: A re-entrant mutex variant. Its usage can be considered a design flaw + typically it is slower than a standard mutex. In this commit, one std::recursive_mutex was converted to std::mutex and annotated with TSA. - For free-standing functions (e.g. helper functions) which are passed shared data members, it can be tricky to specify the associated lock. This is because the annotations use the normal C++ rules for symbol resolution. [0] https://clang.llvm.org/docs/ThreadSafetyAnalysis.html [1] https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/42958.pdf
2022-06-14 22:35:55 +00:00
std::map<uint64_t, nuraft::ptr<nuraft::log_entry>> logs TSA_GUARDED_BY(logs_lock);
2021-01-13 10:32:20 +00:00
mutable std::mutex logs_lock;
2021-04-08 14:17:57 +00:00
std::atomic<uint64_t> start_idx;
2021-01-13 10:32:20 +00:00
};
}