text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>horeConstraint(SchedulerNodeFactory & factory)
{
factory.registerMethod<SemaphoreConstraint>("inflight_limit");
}
}
<|fim_prefix|>#include <Common/Scheduler/Nodes/SemaphoreConstraint.h>
#include <Common/Scheduler/Nodes/SchedulerNodeFactory.h>
#include <Com<|fim_middle|>mon/Scheduler/Nodes/registerSc... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/ISchedulerNode.h>
#include <Common/Scheduler/ISchedulerConstraint.h>
#include <mutex>
#include <limits>
#include <utility>
namespace DB
{
/*
* Limited concurrency constraint.
* Blocks if either number of concurrent in-flight requests exceeds `max_requests`, or... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>deFactory.h>
#include <Common/Scheduler/Nodes/registerSchedulerNodes.h>
namespace DB
{
void registerThrottlerConstraint(SchedulerNodeFactory & factory)
{
factory.registerMethod<ThrottlerConstraint>("bandwidth_limit");
}
}
<|fim_prefix|>#include <Common/Scheduler/Nodes/ThrottlerConstraint.h>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ive() && parent)
parent->activateChild(this);
}
bool isActive() override
{
return active();
}
size_t activeChildren() override
{
return child_active;
}
bool isSatisfied() override
{
return satisfied();
}
double getTokens()... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Priority.h>
#include <Common/Scheduler/Nodes/PriorityPolicy.h>
#include <Common/Scheduler/Nodes/FairPolicy.h>
#include <Common/Scheduler/Nodes/ThrottlerConstraint.h>
#include <Common/Scheduler/Nodes/SemaphoreConstraint.h>
#include <Common/Scheduler/ISchedulerQueue.h>
#includ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>assifier::attach(const ResourcePtr & resource, const VersionPtr & version, UnifiedSchedulerNode * node)
{
std::unique_lock lock{mutex};
chassert(!attachments.contains(resource->getName()));
ResourceLink link;
WorkloadSettings wl_settings{};
if (node)
{
auto queue = node->ge... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> called from query threads (possibly multiple)
bool has(const String & resource_name) override;
ResourceLink get(const String & resource_name) override;
WorkloadSettings getWorkloadSettings(const String & resource_name) const override;
/// Attaches/detaches a specific reso... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Scheduler/Nodes/registerSchedulerNodes.h>
#include <Common/Scheduler/ISchedulerNode.h>
#include <Common/Scheduler/ISchedulerConstraint.h>
#include <Common/Scheduler/Nodes/SchedulerNodeFactory.h>
n<|fim_suffix|>reConstraint(factory);
registerThrottlerConstraint(factory);
// ISch... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
namespace DB
{
class SchedulerNodeFactory;
void registerPriorityPolicy(SchedulerNodeFactory &);
void registerFairPolicy(SchedulerNodeFactory &);
void registerSemaphoreConstraint(SchedulerNodeFactory &);
void registerThrottlerConstraint(SchedulerNodeFactory &);
void registerFifoQueue(SchedulerNodeFactory... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> {
EXPECT_GE(consumed_cost[name], value - error);
EXPECT_LE(consumed_cost[name], value + error);
consumed_cost[name] -= value;
}
void failed(ResourceCost value)
{
EXPECT_EQ(failed_cost, value);
failed_cost -= value;
}
void processEvents()
... | fim | ClickHouse/ClickHouse | c |
#include <gtest/gtest.h>
#include <Common/Scheduler/Nodes/tests/ResourceTest.h>
#include <Common/Scheduler/Nodes/CustomResourceManager.h>
#include <Poco/Util/XMLConfiguration.h>
using namespace DB;
using ResourceTest = ResourceTestManager<CustomResourceManager>;
using TestGuard = ResourceTest::Guard;
TEST(Schedule... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <chrono>
#include <thread>
#include <gtest/gtest.h>
#include <Common/Scheduler/ISchedulerNode.h>
using namespace DB;
class FakeSchedulerNode : public ISchedulerNode
{
public:
explicit FakeSchedulerNode(String & log_, EventQueue * event_queue_, const Poco::Util::AbstractConfiguration & conf... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/Scheduler/Nodes/tests/ResourceTest.h>
#include <Common/Scheduler/Nodes/FairPolicy.h>
using namespace DB;
using ResourceTest = ResourceTestClass;
TEST(SchedulerFairPolicy, Factory)
{
ResourceTest t;
Poco::AutoPtr<Poco::Util::XMLConfiguration> cfg = ne... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
t.dequeue(3);
t.consumed("A", 0);
t.consumed("B", 10);
t.consumed("C", 20);
t.dequeue(2);
t.consumed("A", 20);
t.consumed("B", 0);
t.consumed("C", 0);
t.enqueue("/B", {10, 10, 10});
t.dequeue(2);
t.consumed("A", 0);
t.consumed("B", 20);
t.consumed("C"... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <gtest/gtest.h>
#include <Common/setThreadName.h>
#include <Common/Scheduler/Nodes/SemaphoreConstraint.h>
#include <Common/Scheduler/Nodes/tests/ResourceTest.h>
#include <Common/Scheduler/SchedulerRoot.h>
#include <Common/randomSeed.h>
#include <barrier>
#include <future>
#include <pcg_random.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <chrono>
#include <gtest/gtest.h>
#include <Common/Scheduler/Nodes/tests/ResourceTest.h>
#include <Common/Scheduler/Nodes/FairPolicy.h>
#include <Common/Scheduler/Nodes/ThrottlerConstraint.h>
using namespace DB;
using ResourceTest = ResourceTestClass;
TEST(SchedulerThrottlerConstraint, Leaky... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <chrono>
#include <gtest/gtest.h>
#include <Common/Scheduler/ResourceGuard.h>
#include <Common/Scheduler/ResourceLink.h>
#include <Common/Scheduler/Nodes/tests/ResourceTest.h>
#include <Common/Priority.h>
#include <Common/Scheduler/Nodes/FairPolicy.h>
#include <Common/Scheduler/Nodes/UnifiedSch... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#include <algorithm>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <gtest/gtest.h>
#include <Core/Defines.h>
#include <Core/Settings.h>
#include <Common/EventRateMeter.h>
#include <Common/Stopwatch.h>
#include <Common/setThreadName.h>
#incl... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> switch (mode)
{
case ResourceAccessMode::DiskRead: return CostUnit::IOByte;
case ResourceAccessMode::DiskWrite: return CostUnit::IOByte;
case ResourceAccessMode::MasterThread: return CostUnit::CPUNanosecond;
case ResourceAccessMode::WorkerThread: return CostUnit::CP... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <Common/Scheduler/ResourceRequest.h>
#include <atomic>
namespace DB
{
/*
* Helper class to keep track of requested and consumed amount of resource.
* Useful if real amount of consumed resource can differ from requested amount of resource (e.g. in case of failures).
* Can be safely used from ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#incl<|fim_suffix|>with_stacktrace = */ false));
}
}
<|fim_middle|>ude <Common/Scheduler/ResourceGuard.h>
#include <Common/CurrentThread.h>
namespace DB
{
namespace ErrorCodes
{
extern const int RESOURCE_ACCESS_DENIED;
}
void ResourceGuard::Request::wait()
{
CurrentMetrics::Increment scheduled... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Common/Scheduler/ISchedulerConstraint.h>
#include <Common/Scheduler/ISchedulerQueue.h>
#include <Common/Scheduler/ResourceRequest.h>
#include <Common/Scheduler/ResourceLink.h>
#include <Common/ProfileEvents.h>
#include <Common/CurrentMetrics.h>
#include <... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>perator bool() const { return queue != nullptr; }
void reset()
{
queue = nullptr;
}
};
/*
* Everything required for IO scheduling.
* Note that raw pointer are stored inside, so make sure that `ClassifierPtr` that produced
* resource links will outlive them. Usually classifier is s... | fim | ClickHouse/ClickHouse | c |
#include <Common/Scheduler/ResourceRequest.h>
#include <Common/Scheduler/ISchedulerConstraint.h>
#include <Common/Exception.h>
#include <ranges>
namespace DB
{
void ResourceRequest::finish()
{
// Iterate over constraints in reverse order
for (ISchedulerConstraint * constraint : std::ranges::reverse_view(con... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <boost/intrusive/list.hpp>
#include <base/types.h>
#include <array>
#include <limits>
#include <exception>
namespace DB
{
// Forward declarations
class ISchedulerQueue;
class ISchedulerConstraint;
/// Cost in terms of used resource (e.g. bytes for network IO)
using ResourceCost = Int64;
conste... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <base/defines.h>
#include <Common/Stopwatch.h>
#include <Common/ThreadPool.h>
#include <Common/setThreadName.h>
#include <Common/Scheduler/ISchedulerNode.h>
#include <Common/Scheduler/ISchedulerConstraint.h>
#include <Poco/Util/XMLConfiguration.h>
#include <unordered_map>
#include <memory>
#in... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <base/scope_guard.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
#include <Poco/Util/AbstractConfiguration.h>
namespace DB
{
class IAST;
struct Settings;
enum class WorkloadEntityType : uint8_t
{
Workload,
Resource,
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>tring &,
ASTPtr,
bool,
bool,
const Settings &)
{
// Config storage is read-only - entities come from config, not SQL. This function should not be called
return OperationResult::Failed;
}
WorkloadEntityConfigStorage::OperationResult WorkloadEntityConfigStorage::removeEntityImpl(
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/Workload/WorkloadEntityStorageBase.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
#include <Poco/Util/AbstractConfiguration.h>
namespace DB
{
/// Loads RESOURCE and WORKLOAD sql objects from configuration.
/// Similar to WorkloadEntityKee... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Scheduler/Workload/WorkloadEntityDiskStorage.h>
#include <Common/StringUtils.h>
#include <Common/atomicRename.h>
#include <Common/escapeForFileName.h>
#include <Common/logger_useful.h>
#include <Common/quoteString.h>
#include <Core/Settings.h>
#include <IO/ReadBufferFromFile.h>
#includ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/Scheduler/Workload/WorkloadEntityStorageBase.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
/// Loads workload entities from a specified folder.
class WorkloadEntityDiskStorage : public WorkloadEntityStorageBase
{
public:
Workloa... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>CurrentException(log, "Will try to restart watching thread after error");
zookeeper_getter.resetCache();
sleepForSeconds(5);
}
}
LOG_DEBUG(log, "Stopped watching thread");
}
void WorkloadEntityKeeperStorage::stopWatching()
{
stopWatchingThread();
}
void Work... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>reate_entity_query,
bool throw_if_exists,
bool replace_if_exists,
const Settings & settings) override;
OperationResult removeEntityImpl(
const ContextPtr & current_context,
WorkloadEntityType entity_type,
const String & entity_name,
bool throw_i... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Scheduler/Workload/WorkloadEntityStorageBase.h>
#include <Common/Scheduler/WorkloadSettings.h>
#include <Common/logger_useful.h>
#include <Common/StringUtils.h>
#include <Core/Defines.h>
#include <Core/Settings.h>
#include <Interpreters/Context.h>
#include <Parsers/ASTCreateWorkloadQuery... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <unordered_map>
#include <list>
#include <mutex>
#include <unordered_set>
#include <Common/Logger_fwd.h>
#include <Common/Scheduler/Workload/IWorkloadEntityStorage.h>
#include <Interpreters/Context_fwd.h>
#include <Parsers/IAST_fwd.h>
namespace DB
{
class WorkloadEntityStorageBa... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Scheduler/Workload/createWorkloadEntityStorage.h>
#include <Common/Scheduler/Workload/WorkloadEntityDiskStorage.h>
#include <Common/Scheduler/Workload/WorkloadEntityKeeperStorage.h>
#include <Common/Scheduler/Workload/WorkloadEntityConfigStorage.h>
#include <Common/Scheduler/Workload/Work... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Ptr & global_context);
}
<|fim_prefix|>#pragma <|fim_middle|>once
#include <Interpreters/Context_fwd.h>
#include <Common/Scheduler/Workload/IWorkloadEntityStorage.h>
namespace DB
{
std::unique_ptr<IWorkloadEntityStorage> createWorkloadEntityStorage(const ContextMutable<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <limits>
#include <Common/Scheduler/CostUnit.h>
#include <Common/getNumberOfCPUCoresToUse.h>
#include <Common/Scheduler/WorkloadSettings.h>
#include <Common/Scheduler/ISchedulerNode.h>
#include <Parsers/ASTSetQuery.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Common/Priority.h>
#include <Parsers/ASTCreateWorkloadQuery.h>
#include <Parsers/ASTCreateResourceQuery.h>
#include <limits>
namespace DB
{
// Represent parsed version for SETTINGS clause in CREATE WORKLOAD query
// Note t<|fim_suffix|>epend on cost unit... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Scheduler/createResourceManager.h>
#include <Common/Scheduler/Nodes/CustomResourceManager.h>
#include <Common/Scheduler/Nodes/WorkloadResourceManager.h>
#include <Interpreters/Context.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <memory>
#include <vector>
namespace DB
{
na... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>
}
<|fim_prefix|>#pragma once
#include <Interpreters/Context_fwd.h>
#include <Common/Scheduler/IResourceManager.h>
namespace <|fim_middle|>DB
{
ResourceManagerPtr createResourceManager(const ContextMutablePtr & global_context);<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SensitiveDataMasker.h>
#include <set>
#include <string>
#include <atomic>
#include <Poco/Util/AbstractConfiguration.h>
#include <Common/logger_useful.h>
#include <Common/re2.h>
#include <Common/Exception.h>
#include <Common/StringUtils.h>
#include <Common/ProfileEvents.h>
#ifndef NDE... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> can't own, as Context is destroyed before logger,
/// and logger lives longer and logging can still happen after Context destruction.
/// resetting masker in the logger at the moment of
/// context destruction can't be done without synchronization / locks in a safe manner.
///
/// logger is Poc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>oryTracking<K>>;
template <typename K, typename Compare = std::less<K>>
using MultiSetWithMemoryTracking = std::multiset<K, Compare, AllocatorWithMemoryTracking<K>>;
}
<|fim_prefix|>#pragma once
#include <Common/AllocatorWithMemoryTracking.h>
#include <set>
namespace DB
{
/// We do track memory allo... | fim | ClickHouse/ClickHouse | c |
#pragma once
namespace DB
{
enum class SettingConstraintWritability : uint8_t
{
// Default. Setting can be change within specified range only in `readonly=0` or `readonly=2` mode.
WRITABLE,
// Setting cannot be changed at all.
// Either READONLY or CONST keyword in SQL syntax can be used (<readonly/... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <string_view>
namespace DB
{
enum SettingSource
{
/// Query or session change:
/// SET <setting> = <value>
/// SELECT ... SETTINGS [<setting> = <value]
QUERY,
/// Profile creation or altering:
/// CREATE SETTINGS PROFILE ... SETTINGS [<set... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SettingsChanges.h><|fim_suffix|>ace_back(name, value);
return true;
}
void SettingsChanges::setSetting(std::string_view name, const Field & value)
{
if (auto * setting_value = tryGet(name))
*setting_value = value;
else
insertSetting(name, value);
}
bool Setti... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Field.h>
#include <vector>
namespace DB
{
struct SettingChange
{
String name;
Field value;
SettingChange() = default;
SettingChan<|fim_suffix|>me);
/// Inserts element if doesn't exists and returns true, otherwise just returns false
bool insertSett... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Common/Exception.h>
#include <base/defines.h>
#include <shared_mutex>
namespace DB
{
na<|fim_suffix|> Mutex>
class TSA_SCOPED_LOCKABLE SharedLockGuard
{
public:
explicit SharedLockGuard(Mutex & mutex_) TSA_ACQUIRE_SHARED(mutex_) : shared_lock(mutex_) {}
explicit SharedL... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#ifdef OS_LINUX /// Because of futex
#include <Common/SharedMutex.h>
#include <Common/futex.h>
namespace DB
{
SharedMutex::SharedMutex()
: state(0)
, waiters(0)
{}
void SharedMutex::lock()
{
/// Try fast acquire
UInt64 value = 0;
if (likely(state.compare_exchange_strong(value, writ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>dif
<|fim_prefix|>#pragma once
#include <base/defines.h>
#ifdef OS_LINUX /// Because of futex
#include <base/types.h>
#include <atomic>
namespace DB
{
// Faster implementation of STD shared_mutex <|fim_middle|>based on a pair of futexes
// See https://github.com/ClickHouse/ClickHouse/issues/87060 fo... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>READ_SAFETY_ANALYSIS
{
mutex.unlock_shared();
}
MutexType mutex;
};
}
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <base/defines.h>
#include <Common/SharedMutex.h>
namespace DB
{
/** SharedMutexHelper class allows to inject specific logic when underlying shared mute... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>al_rusage{};
while (waitpid_retcode < 0)
{
/// Reap the child. With `Config::collect_resource_usage` (executable UDFs),
/// use `wait4` to also collect the child's `rusage`: it is `waitpid` plus an
/// `rusage` out-parameter and shares its pid/status/options/EINTR semantic... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <unordered_map>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromFile.h>
#include <Common/VectorWithMemoryTracking.h>
#include <base/types.h>
namespace DB
{
/** Lets you run the command,
* read it stdout and stderr; write to stdin;
* wait fo... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>t std::string & config)
{
auto reaction = magic_enum::enum_cast<ExternalCommandStderrReaction>(Poco::toUpper(config));
if (!reaction)
throw Exception(
ErrorCodes::BAD_ARGUMENTS,
"Unknown stderr_reaction: {}. Possible values are 'none', 'log', 'log_first', 'log_last'... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
namespace DB
{
enum class ExternalComm<|fim_suffix|>OG_FIRST, /// Try to log first 1_KiB outputs of stderr from the external command after exit.
LOG_LAST, /// Same as above, but log last 1_KiB outputs.
THROW /// Immediately throw exception when the external comman... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/logger_useful.h>
#include <Common/Exception.h>
#include <Common/ShellCommandsHolder.h>
namespace DB
{
ShellCommandsHolder & ShellCommandsHolder::instance()
{
static ShellCommandsHolder instance;
return instance;
}
void ShellCommandsHolder::removeCommand(pid_t pid)
{
std::lo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>mmand);
private:
using ShellCommands = std::unordered_map<pid_t, std::unique_ptr<ShellCommand>>;
std::mutex mutex;
ShellCommands shell_commands TSA_GUARDED_BY(mutex);
LoggerPtr log = getLogger("ShellCommandsHolder");
};
}
<|fim_prefix|>#pragma once
#include <Common/Logger.h>
#include ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SignalHandlers.h>
#include <Common/config_version.h>
#include <Common/getHashOfLoadedBinary.h>
#include <Common/ShellCommandsHolder.h>
#include <Common/CurrentThread.h>
#include <Common/SymbolIndex.h>
#include <Common/FramePointers.h>
#include <Common/ErrnoException.h>
#include <Daemon/Ba... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <csignal>
#include <base/defines.h>
#include <Common/Logger_fwd.h>
#include <Common/PipeFDs.h>
#include <Common/StackTrace.h>
#include <Common/ThreadStatus.h>
#include <Core/Types.h>
#include <Poco/Runnable.h>
class BaseDaemon;
/** Reset signal handler to the default and send sig... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/SignalUnsafeMutationGuard.h>
namespace DB
{
SignalUnsafeMutation<|fim_suffix|>eMutationGuard::~SignalUnsafeMutationGuard()
{
std::atomic_signal_fence(std::memory_order_seq_cst);
is_usable.store(true, std::memory_order_relaxed);
}
}
<|fim_middle|>Guard::SignalUnsafeMutationGuard... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#includ<|fim_suffix|>
/// Marks signal-observed data unusable during mutation and usable again on destruction.
class SignalUnsafeMutationGuard
{
public:
explicit SignalUnsafeMutationGuard(std::atomic<bool> & is_usable_);
~SignalUnsafeMutationGuard();
private:
std::atomic<bool> ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>pleIncrement
{
std::atomic<UInt64> value{0};
void set(UInt64 new_value)
{
value = new_value;
}
UInt64 get()
{
return ++value;
}
};
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <atomic><|fim_middle|>
/** Is used for numbering of files.
*/
st... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/Exception.h>
#include <Common/SipHash.h>
namespace DB::ErrorC<|fim_suffix|>AL_ERROR;
}
UInt128 SipHash::get128Reference()
{
if (!is_reference_128)
throw DB::Exception(
DB::ErrorCodes::LOGICAL_ERROR, "Can't call get128Reference when is_reference_128 is not set");
... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
/** SipHash is a fast cryptographic hash function for short strings.
* Taken from here: https://www.131002.net/siphash/
*
* This is SipHash 2-4 variant.
*
* Two changes are made:
* - returns also 128 bits, not only 64;
* - done streaming (can be calculated in parts).
*
* On short strings... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>nter_list.size();
counter_map.insertIfNotPresent(counter.key, counter.hash, pos);
counter_list.push_back(std::move(counter));
truncateIfNeeded(false);
}
ALWAYS_INLINE void truncateIfNeeded(bool force_counter_map_rebuild)
{
if (unlikely(counter_list.size() >= ta... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/StackTrace.h>
#include <base/FnTraits.h>
#include <base/constexpr_helpers.h>
#include <base/demangle.h>
#include <base/MemorySanitizer.h>
#include <Common/Dwarf.h>
#include <Common/Elf.h>
#include <Common/SharedMutex.h>
#include <Common/SymbolIndex.h>
#include <Common/scope_guard_safe.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> could be captured
explicit StackTrace(const ucontext_t & signal_context);
/// Creates empty object for deferred initialization
explicit StackTrace(NoCapture) {}
StackTrace(FramePointers frame_pointers_, size_t size_, size_t offset_ = 0);
constexpr size_t getSize() const { return si... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <string_view>
namespace DB
{
class StaticString
{
std::string_view stored_view;
public:
template <size_t n>
consteval StaticString(const char(&s)[n]) : stored_view(s) {} /// NOLINT(google-explicit-constructor)
explicit consteval StaticString(const char* s) : store... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>h(ErrorCodes::CANNOT_OPEN_FILE, path, "Cannot lock file {}", path);
}
if (0 != ftruncate(fd, 0))
ErrnoException::throwFromPath(ErrorCodes::CANNOT_TRUNCATE_FILE, path, "Cannot ftruncate file {}", path);
if (0 != lseek(fd, 0, SEEK_SET))
ErrnoException::throw... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <functional>
#include <boost/noncopyable.hpp>
namespace DB
{
class WriteBuffer;
/** Provides that no more than one server works with one data directory.
*/
class StatusFile : private boost::noncopyable
{
public:
using FillFunction =<|fim_suffix|>
}
<|f... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> if (state == nullptr)
return;
std::unique_lock lock(state->mutex);
if (state->stopped.load())
{
lock.unlock();
while (!returned.load())
std::this_thread::yield();
}
else
{
state->callbacks.erase(it);
}
}
<|fim_prefix|>#include <Comm... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <memory>
#include <functional>
#include <list>
#include <atomic>
/// Just like std::stop_token, which isn't available yet. A.k.a. folly::CancellationToken.
/// When we switch to C++20, <|fim_suffix|>top_possible() const { return state != nullptr; }
private:
friend class StopSou... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ll return false.
UInt64 nanoseconds(UInt64 prev_time) const { return clock_gettime_ns_adjusted(prev_time, clock_type) & 0x7FFFFFFFFFFFFFFFULL; }
/// Convert seconds to nanoseconds with saturation. Avoids UB when `seconds` is so large
/// that `seconds * 1e9` falls outside the representable ra... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#in<|fim_suffix|>clude <functional>
namespace DB
{
/// See https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0919r3.html
struct StringHashForHeterogeneousLookup
{
using hash_type = std::hash<std::string_view>;
using transparent_key_equal = std::equal_to<>;
using is_tran... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|><|fim_suffix|>
template class StringSearcher<true, true>;
template class StringSearcher<false, true>;
template class StringSearcher<true, false>;
template class StringSearcher<false, false>;
}
<|fim_middle|>#include <Common/StringSearcher.h>
namespace DB::impl
{<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <algorithm>
#include <cctype>
#include <cstdint>
#include <cstring>
#include <base/getPageSize.h>
#include <Common/UTF8Helpers.h>
#include <Poco/Unicode.h>
#ifdef __SSE2__
# include <emmintrin.h>
#endif
#ifdef __SSE4_1__
# include <smmintrin.h>
#en... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> case '%':
case '_':
{
bool is_perfect_prefix = std::all_of(pos, end, [](auto c) { return c == '%'; });
if (requires_perfect_prefix)
{
if (is_perfect_prefix)
return {fixed_prefix, true};
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <algorithm>
#include <string>
#include <cstring>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <base/types.h>
namespace impl
{
bool startsWith(const std::string & s, const char * prefix, size_t prefix_size);
bool endsWith(const std::string & s, con... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#includ<|fim_suffix|>ar_traits<char>, AllocatorWithMemoryTracking<char>>
{
using std::basic_string<char, std::char_traits<char>, AllocatorWithMemoryTracking<char>>::basic_string;
};
<|fim_middle|>e <Common/AllocatorWithMemoryTracking.h>
#include <string>
/// String that can throw MEMOR... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>1.988, 2.371, 2.635, 3.189 },
{ 1.291, 1.663, 1.988, 2.370, 2.634, 3.188 },
{ 1.291, 1.663, 1.988, 2.370, 2.634, 3.187 },
{ 1.291, 1.662, 1.987, 2.369, 2.633, 3.185 },
{ 1.291, 1.662, 1.987, 2.369, 2.632, 3.184 },
{ 1.291, 1.662, 1.987, 2.368, 2.632, 3.183 },
{ 1.291, 1.662, 1.986,... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>xtern const double students_table[101][6];
extern const double confidence_level[6];
}
<|fim_prefix|>#pragma once
namespac<|fim_middle|>e impl
{
e<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>< "% confidence";
return {true, out.str()};
}
<|fim_prefix|>#include <Common/StudentTTest.h>
#include <Common/StudentTTable.h>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
void StudentTTest::clear()
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>confidence that two distributions don't differ.
* Values can be added with t_test.add(0/1, value) and after compared and reported with compareAndReport().
*/
class StudentTTest
{
private:
struct DistributionData
{
size_t size = 0;
double sum = 0;
double squares_sum = 0;
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ut.str()};
}
<|fim_prefix|>#include <Common/StudentTTestOneSample.h>
#include <Common/StudentTTable.h>
#include <cmath>
#include <iomanip>
#include <sstream>
#include <stdexcept>
#include <IO/WriteBufferFromString.h>
#include <IO/Operators.h>
void StudentTTestOneSample::cl<|fim_middle|>ear()
{
dat... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>pleData data;
public:
void clear();
void setPopulationMean(double mean);
void add(double value);
std::pair<bool, std::string> compareAndReport(size_t confidence_level_index = 5) const;
};
<|fim_prefix|>#pragma once
#include <string>
/**
* About:
* This is implementation of One-samp... | fim | ClickHouse/ClickHouse | c |
#include <base/defines.h>
#include <base/MemorySanitizer.h>
#include <base/hex.h>
#include <base/sort.h>
#include <Common/MemoryTrackerUntrackedAllocationsBlockerInThread.h>
#include <Common/SymbolIndex.h>
#include <algorithm>
#include <optional>
#include <filesystem>
#if defined(OS_DARWIN)
#include <Common/MachO.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>oid * offset_end;
const char * name;
};
struct Object
{
/// Here addresses are absolute virtual memory addresses.
const void * address_begin{};
const void * address_end{};
std::string name;
std::shared_ptr<Elf> elf;
#if defined(OS_DARWIN)
... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <mutex>
#include <list>
#include <cstdlib>
#include <Common/AllocationInterceptors.h>
#include <Common/CurrentMemoryTracker.h>
namespace DB
{
/// This is a helper class for SYSTEM ALLOCATE MEMORY / SYSTEM FREE MEMORY commands
class SystemAllocatedMemoryHolder
{
std::mutex mutex;
class ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>lushing system log '{}'. Aborting.",
demangle(typeid(*this).name()));
}
}
template <typename LogElement>
SystemLogQueue<LogElement>::Index SystemLogQueue<LogElement>::getLastLogIndex()
{
std::lock_guard lock(mutex);
return queue_front_index + queue.size();
}
template <typename Lo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>Size() { return 1048576; }
static consteval size_t getDefaultReservedSize() { return 8192; }
static consteval size_t getDefaultFlushIntervalMilliseconds() { return 7500; }
static consteval bool shouldNotifyFlushOnCrash() { return false; }
static consteval bool shouldTurnOffLogger() { retur... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/TCPSocketMemInfo.h>
#if defined(OS_LINUX) && __has_include(<linux/sock_diag.h>)
#include <linux/sock_diag.h>
#include <linux/inet_diag.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <unistd.h>
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#i<|fim_suffix|>NET_DIAG_MEMINFO).
/// Returns a mapping from socket inode to TCPSocketMemInfo.
/// Linux-only. Returns an empty map on other platforms or on error.
std::unordered_map<uint64_t, TCPSocketMemInfo> getTCPSocketMemInfoByInode();
}
<|fim_middle|>nclude <cstdint>
#include <unorde... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Common/TLDListsHolder.h>
#include <Common/StringUtils.h>
#include <Common/logger_useful.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/ReadHelpers.h>
#include <string_view>
#include <unordered_set>
namespace DB
{
namespace ErrorCodes
{
extern const int TLD_LIST_NOT_FOUND;
extern co... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ze of the list.
size_t parseAndAddTldList(const std::string & name, const std::string & path);
/// Throws TLD_LIST_NOT_FOUND if list does not exist
const TLDList & getTldList(const std::string & name);
protected:
TLDListsHolder();
std::mutex tld_lists_map_mutex;
Map tld_lists_map... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Ptr &)> predicate) override
{
const size_t old_size_in_bytes = size_in_bytes;
const size_t old_size = cache.size();
for (auto it = cache.begin(); it != cache.end();)
{
if (predicate(it->first, it->second))
{
size_t sz = weight_fu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(TargetArch::x86_64_v4)) == static_cast<UInt32>(TargetArch::x86_64_v4)
&& CPU::CPUFlagsCache::have_AVX512VBMI
&& CPU::CPUFlagsCache::have_AVX512VBMI2
&& CPU::CPUFlagsCache::have_AVX512IFMA
&& CPU::CPUFlagsCache::have_AVX512VNNI
&& CPU::CPUFlagsCache::have_AVX512VPOP... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wunused-macros"
#endif
#include <base/defines.h>
#include <base/types.h>
/* This file contains macros and helpers for writing platform-dependent code.
*
* Macros DECLARE_<Arch>_SPECIFIC_CODE w... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <cstdlib>
#include <string_view>
#include <unistd.h>
#include <sys/ioctl.h>
#if defined(OS_SUNOS)
# include <sys/termios.h>
#endif
#include <Common/Exception.h>
#include <Common/ErrnoException.h>
#include <Common/TerminalSize.h>
#include <boost/program_options.hpp>
namespace DB::ErrorCodes
{
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <string>
#include <unistd.h>
#include <boost/program_options.hpp>
namespace po = boost::program_options;
std::pair<uint16_t, uint16_t> getTerminalSize(int in_fd = STDIN_FILENO, int err_fd = STDERR_FILENO);
uint16_t getTerminalWidth(int in_fd = STDIN_FILENO, int err_fd = <|fim_su... | fim | ClickHouse/ClickHouse | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.