**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.
{
private:
    std::atomic<Int64> amount {0};
    std::atomic<Int64> peak {0};
    std::atomic<Int64> hard_limit {0};
    std::atomic<Int64> profiler_limit {0};
    Int64 profiler_step = 0;
    
    double fault_probability = 0;
    
    double sample_probability = 0;
    
    
    std::atomic<MemoryTracker *> parent {};
    
    std::atomic<CurrentMetrics::Metric> metric = CurrentMetrics::end();
    
    std::atomic<const char *> description_ptr = nullptr;
    void updatePeak(Int64 will_be);
    void logMemoryUsage(Int64 current) const;
public:
    MemoryTracker(VariableContext level_ = VariableContext::Thread);
    MemoryTracker(MemoryTracker * parent_, VariableContext level_ = VariableContext::Thread);
    ~MemoryTracker();
    VariableContext level;
    /** Call the following functions before calling of corresponding operations with memory allocators.
      */
    void alloc(Int64 size);
    void realloc(Int64 old_size, Int64 new_size)