**Use case**
Very rare deadlock is possible.

**Describe the solution you'd like**
If MemoryTracker is called from operator new, don't:
- log anything (1);
- throw (2).

(1) is strictly necessarily to avoid deadlock;
(2) is almost necessarily to avoid tons of peculiarities in destructors.
{
    if (size < 0)
        throw DB::Exception(DB::ErrorCodes::LOGICAL_ERROR, "Negative size ({}) is passed to MemoryTracker. It is a bug.", size);
    if (BlockerInThread::isBlocked(level))
    {
        
        if (auto * loaded_next = parent.load(std::memory_order_relaxed))
            loaded_next->alloc(size);
        return;
    }
    /** Using memory_order_relaxed means that if allocations are done simultaneously,
      *  we allow exception about memory limit exceeded to be thrown only on next allocation.
      * So, we allow over-allocations.
      */
    Int64 will_be = size + amount.fetch_add(size, std::memory_order_relaxed);
    auto metric_loaded = metric.load(std::memory_order_relaxed);
    if (metric_loaded != CurrentMetrics::end())
        CurrentMetrics::add(metric_loaded, size);
    Int64 current_hard_limit = hard_limit.load(std::memory_order_relaxed);
    Int64 current_profiler_limit = profiler_limit.load(std::memory_order_relaxed);
    
    
    
    
    
    
    if (unlikely(current_hard_limit
        && will_be > current_hard_limit