mirror of
https://github.com/facebook/rocksdb.git
synced 2026-10-23 08:09:02 +03:00
4b983da055
Summary: Pull Request resolved: https://github.com/facebook/rocksdb/pull/15387 ## Summary RocksDB's `.clang-tidy` enables `cppcoreguidelines-special-member-functions`, `cppcoreguidelines-virtual-class-destructor` and the noexcept-move checks, and clang warns `-Wdeprecated-copy-with-user-provided-dtor`. A full scan reports 476 findings. In most of them, a class declares a destructor (or copy operations) but leaves the rest of copy/move implicit. That has two costs. Readers can't tell whether a class may be copied or moved. And resource-owning classes keep an implicit copy that would double-free if anyone ever used it. This diff resolves 453 of the 476. Approach, picked per class from least to most invasive: 1. An empty user-provided destructor becomes `= default`. This covers most interface classes, such as `virtual ~X() {}` -> `= default`. If the class is still copied, that would only rename the deprecated-copy warning, so the destructor is removed instead when nothing needs it (`Customizable`, `TableFactory` and `InternalKeyComparator` inherit a virtual one; `IteratorWrapperBase` isn't polymorphic), and `MemTableRep::KeyComparator` gets defaulted copy and move. 2. Classes whose copy is already deleted get explicitly deleted move operations too. Move was already unavailable, so this only documents it. 3. Resource-owning classes that are never copied get deleted copy and move operations. Examples: the C API wrapper structs, which run a `destructor_` callback (edited in `tools/c_api_gen/c_base.cc` and regenerated into `db/c.cc`); `ShardedCache`, which frees its shards; iterator wrappers; and RAII handles. 4. Value types that are copied or moved get the missing operations as `= default`, which keeps their current behavior. 5. Exception specifications of existing functions are unchanged, except for `WriteBatch`'s move assignment (below): no other `noexcept` is added or removed. Only the move operations this diff newly declares (`Comparator`, `FileSampledStats` and the thread-local `Entry`) are `noexcept`; they copy only scalars or atomics. `WriteBatch`'s copy and move assignment destroyed `*this` and placement-new'ed a new `WriteBatch` over it. That is undefined behavior when `*this` is a subclass, and if the copy constructor threw, `*this` was left destroyed and was later destroyed again. Move assignment now assigns member-wise and ends in the same state as the move constructor, which leaves `has_key_with_ts_`, the timestamp-size tracking and the other fields it doesn't copy at their defaults. `rep_` is swapped through a temporary, because a plain string move-assignment can keep the old buffer (e.g. a large batch reset with `batch = WriteBatch()` would keep its memory). Nothing in it can throw, so it is now `noexcept`. Copy assignment copies into a temporary and moves it in, so a throwing copy leaves `*this` unchanged. Bugs this exposed and fixed: - `RestoreAfterCopyOrCreateWorkItem` (backup engine): the hand-written move constructor and assignment moved only some fields, so `from_file` and `to_file` were empty after `push_back(std::move(...))`. A restore that hit a checksum mismatch then reported "While restoring -> : ..." without file names. It now uses the compiler-generated moves, which are still `noexcept`. - `ExternalSstFileIngestionJob` lived in a `std::vector`, and its destructor frees raw-owned pointers, so the implicit copy used on vector reallocation would double-free. Its file batches also point into its own inline file storage, so neither a copy nor a move is safe after `Prepare()`. Copy and move are now deleted, and `DBImpl` holds jobs through `std::unique_ptr`. Compatibility: no public class loses an operation users can call. Public interfaces mostly only get `virtual ~X() = default;`. `WriteBatch`'s move assignment becomes `noexcept`, which is not part of the mangled name, so the ABI doesn't change. `SubcompactionJobInfo` and `CompactionJobInfo` intentionally stay C++20 aggregates, so users' aggregate and designated initializers keep compiling. `Configurable`, `CompareInterface`, `WriteBatchBase`, `ObjectLibrary::Entry` and `MemTableRep::KeyComparator` declare defaulted copy and move, and `Customizable` no longer declares a destructor. As a result, `Configurable` and `Customizable` subclasses that declare no destructor or copy operations of their own now move their registered-options list instead of copying it. In-tree, these are the mutable-options adapters, the table factories, the memory allocators and test classes; all are held through smart pointers or used in place, and `Clone()` copies, so none is moved by value. Not changed (23): `IODebugContext` (custom deep copy plus a `std::shared_mutex`), `DBWithColumnFamilies` in db_bench (stored in a `std::vector` with non-movable members), `Snapshot`'s protected virtual destructor (intended), `ManagedSnapshot`, the `SubcompactionJobInfo` and `CompactionJobInfo` aggregates, and the 16 noexcept-move-constructor and noexcept-swap findings on existing functions, including `autovector`'s move assignment (adding `noexcept` would change their exception specifications). Copying `ManagedSnapshot` already double-releases the snapshot. Fixing that needs a real move implementation and is a behavior change, so it is left for a separate diff. Reviewed By: rban1 Differential Revision: D123186309 fbshipit-source-id: 6f8e57e233e12199a007407130bb9a1f6d52e8d1
87 lines
2.5 KiB
C++
87 lines
2.5 KiB
C++
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
|
|
#pragma once
|
|
|
|
#include <functional>
|
|
|
|
#include "rocksdb/rocksdb_namespace.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
|
|
// Defers the execution of the provided function until the Defer
|
|
// object goes out of scope.
|
|
//
|
|
// Usage example:
|
|
//
|
|
// Status DeferTest() {
|
|
// Status s;
|
|
// Defer defer([&s]() {
|
|
// if (!s.ok()) {
|
|
// // do cleanups ...
|
|
// }
|
|
// });
|
|
// // do something ...
|
|
// if (!s.ok()) return;
|
|
// // do some other things ...
|
|
// return s;
|
|
// }
|
|
//
|
|
// The above code ensures that cleanups will always happen on returning.
|
|
//
|
|
// Without the help of Defer, you can
|
|
// 1. every time when !s.ok(), do the cleanup;
|
|
// 2. instead of returning when !s.ok(), continue the work only when s.ok(),
|
|
// but sometimes, this might lead to nested blocks of "if (s.ok()) {...}".
|
|
//
|
|
// With the help of Defer, you can centralize the cleanup logic inside the
|
|
// lambda passed to Defer, and you can return immediately on failure when
|
|
// necessary.
|
|
class Defer final {
|
|
public:
|
|
explicit Defer(std::function<void()>&& fn) : fn_(std::move(fn)) {}
|
|
~Defer() { fn_(); }
|
|
|
|
// Disallow copy.
|
|
Defer(const Defer&) = delete;
|
|
Defer& operator=(const Defer&) = delete;
|
|
Defer(Defer&&) = delete;
|
|
Defer& operator=(Defer&&) = delete;
|
|
|
|
private:
|
|
std::function<void()> fn_;
|
|
};
|
|
|
|
// An RAII utility object that saves the current value of an object so that
|
|
// it can be overwritten, and restores it to the saved value when the
|
|
// SaveAndRestore object goes out of scope.
|
|
template <typename T>
|
|
class SaveAndRestore {
|
|
public:
|
|
// obj is non-null pointer to value to be saved and later restored.
|
|
explicit SaveAndRestore(T* obj) : obj_(obj), saved_(*obj) {}
|
|
// new_value is stored in *obj
|
|
SaveAndRestore(T* obj, const T& new_value)
|
|
: obj_(obj), saved_(std::move(*obj)) {
|
|
*obj = new_value;
|
|
}
|
|
SaveAndRestore(T* obj, T&& new_value) : obj_(obj), saved_(std::move(*obj)) {
|
|
*obj = std::move(new_value);
|
|
}
|
|
~SaveAndRestore() { *obj_ = std::move(saved_); }
|
|
|
|
// No copies
|
|
SaveAndRestore(const SaveAndRestore&) = delete;
|
|
SaveAndRestore& operator=(const SaveAndRestore&) = delete;
|
|
SaveAndRestore(SaveAndRestore&&) = delete;
|
|
SaveAndRestore& operator=(SaveAndRestore&&) = delete;
|
|
|
|
private:
|
|
T* const obj_;
|
|
T saved_;
|
|
};
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|