thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-12-12 09:22:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

replace every std::shared_mutex with DB::FastSharedMutex

Browse Source
This commit is contained in:
serxa 2023-01-06 23:35:38 +00:00
parent a6958fff45
commit 15bb127b01
28 changed files with 81 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/Common/ProfilingScopedRWLock.h
View File

@ -1,6 +1,6 @@
#pragma once
#include <shared_mutex>
#include <Common/Threading.h>
#include <Common/ProfileEvents.h>
#include <Common/Stopwatch.h>
@ -12,7 +12,7 @@ class ProfilingScopedWriteRWLock
{
public:
ProfilingScopedWriteRWLock(std::shared_mutex & rwl_, ProfileEvents::Event event) :
ProfilingScopedWriteRWLock(DB::FastSharedMutex & rwl_, ProfileEvents::Event event) :
scoped_write_lock(rwl_)
{
ProfileEvents::increment(event, watch.elapsed());
@ -20,14 +20,14 @@ public:
private:
Stopwatch watch;
std::unique_lock<std::shared_mutex> scoped_write_lock;
std::unique_lock<DB::FastSharedMutex> scoped_write_lock;
};
class ProfilingScopedReadRWLock
{
public:
ProfilingScopedReadRWLock(std::shared_mutex & rwl, ProfileEvents::Event event) :
ProfilingScopedReadRWLock(DB::FastSharedMutex & rwl, ProfileEvents::Event event) :
scoped_read_lock(rwl)
{
ProfileEvents::increment(event, watch.elapsed());
@ -35,7 +35,7 @@ public:
private:
Stopwatch watch;
std::shared_lock<std::shared_mutex> scoped_read_lock;
std::shared_lock<DB::FastSharedMutex> scoped_read_lock;
};
}

2
src/Common/ThreadStatus.h
View File

@ -5,6 +5,7 @@
#include <IO/Progress.h>
#include <Common/MemoryTracker.h>
#include <Common/ProfileEvents.h>
#include <Common/Threading.h>
#include <base/StringRef.h>
#include <Common/ConcurrentBoundedQueue.h>
@ -14,7 +15,6 @@
#include <map>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <unordered_set>

6
src/Common/Threading.h
View File

@ -3,7 +3,9 @@
#include <base/types.h>
#include <base/defines.h>
#include <Common/Exception.h>
#include <Common/Exception.h> // for chassert to work
#include <shared_mutex> // for std::shared_lock and std::unique_lock
#ifdef OS_LINUX /// Because of futex
@ -216,8 +218,6 @@ private:
#else
#include <shared_mutex>
// WARNING: We support cancellable synchronization primitives only on linux for now
namespace DB

4
src/Dictionaries/CacheDictionary.h
View File

@ -4,7 +4,6 @@
#include <chrono>
#include <cmath>
#include <mutex>
#include <shared_mutex>
#include <utility>
#include <vector>
@ -14,6 +13,7 @@
#include <Common/randomSeed.h>
#include <Common/ThreadPool.h>
#include <Common/Threading.h>
#include <Common/CurrentMetrics.h>
#include <Dictionaries/IDictionary.h>
@ -206,7 +206,7 @@ private:
/// This lock is used for the inner cache state update function lock it for
/// write, when it need to update cache state all other functions just
/// readers. Surprisingly this lock is also used for last_exception pointer.
mutable std::shared_mutex rw_lock;
mutable DB::FastSharedMutex rw_lock;
mutable std::exception_ptr last_exception;
mutable std::atomic<size_t> error_count {0};

2
src/Dictionaries/CacheDictionaryUpdateQueue.h
View File

@ -2,12 +2,12 @@
#include <atomic>
#include <mutex>
#include <shared_mutex>
#include <utility>
#include <vector>
#include <functional>
#include <Common/ThreadPool.h>
#include <Common/Threading.h>
#include <Common/ConcurrentBoundedQueue.h>
#include <Common/CurrentMetrics.h>
#include <Common/PODArray.h>

2
src/Disks/ObjectStorages/FakeMetadataStorageFromDisk.h
View File

@ -15,7 +15,7 @@ class FakeMetadataStorageFromDisk final : public IMetadataStorage
private:
friend class FakeMetadataStorageFromDiskTransaction;
mutable std::shared_mutex metadata_mutex;
mutable DB::FastSharedMutex metadata_mutex;
DiskPtr disk;
ObjectStoragePtr object_storage;

4
src/Disks/ObjectStorages/MetadataStorageFromDisk.cpp
View File

@ -83,7 +83,7 @@ std::string MetadataStorageFromDisk::readInlineDataToString(const std::string &
return readMetadata(path)->getInlineData();
}
DiskObjectStorageMetadataPtr MetadataStorageFromDisk::readMetadataUnlocked(const std::string & path, std::shared_lock<std::shared_mutex> &) const
DiskObjectStorageMetadataPtr MetadataStorageFromDisk::readMetadataUnlocked(const std::string & path, std::shared_lock<DB::FastSharedMutex> &) const
{
auto metadata = std::make_unique<DiskObjectStorageMetadata>(disk->getPath(), object_storage_root_path, path);
auto str = readFileToString(path);
@ -91,7 +91,7 @@ DiskObjectStorageMetadataPtr MetadataStorageFromDisk::readMetadataUnlocked(const
return metadata;
}
DiskObjectStorageMetadataPtr MetadataStorageFromDisk::readMetadataUnlocked(const std::string & path, std::unique_lock<std::shared_mutex> &) const
DiskObjectStorageMetadataPtr MetadataStorageFromDisk::readMetadataUnlocked(const std::string & path, std::unique_lock<DB::FastSharedMutex> &) const
{
auto metadata = std::make_unique<DiskObjectStorageMetadata>(disk->getPath(), object_storage_root_path, path);
auto str = readFileToString(path);

6
src/Disks/ObjectStorages/MetadataStorageFromDisk.h
View File

@ -17,7 +17,7 @@ class MetadataStorageFromDisk final : public IMetadataStorage
private:
friend class MetadataStorageFromDiskTransaction;
mutable std::shared_mutex metadata_mutex;
mutable DB::FastSharedMutex metadata_mutex;
DiskPtr disk;
std::string object_storage_root_path;
@ -67,8 +67,8 @@ public:
DiskObjectStorageMetadataPtr readMetadata(const std::string & path) const;
DiskObjectStorageMetadataPtr readMetadataUnlocked(const std::string & path, std::unique_lock<std::shared_mutex> & lock) const;
DiskObjectStorageMetadataPtr readMetadataUnlocked(const std::string & path, std::shared_lock<std::shared_mutex> & lock) const;
DiskObjectStorageMetadataPtr readMetadataUnlocked(const std::string & path, std::unique_lock<DB::FastSharedMutex> & lock) const;
DiskObjectStorageMetadataPtr readMetadataUnlocked(const std::string & path, std::shared_lock<DB::FastSharedMutex> & lock) const;
};
class MetadataStorageFromDiskTransaction final : public IMetadataTransaction

30
src/Disks/ObjectStorages/MetadataStorageFromDiskTransactionOperations.cpp
View File

@ -26,7 +26,7 @@ SetLastModifiedOperation::SetLastModifiedOperation(const std::string & path_, Po
{
}
void SetLastModifiedOperation::execute(std::unique_lock<std::shared_mutex> &)
void SetLastModifiedOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
old_timestamp = disk.getLastModified(path);
disk.setLastModified(path, new_timestamp);
@ -44,7 +44,7 @@ ChmodOperation::ChmodOperation(const std::string & path_, mode_t mode_, IDisk &
{
}
void ChmodOperation::execute(std::unique_lock<std::shared_mutex> &)
void ChmodOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
old_mode = disk.stat(path).st_mode;
disk.chmod(path, mode);
@ -61,7 +61,7 @@ UnlinkFileOperation::UnlinkFileOperation(const std::string & path_, IDisk & disk
{
}
void UnlinkFileOperation::execute(std::unique_lock<std::shared_mutex> &)
void UnlinkFileOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
auto buf = disk.readFile(path, ReadSettings{}, std::nullopt, disk.getFileSize(path));
readStringUntilEOF(prev_data, *buf);
@ -81,7 +81,7 @@ CreateDirectoryOperation::CreateDirectoryOperation(const std::string & path_, ID
{
}
void CreateDirectoryOperation::execute(std::unique_lock<std::shared_mutex> &)
void CreateDirectoryOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
disk.createDirectory(path);
}
@ -97,7 +97,7 @@ CreateDirectoryRecursiveOperation::CreateDirectoryRecursiveOperation(const std::
{
}
void CreateDirectoryRecursiveOperation::execute(std::unique_lock<std::shared_mutex> &)
void CreateDirectoryRecursiveOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
namespace fs = std::filesystem;
fs::path p(path);
@ -124,7 +124,7 @@ RemoveDirectoryOperation::RemoveDirectoryOperation(const std::string & path_, ID
{
}
void RemoveDirectoryOperation::execute(std::unique_lock<std::shared_mutex> &)
void RemoveDirectoryOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
disk.removeDirectory(path);
}
@ -141,7 +141,7 @@ RemoveRecursiveOperation::RemoveRecursiveOperation(const std::string & path_, ID
{
}
void RemoveRecursiveOperation::execute(std::unique_lock<std::shared_mutex> &)
void RemoveRecursiveOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
if (disk.isFile(path))
disk.moveFile(path, temp_path);
@ -174,7 +174,7 @@ CreateHardlinkOperation::CreateHardlinkOperation(const std::string & path_from_,
{
}
void CreateHardlinkOperation::execute(std::unique_lock<std::shared_mutex> & lock)
void CreateHardlinkOperation::execute(std::unique_lock<DB::FastSharedMutex> & lock)
{
auto metadata = metadata_storage.readMetadataUnlocked(path_from, lock);
@ -201,7 +201,7 @@ MoveFileOperation::MoveFileOperation(const std::string & path_from_, const std::
{
}
void MoveFileOperation::execute(std::unique_lock<std::shared_mutex> &)
void MoveFileOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
disk.moveFile(path_from, path_to);
}
@ -218,7 +218,7 @@ MoveDirectoryOperation::MoveDirectoryOperation(const std::string & path_from_, c
{
}
void MoveDirectoryOperation::execute(std::unique_lock<std::shared_mutex> &)
void MoveDirectoryOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
disk.moveDirectory(path_from, path_to);
}
@ -236,7 +236,7 @@ ReplaceFileOperation::ReplaceFileOperation(const std::string & path_from_, const
{
}
void ReplaceFileOperation::execute(std::unique_lock<std::shared_mutex> &)
void ReplaceFileOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
if (disk.exists(path_to))
disk.moveFile(path_to, temp_path_to);
@ -262,7 +262,7 @@ WriteFileOperation::WriteFileOperation(const std::string & path_, IDisk & disk_,
{
}
void WriteFileOperation::execute(std::unique_lock<std::shared_mutex> &)
void WriteFileOperation::execute(std::unique_lock<DB::FastSharedMutex> &)
{
if (disk.exists(path))
{
@ -288,7 +288,7 @@ void WriteFileOperation::undo()
}
}
void AddBlobOperation::execute(std::unique_lock<std::shared_mutex> & metadata_lock)
void AddBlobOperation::execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock)
{
DiskObjectStorageMetadataPtr metadata;
if (metadata_storage.exists(path))
@ -309,7 +309,7 @@ void AddBlobOperation::undo()
write_operation->undo();
}
void UnlinkMetadataFileOperation::execute(std::unique_lock<std::shared_mutex> & metadata_lock)
void UnlinkMetadataFileOperation::execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock)
{
auto metadata = metadata_storage.readMetadataUnlocked(path, metadata_lock);
uint32_t ref_count = metadata->getRefCount();
@ -336,7 +336,7 @@ void UnlinkMetadataFileOperation::undo()
write_operation->undo();
}
void SetReadonlyFileOperation::execute(std::unique_lock<std::shared_mutex> & metadata_lock)
void SetReadonlyFileOperation::execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock)
{
auto metadata = metadata_storage.readMetadataUnlocked(path, metadata_lock);
metadata->setReadOnly();

32
src/Disks/ObjectStorages/MetadataStorageFromDiskTransactionOperations.h
View File

@ -13,7 +13,7 @@ class IDisk;
struct IMetadataOperation
{
virtual void execute(std::unique_lock<std::shared_mutex> & metadata_lock) = 0;
virtual void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) = 0;
virtual void undo() = 0;
virtual void finalize() {}
virtual ~IMetadataOperation() = default;
@ -26,7 +26,7 @@ struct SetLastModifiedOperation final : public IMetadataOperation
{
SetLastModifiedOperation(const std::string & path_, Poco::Timestamp new_timestamp_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -41,7 +41,7 @@ struct ChmodOperation final : public IMetadataOperation
{
ChmodOperation(const std::string & path_, mode_t mode_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -57,7 +57,7 @@ struct UnlinkFileOperation final : public IMetadataOperation
{
UnlinkFileOperation(const std::string & path_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -72,7 +72,7 @@ struct CreateDirectoryOperation final : public IMetadataOperation
{
CreateDirectoryOperation(const std::string & path_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -86,7 +86,7 @@ struct CreateDirectoryRecursiveOperation final : public IMetadataOperation
{
CreateDirectoryRecursiveOperation(const std::string & path_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -101,7 +101,7 @@ struct RemoveDirectoryOperation final : public IMetadataOperation
{
RemoveDirectoryOperation(const std::string & path_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -114,7 +114,7 @@ struct RemoveRecursiveOperation final : public IMetadataOperation
{
RemoveRecursiveOperation(const std::string & path_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -130,7 +130,7 @@ struct WriteFileOperation final : public IMetadataOperation
{
WriteFileOperation(const std::string & path_, IDisk & disk_, const std::string & data_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
private:
@ -149,7 +149,7 @@ struct CreateHardlinkOperation final : public IMetadataOperation
IDisk & disk_,
const MetadataStorageFromDisk & metadata_storage_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -166,7 +166,7 @@ struct MoveFileOperation final : public IMetadataOperation
{
MoveFileOperation(const std::string & path_from_, const std::string & path_to_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -181,7 +181,7 @@ struct MoveDirectoryOperation final : public IMetadataOperation
{
MoveDirectoryOperation(const std::string & path_from_, const std::string & path_to_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -196,7 +196,7 @@ struct ReplaceFileOperation final : public IMetadataOperation
{
ReplaceFileOperation(const std::string & path_from_, const std::string & path_to_, IDisk & disk_);
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -226,7 +226,7 @@ struct AddBlobOperation final : public IMetadataOperation
, metadata_storage(metadata_storage_)
{}
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -254,7 +254,7 @@ struct UnlinkMetadataFileOperation final : public IMetadataOperation
{
}
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;
@ -279,7 +279,7 @@ struct SetReadonlyFileOperation final : public IMetadataOperation
{
}
void execute(std::unique_lock<std::shared_mutex> & metadata_lock) override;
void execute(std::unique_lock<DB::FastSharedMutex> & metadata_lock) override;
void undo() override;

4
src/Interpreters/DatabaseCatalog.cpp
View File

@ -729,7 +729,7 @@ DDLGuardPtr DatabaseCatalog::getDDLGuard(const String & database, const String &
return std::make_unique<DDLGuard>(db_guard.first, db_guard.second, std::move(lock), table, database);
}
std::unique_lock<std::shared_mutex> DatabaseCatalog::getExclusiveDDLGuardForDatabase(const String & database)
std::unique_lock<DB::FastSharedMutex> DatabaseCatalog::getExclusiveDDLGuardForDatabase(const String & database)
{
DDLGuards::iterator db_guard_iter;
{
@ -1282,7 +1282,7 @@ TemporaryLockForUUIDDirectory & TemporaryLockForUUIDDirectory::operator = (Tempo
}
DDLGuard::DDLGuard(Map & map_, std::shared_mutex & db_mutex_, std::unique_lock<std::mutex> guards_lock_, const String & elem, const String & database_name)
DDLGuard::DDLGuard(Map & map_, DB::FastSharedMutex & db_mutex_, std::unique_lock<std::mutex> guards_lock_, const String & elem, const String & database_name)
: map(map_), db_mutex(db_mutex_), guards_lock(std::move(guards_lock_))
{
it = map.emplace(elem, Entry{std::make_unique<std::mutex>(), 0}).first;

10
src/Interpreters/DatabaseCatalog.h
View File

@ -6,6 +6,7 @@
#include <Databases/TablesDependencyGraph.h>
#include <Parsers/IAST_fwd.h>
#include <Storages/IStorage_fwd.h>
#include <Common/Threading.h>
#include <boost/noncopyable.hpp>
#include <Poco/Logger.h>
@ -17,7 +18,6 @@
#include <memory>
#include <mutex>
#include <set>
#include <shared_mutex>
#include <unordered_map>
#include <unordered_set>
#include <filesystem>
@ -58,7 +58,7 @@ public:
DDLGuard(
Map & map_,
std::shared_mutex & db_mutex_,
DB::FastSharedMutex & db_mutex_,
std::unique_lock<std::mutex> guards_lock_,
const String & elem,
const String & database_name);
@ -69,7 +69,7 @@ public:
private:
Map & map;
std::shared_mutex & db_mutex;
DB::FastSharedMutex & db_mutex;
Map::iterator it;
std::unique_lock<std::mutex> guards_lock;
std::unique_lock<std::mutex> table_lock;
@ -142,7 +142,7 @@ public:
/// Get an object that protects the table from concurrently executing multiple DDL operations.
DDLGuardPtr getDDLGuard(const String & database, const String & table);
/// Get an object that protects the database from concurrent DDL queries all tables in the database
std::unique_lock<std::shared_mutex> getExclusiveDDLGuardForDatabase(const String & database);
std::unique_lock<DB::FastSharedMutex> getExclusiveDDLGuardForDatabase(const String & database);
void assertDatabaseExists(const String & database_name) const;
@ -298,7 +298,7 @@ private:
/// For the duration of the operation, an element is placed here, and an object is returned,
/// which deletes the element in the destructor when counter becomes zero.
/// In case the element already exists, waits when query will be executed in other thread. See class DDLGuard below.
using DatabaseGuard = std::pair<DDLGuard::Map, std::shared_mutex>;
using DatabaseGuard = std::pair<DDLGuard::Map, DB::FastSharedMutex>;
using DDLGuards = std::map<String, DatabaseGuard>;
DDLGuards ddl_guards TSA_GUARDED_BY(ddl_guards_mutex);
/// If you capture mutex and ddl_guards_mutex, then you need to grab them strictly in this order.

3
src/Interpreters/GraceHashJoin.h
View File

@ -7,6 +7,7 @@
#include <Core/Block.h>
#include <Common/MultiVersion.h>
#include <Common/Threading.h>
#include <mutex>
@ -130,7 +131,7 @@ private:
TemporaryDataOnDiskPtr tmp_data;
Buckets buckets;
mutable std::shared_mutex rehash_mutex;
mutable DB::FastSharedMutex rehash_mutex;
FileBucket * current_bucket = nullptr;
mutable std::mutex current_bucket_mutex;

4
src/Interpreters/InterserverIOHandler.h
View File

@ -7,11 +7,11 @@
#include <IO/WriteBufferFromString.h>
#include <IO/WriteHelpers.h>
#include <Common/ActionBlocker.h>
#include <Common/Threading.h>
#include <base/types.h>
#include <atomic>
#include <map>
#include <shared_mutex>
#include <utility>
namespace zkutil
@ -43,7 +43,7 @@ public:
/// You need to stop the data transfer if blocker is activated.
ActionBlocker blocker;
std::shared_mutex rwlock;
DB::FastSharedMutex rwlock;
};
using InterserverIOEndpointPtr = std::shared_ptr<InterserverIOEndpoint>;

5
src/Interpreters/MergeJoin.h
View File

@ -1,7 +1,6 @@
#pragma once
#include <shared_mutex>
#include <Common/Threading.h>
#include <Common/CacheBase.h>
#include <Core/Block.h>
#include <Core/SortDescription.h>
@ -72,7 +71,7 @@ private:
using Cache = CacheBase<size_t, Block, std::hash<size_t>, BlockByteWeight>;
mutable std::shared_mutex rwlock;
mutable DB::FastSharedMutex rwlock;
std::shared_ptr<TableJoin> table_join;
SizeLimits size_limits;
SortDescription left_sort_description;

2
src/Interpreters/ProcessList.h
View File

@ -19,13 +19,13 @@
#include <Common/Stopwatch.h>
#include <Common/Throttler.h>
#include <Common/OvercommitTracker.h>
#include <Common/Threading.h>
#include <condition_variable>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <unordered_map>
#include <vector>

2
src/Interpreters/Set.cpp
View File

@ -176,7 +176,7 @@ bool Set::insertFromBlock(const ColumnsWithTypeAndName & columns)
bool Set::insertFromBlock(const Columns & columns)
{
std::lock_guard<std::shared_mutex> lock(rwlock);
std::lock_guard lock(rwlock);
if (data.empty())
throw Exception("Method Set::setHeader must be called before Set::insertFromBlock", ErrorCodes::LOGICAL_ERROR);

4
src/Interpreters/Set.h
View File

@ -1,6 +1,5 @@
#pragma once
#include <shared_mutex>
#include <Core/Block.h>
#include <QueryPipeline/SizeLimits.h>
#include <DataTypes/IDataType.h>
@ -8,6 +7,7 @@
#include <Parsers/IAST.h>
#include <Storages/MergeTree/BoolMask.h>
#include <Common/Threading.h>
#include <Common/logger_useful.h>
@ -131,7 +131,7 @@ private:
/** Protects work with the set in the functions `insertFromBlock` and `execute`.
* These functions can be called simultaneously from different threads only when using StorageSet,
*/
mutable std::shared_mutex rwlock;
mutable DB::FastSharedMutex rwlock;
template <typename Method>
void insertFromBlockImpl(

2
src/Storages/IStorage.h
View File

@ -17,9 +17,9 @@
#include <Common/Exception.h>
#include <Common/RWLock.h>
#include <Common/TypePromotion.h>
#include <Common/Threading.h>
#include <optional>
#include <shared_mutex>
#include <compare>

5
src/Storages/MergeTree/IMergeTreeDataPart.h
View File

@ -1,6 +1,7 @@
#pragma once
#include "IO/WriteSettings.h"
#include <Common/Threading.h>
#include <IO/WriteSettings.h>
#include <Core/Block.h>
#include <base/types.h>
#include <Core/NamesAndTypes.h>
@ -22,8 +23,6 @@
#include <DataTypes/Serializations/SerializationInfo.h>
#include <Storages/MergeTree/IPartMetadataManager.h>
#include <shared_mutex>
namespace zkutil
{

2
src/Storages/MergeTree/MergeTreeData.h
View File

@ -1086,7 +1086,7 @@ protected:
MultiVersion<MergeTreeSettings> storage_settings;
/// Used to determine which UUIDs to send to root query executor for deduplication.
mutable std::shared_mutex pinned_part_uuids_mutex;
mutable DB::FastSharedMutex pinned_part_uuids_mutex;
PinnedPartUUIDsPtr pinned_part_uuids;
/// True if at least one part was created/removed with transaction.

6
src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp
View File

@ -25,6 +25,7 @@
#include <Poco/Util/AbstractConfiguration.h>
#include <Common/logger_useful.h>
#include <Common/Exception.h>
#include <Common/Threading.h>
#include <base/sort.h>
#include <rocksdb/table.h>
@ -33,7 +34,6 @@
#include <cstddef>
#include <filesystem>
#include <shared_mutex>
#include <utility>
@ -491,7 +491,7 @@ static StoragePtr create(const StorageFactory::Arguments & args)
std::shared_ptr<rocksdb::Statistics> StorageEmbeddedRocksDB::getRocksDBStatistics() const
{
std::shared_lock<std::shared_mutex> lock(rocksdb_ptr_mx);
std::shared_lock lock(rocksdb_ptr_mx);
if (!rocksdb_ptr)
return nullptr;
return rocksdb_ptr->GetOptions().statistics;
@ -499,7 +499,7 @@ std::shared_ptr<rocksdb::Statistics> StorageEmbeddedRocksDB::getRocksDBStatistic
std::vector<rocksdb::Status> StorageEmbeddedRocksDB::multiGet(const std::vector<rocksdb::Slice> & slices_keys, std::vector<String> & values) const
{
std::shared_lock<std::shared_mutex> lock(rocksdb_ptr_mx);
std::shared_lock lock(rocksdb_ptr_mx);
if (!rocksdb_ptr)
return {};
return rocksdb_ptr->MultiGet(rocksdb::ReadOptions(), slices_keys, &values);

4
src/Storages/RocksDB/StorageEmbeddedRocksDB.h
View File

@ -1,7 +1,7 @@
#pragma once
#include <memory>
#include <shared_mutex>
#include <Common/Threading.h>
#include <Storages/IStorage.h>
#include <Interpreters/IKeyValueEntity.h>
#include <rocksdb/status.h>
@ -86,7 +86,7 @@ private:
const String primary_key;
using RocksDBPtr = std::unique_ptr<rocksdb::DB>;
RocksDBPtr rocksdb_ptr;
mutable std::shared_mutex rocksdb_ptr_mx;
mutable DB::FastSharedMutex rocksdb_ptr_mx;
String rocksdb_dir;
Int32 ttl;
bool read_only;

2
src/Storages/StorageFile.h
View File

@ -3,10 +3,10 @@
#include <Storages/IStorage.h>
#include <Storages/Cache/SchemaCache.h>
#include <Common/Threading.h>
#include <Common/logger_useful.h>
#include <atomic>
#include <shared_mutex>
namespace DB

3
src/Storages/StorageLog.h
View File

@ -1,15 +1,14 @@
#pragma once
#include <map>
#include <shared_mutex>
#include <Disks/IDisk.h>
#include <Storages/IStorage.h>
#include <Common/FileChecker.h>
#include <Common/Threading.h>
#include <Common/escapeForFileName.h>
#include <Core/NamesAndTypes.h>
namespace DB
{

2
src/Storages/StorageStripeLog.h
View File

@ -1,11 +1,11 @@
#pragma once
#include <map>
#include <shared_mutex>
#include <Core/Defines.h>
#include <Storages/IStorage.h>
#include <Formats/IndexForNativeFormat.h>
#include <Common/Threading.h>
#include <Common/FileChecker.h>
#include <Common/escapeForFileName.h>
#include <Disks/IDisk.h>

4
src/Storages/WindowView/StorageWindowView.cpp
View File

@ -1443,11 +1443,11 @@ void StorageWindowView::writeIntoWindowView(
});
}
std::shared_lock<std::shared_mutex> fire_signal_lock;
std::shared_lock<DB::FastSharedMutex> fire_signal_lock;
QueryPipelineBuilder builder;
if (window_view.is_proctime)
{
fire_signal_lock = std::shared_lock<std::shared_mutex>(window_view.fire_signal_mutex);
fire_signal_lock = std::shared_lock(window_view.fire_signal_mutex);
/// Fill ____timestamp column with current time in case of now() time column.
if (window_view.is_time_column_func_now)

2
src/Storages/WindowView/StorageWindowView.h
View File

@ -213,7 +213,7 @@ private:
/// Mutex for the blocks and ready condition
std::mutex mutex;
std::shared_mutex fire_signal_mutex;
DB::FastSharedMutex fire_signal_mutex;
mutable std::mutex sample_block_lock; /// Mutex to protect access to sample block
IntervalKind::Kind window_kind;