2015-09-29 19:19:54 +00:00
|
|
|
#include <common/likely.h>
|
|
|
|
#include <common/logger_useful.h>
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Common/Exception.h>
|
|
|
|
#include <Common/formatReadable.h>
|
|
|
|
#include <IO/WriteHelpers.h>
|
2014-05-08 12:00:47 +00:00
|
|
|
#include <iomanip>
|
2014-05-03 22:57:43 +00:00
|
|
|
|
2017-04-01 09:19:00 +00:00
|
|
|
#include <Common/MemoryTracker.h>
|
2014-05-03 22:57:43 +00:00
|
|
|
|
|
|
|
|
2016-10-24 04:06:27 +00:00
|
|
|
namespace DB
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
namespace ErrorCodes
|
|
|
|
{
|
|
|
|
extern const int MEMORY_LIMIT_EXCEEDED;
|
|
|
|
}
|
2016-01-11 21:46:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-05-03 22:57:43 +00:00
|
|
|
MemoryTracker::~MemoryTracker()
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
if (peak)
|
|
|
|
logPeakMemoryUsage();
|
2016-01-21 01:47:28 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (amount && !next)
|
|
|
|
CurrentMetrics::sub(metric, amount);
|
2014-05-03 22:57:43 +00:00
|
|
|
}
|
|
|
|
|
2015-12-30 15:39:11 +00:00
|
|
|
|
|
|
|
void MemoryTracker::logPeakMemoryUsage() const
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
LOG_DEBUG(&Logger::get("MemoryTracker"),
|
|
|
|
"Peak memory usage" << (description ? " " + std::string(description) : "")
|
|
|
|
<< ": " << formatReadableSizeWithBinarySuffix(peak) << ".");
|
2015-12-30 15:39:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-05-08 15:54:51 +00:00
|
|
|
void MemoryTracker::alloc(Int64 size)
|
2014-05-03 22:57:43 +00:00
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
Int64 will_be = amount += size;
|
|
|
|
|
|
|
|
if (!next)
|
|
|
|
CurrentMetrics::add(metric, size);
|
|
|
|
|
|
|
|
Int64 current_limit = limit.load(std::memory_order_relaxed);
|
|
|
|
|
|
|
|
/// Using non-thread-safe random number generator. Joint distribution in different threads would not be uniform.
|
|
|
|
/// In this case, it doesn't matter.
|
|
|
|
if (unlikely(fault_probability && drand48() < fault_probability))
|
|
|
|
{
|
|
|
|
free(size);
|
|
|
|
|
|
|
|
std::stringstream message;
|
|
|
|
message << "Memory tracker";
|
|
|
|
if (description)
|
|
|
|
message << " " << description;
|
|
|
|
message << ": fault injected. Would use " << formatReadableSizeWithBinarySuffix(will_be)
|
|
|
|
<< " (attempt to allocate chunk of " << size << " bytes)"
|
|
|
|
<< ", maximum: " << formatReadableSizeWithBinarySuffix(current_limit);
|
|
|
|
|
|
|
|
throw DB::Exception(message.str(), DB::ErrorCodes::MEMORY_LIMIT_EXCEEDED);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(current_limit && will_be > current_limit))
|
|
|
|
{
|
|
|
|
free(size);
|
|
|
|
|
|
|
|
std::stringstream message;
|
|
|
|
message << "Memory limit";
|
|
|
|
if (description)
|
|
|
|
message << " " << description;
|
|
|
|
message << " exceeded: would use " << formatReadableSizeWithBinarySuffix(will_be)
|
|
|
|
<< " (attempt to allocate chunk of " << size << " bytes)"
|
|
|
|
<< ", maximum: " << formatReadableSizeWithBinarySuffix(current_limit);
|
|
|
|
|
|
|
|
throw DB::Exception(message.str(), DB::ErrorCodes::MEMORY_LIMIT_EXCEEDED);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (will_be > peak.load(std::memory_order_relaxed)) /// Races doesn't matter. Could rewrite with CAS, but not worth.
|
|
|
|
peak.store(will_be, std::memory_order_relaxed);
|
|
|
|
|
|
|
|
if (next)
|
|
|
|
next->alloc(size);
|
2015-12-30 15:39:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void MemoryTracker::free(Int64 size)
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
amount -= size;
|
2015-12-30 15:39:11 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
if (next)
|
|
|
|
next->free(size);
|
|
|
|
else
|
|
|
|
CurrentMetrics::sub(metric, size);
|
2015-12-30 15:39:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void MemoryTracker::reset()
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
if (!next)
|
|
|
|
CurrentMetrics::sub(metric, amount);
|
2016-01-21 01:47:28 +00:00
|
|
|
|
2017-04-01 07:20:54 +00:00
|
|
|
amount.store(0, std::memory_order_relaxed);
|
|
|
|
peak.store(0, std::memory_order_relaxed);
|
|
|
|
limit.store(0, std::memory_order_relaxed);
|
2017-02-01 03:53:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void MemoryTracker::setOrRaiseLimit(Int64 value)
|
|
|
|
{
|
2017-04-01 07:20:54 +00:00
|
|
|
/// This is just atomic set to maximum.
|
|
|
|
Int64 old_value = limit.load(std::memory_order_relaxed);
|
|
|
|
while (old_value < value && !limit.compare_exchange_weak(old_value, value))
|
|
|
|
;
|
2014-05-03 22:57:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
__thread MemoryTracker * current_memory_tracker = nullptr;
|
2017-04-10 21:40:38 +00:00
|
|
|
|
|
|
|
namespace CurrentMemoryTracker
|
|
|
|
{
|
|
|
|
void alloc(Int64 size)
|
|
|
|
{
|
|
|
|
if (current_memory_tracker)
|
|
|
|
current_memory_tracker->alloc(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void realloc(Int64 old_size, Int64 new_size)
|
|
|
|
{
|
|
|
|
if (current_memory_tracker)
|
|
|
|
current_memory_tracker->alloc(new_size - old_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
void free(Int64 size)
|
|
|
|
{
|
|
|
|
if (current_memory_tracker)
|
|
|
|
current_memory_tracker->free(size);
|
|
|
|
}
|
|
|
|
}
|