Use TContiguousData rooms interface in vdisk/pdisk

separate concerns

add tracing

add tracing calls

3 files changed, 121 insertions, 5 deletions

diff --git a/library/cpp/actors/util/contiguous_data.h b/library/cpp/actors/util/contiguous_data.h
index 7510cc979fd..8eda607711f 100644
--- a/library/cpp/actors/util/contiguous_data.h
+++ b/library/cpp/actors/util/contiguous_data.h
@@ -11,6 +11,10 @@
 
 #include "shared_data.h"
 
+#ifdef KIKIMR_TRACE_CONTIGUOUS_DATA_GROW
+#include "shared_data_backtracing_owner.h"
+#endif
+
 namespace NContiguousDataDetails {
     template<typename TContainer>
     struct TContainerTraits {
@@ -701,8 +705,14 @@ public:
     }
 
     explicit TContiguousData(NActors::TSharedData s)
+#ifndef KIKIMR_TRACE_CONTIGUOUS_DATA_GROW
         : Backend(std::move(s))
+#endif
     {
+#ifdef KIKIMR_TRACE_CONTIGUOUS_DATA_GROW
+        TBackTracingOwner::FakeOwner(s, TBackTracingOwner::INFO_FROM_SHARED_DATA);
+        Backend = TBackend(std::move(s));
+#endif
         auto span = Backend.GetData();
         Begin = span.data();
         End = Begin + span.size();
@@ -746,14 +756,22 @@ public:
             return TContiguousData();
         }
         if (headroom == 0 && tailroom == 0) {
-            NActors::TSharedData res = NActors::TSharedData::Uninitialized(size + headroom + tailroom);
+#ifdef KIKIMR_TRACE_CONTIGUOUS_DATA_GROW
+            NActors::TSharedData res = TBackTracingOwner::Allocate(size, TBackTracingOwner::INFO_ALLOC_UNINITIALIZED);
+#else
+            NActors::TSharedData res = NActors::TSharedData::Uninitialized(size);
+#endif
             return TContiguousData(
                 OwnedSlice,
-                res.data() + headroom,
-                res.data() + res.size() - tailroom,
+                res.data(),
+                res.data() + res.size(),
                 TContiguousData(res));
         } else {
+#ifdef KIKIMR_TRACE_CONTIGUOUS_DATA_GROW
+            NActors::TSharedData res = TBackTracingOwner::Allocate(size + headroom + tailroom + TBackend::CookiesSize, TBackTracingOwner::INFO_ALLOC_UNINIT_ROOMS);
+#else
             NActors::TSharedData res = NActors::TSharedData::Uninitialized(size + headroom + tailroom + TBackend::CookiesSize);
+#endif
             return TContiguousData(
                 OwnedSlice,
                 res.data() + headroom,
@@ -874,6 +892,13 @@ public:
             Begin -= size;
             Backend.UpdateCookies(Begin, End);
         } else {
+#ifdef KIKIMR_TRACE_CONTIGUOUS_DATA_GROW
+            if (Backend.ContainsNativeType<NActors::TSharedData>()) {
+                Cerr << "GrowFront# " << size;
+                NActors::TSharedData data = GetRaw<NActors::TSharedData>();
+                TBackTracingOwner::UnsafePrintBackTrace(data);
+            }
+#endif
             if (strategy == EResizeStrategy::FailOnCopy && static_cast<bool>(Backend)) {
                 Y_FAIL("Fail on grow");
             }
@@ -891,6 +916,13 @@ public:
             End += size;
             Backend.UpdateCookies(Begin, End);
         } else {
+#ifdef KIKIMR_TRACE_CONTIGUOUS_DATA_GROW
+            if (Backend.ContainsNativeType<NActors::TSharedData>()) {
+                Cerr << "GrowBack# " << size;
+                NActors::TSharedData data = GetRaw<NActors::TSharedData>();
+                TBackTracingOwner::UnsafePrintBackTrace(data);
+            }
+#endif
             if (strategy == EResizeStrategy::FailOnCopy && static_cast<bool>(Backend)) {
                 Y_FAIL("Fail on grow");
             }
diff --git a/library/cpp/actors/util/rope.h b/library/cpp/actors/util/rope.h
index e713cd241a2..6ac4aa13b37 100644
--- a/library/cpp/actors/util/rope.h
+++ b/library/cpp/actors/util/rope.h
@@ -736,10 +736,10 @@ public:
         return false;
     }
 
-    void Compact() {
+    void Compact(size_t headroom = 0, size_t tailroom = 0) {
         if(!IsContiguous()) {
             // TODO(innokentii): use better container, when most outer users stop use TString
-            TContiguousData res = TContiguousData::Uninitialized(GetSize());
+            TContiguousData res = TContiguousData::Uninitialized(GetSize(), headroom, tailroom);
             Begin().ExtractPlainDataAndAdvance(res.UnsafeGetDataMut(), res.size());
             Erase(Begin(), End());
             Insert(End(), TRope(res));
diff --git a/library/cpp/actors/util/shared_data_backtracing_owner.h b/library/cpp/actors/util/shared_data_backtracing_owner.h
new file mode 100644
index 00000000000..9e93e327c34
--- /dev/null
+++ b/library/cpp/actors/util/shared_data_backtracing_owner.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <util/system/sys_alloc.h>
+#include <util/system/backtrace.h>
+
+#include "shared_data.h"
+
+class TBackTracingOwner : public NActors::TSharedData::IOwner {
+    using THeader = NActors::TSharedData::THeader;
+    using TSelf = TBackTracingOwner;
+    using IOwner = NActors::TSharedData::IOwner;
+
+    static constexpr size_t PrivateHeaderSize = NActors::TSharedData::PrivateHeaderSize;
+    static constexpr size_t HeaderSize = NActors::TSharedData::HeaderSize;
+    static constexpr size_t OverheadSize = NActors::TSharedData::OverheadSize;
+
+    IOwner* RealOwner = nullptr;
+    TBackTrace BackTrace;
+    const char* Info;
+public:
+
+    static constexpr const char* INFO_FROM_SHARED_DATA = "FROM_SHARED_DATA";
+    static constexpr const char* INFO_COPIED_STRING = "COPIED_STRING";
+    static constexpr const char* INFO_ALLOC_UNINITIALIZED = "ALLOC_UNINITIALIZED";
+    static constexpr const char* INFO_ALLOC_UNINIT_ROOMS = "ALLOC_UNINIT_ROOMS";
+
+    static NActors::TSharedData Allocate(size_t size, const char* info = nullptr) {
+        char* raw = reinterpret_cast<char*>(y_allocate(OverheadSize + size));
+        THeader* header = reinterpret_cast<THeader*>(raw + PrivateHeaderSize);
+        TSelf* btOwner = new TSelf;
+        btOwner->BackTrace.Capture();
+        btOwner->Info = info;
+        header->RefCount = 1;
+        header->Owner = btOwner;
+        char* data = raw + OverheadSize;
+        return NActors::TSharedData::AttachUnsafe(data, size);
+    }
+
+    static void FakeOwner(const NActors::TSharedData& data, const char* info = nullptr) {
+        THeader* header = Header(data);
+        if (header) {
+            TSelf* btOwner = new TSelf();
+            btOwner->BackTrace.Capture();
+            btOwner->Info = info;
+            if (header->Owner) {
+                btOwner->RealOwner = header->Owner;
+            }
+            header->Owner = btOwner;
+        }
+    }
+
+    static void UnsafePrintBackTrace(NActors::TSharedData& data) {
+        THeader* header = Header(data);
+        if(header->Owner) {
+            TSelf* owner = static_cast<TSelf*>(header->Owner);
+            owner->PrintBackTrace();
+        }
+    }
+
+    void Deallocate(char* data) noexcept override {
+        if (!RealOwner) {
+            char* raw = data - OverheadSize;
+            y_deallocate(raw);
+        } else {
+            RealOwner->Deallocate(data);
+        }
+
+        delete this;
+    }
+
+    void PrintBackTrace() {
+        Cerr << "Deallocate TSharedData with info# " << Info << Endl;
+        BackTrace.PrintTo(Cerr);
+    }
+private:
+    static Y_FORCE_INLINE THeader* Header(const NActors::TSharedData& d) noexcept {
+        char* data = const_cast<char*>(d.data());
+        if (data) {
+            return reinterpret_cast<THeader*>(data - HeaderSize);
+        } else {
+            return nullptr;
+        }
+    }
+};