Stat about opened files from one/many sessions (#1818)

* Stat about opened files from one/many sessions * Style * style * simpler * Names * Simpler * Simpler * Simpler * clean * fixes * safe * fixes * Some fixes * better * better * better * better * test name * move * clean * Add test
ydb-platform · Aug 31, 2024 · 3af0964 · 3af0964
1 parent 836a516
commit 3af0964
Show file tree

Hide file tree

Showing 11 changed files with 498 additions and 4 deletions.
diff --git a/cloud/filestore/libs/storage/tablet/model/node_session_stat.cpp b/cloud/filestore/libs/storage/tablet/model/node_session_stat.cpp
@@ -0,0 +1,98 @@
+#include "node_session_stat.h"
+
+namespace NCloud::NFileStore::NStorage {
+
+TNodeToSessionStat::EKind TNodeToSessionStat::AddRead(
+    ui64 nodeId,
+    const TString& sessionId)
+{
+    ++Stat[nodeId].ReadSessions[sessionId];
+    return GetKind(nodeId);
+}
+
+TNodeToSessionStat::EKind TNodeToSessionStat::AddWrite(
+    ui64 nodeId,
+    const TString& sessionId)
+{
+    ++Stat[nodeId].WriteSessions[sessionId];
+    return GetKind(nodeId);
+}
+
+void TNodeToSessionStat::Clean(
+    const TStat::iterator& nodeStatIterator,
+    const TString& sessionId)
+{
+    auto& nodeStat = nodeStatIterator->second;
+
+    {
+        const auto it = nodeStat.WriteSessions.find(sessionId);
+        if (it != nodeStat.WriteSessions.end() && it->second <= 0) {
+            nodeStat.WriteSessions.erase(it);
+        }
+    }
+
+    {
+        const auto it = nodeStat.ReadSessions.find(sessionId);
+        if (it != nodeStat.ReadSessions.end() && it->second <= 0) {
+            nodeStat.ReadSessions.erase(it);
+        }
+    }
+
+    if (nodeStat.WriteSessions.empty() && nodeStat.ReadSessions.empty()) {
+        Stat.erase(nodeStatIterator);
+    }
+}
+
+TNodeToSessionStat::EKind TNodeToSessionStat::RemoveRead(
+    ui64 nodeId,
+    const TString& sessionId)
+{
+    const auto& nodeStatIterator = Stat.find(nodeId);
+    if (nodeStatIterator != Stat.end()) {
+        --nodeStatIterator->second.ReadSessions[sessionId];
+        Clean(nodeStatIterator, sessionId);
+    }
+    return GetKind(nodeStatIterator);
+}
+
+TNodeToSessionStat::EKind TNodeToSessionStat::RemoveWrite(
+    ui64 nodeId,
+    const TString& sessionId)
+{
+    const auto& nodeStatIterator = Stat.find(nodeId);
+    if (nodeStatIterator != Stat.end()) {
+        --nodeStatIterator->second.WriteSessions[sessionId];
+        Clean(nodeStatIterator, sessionId);
+    }
+    return GetKind(nodeStatIterator);
+}
+
+TNodeToSessionStat::EKind TNodeToSessionStat::GetKind(ui64 nodeId) const
+{
+    const auto& nodeStatIterator = Stat.find(nodeId);
+    return GetKind(nodeStatIterator);
+}
+
+TNodeToSessionStat::EKind TNodeToSessionStat::GetKind(
+    const TStat::const_iterator& nodeStatIterator) const
+{
+    if (nodeStatIterator == Stat.end()) {
+        return EKind::None;
+    }
+    const auto& nodeStat = nodeStatIterator->second;
+    if (nodeStat.WriteSessions.size() > 1) {
+        return EKind::NodesOpenForWritingByMultipleSessions;
+    }
+    if (nodeStat.WriteSessions.size() == 1) {
+        return EKind::NodesOpenForWritingBySingleSession;
+    }
+    if (nodeStat.ReadSessions.size() > 1) {
+        return EKind::NodesOpenForReadingByMultipleSessions;
+    }
+    if (nodeStat.ReadSessions.size() == 1) {
+        return EKind::NodesOpenForReadingBySingleSession;
+    }
+    return EKind::None;
+}
+
+}   // namespace NCloud::NFileStore::NStorage
diff --git a/cloud/filestore/libs/storage/tablet/model/node_session_stat.h b/cloud/filestore/libs/storage/tablet/model/node_session_stat.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <util/generic/hash.h>
+#include <util/system/types.h>
+
+namespace NCloud::NFileStore::NStorage {
+
+class TNodeToSessionStat
+{
+    struct TSessionStat
+    {
+        THashMap<TString, i32> ReadSessions;
+        THashMap<TString, i32> WriteSessions;
+    };
+    using TStat = THashMap<ui64, TSessionStat>;
+    TStat Stat;
+
+    void Clean(
+        const TStat::iterator& nodeStatIterator,
+        const TString& sessionId);
+
+public:
+    enum class EKind
+    {
+        None,
+        NodesOpenForWritingBySingleSession,
+        NodesOpenForWritingByMultipleSessions,
+        NodesOpenForReadingBySingleSession,
+        NodesOpenForReadingByMultipleSessions,
+    };
+
+    EKind AddRead(ui64 nodeId, const TString& sessionId);
+    EKind AddWrite(ui64 nodeId, const TString& sessionId);
+    EKind RemoveRead(ui64 nodeId, const TString& sessionId);
+    EKind RemoveWrite(ui64 nodeId, const TString& sessionId);
+    [[nodiscard]] EKind GetKind(ui64 nodeId) const;
+
+private:
+    [[nodiscard]] EKind GetKind(
+        const TStat::const_iterator& nodeStatIterator) const;
+};
+
+}   // namespace NCloud::NFileStore::NStorage
diff --git a/cloud/filestore/libs/storage/tablet/model/node_session_stat_ut.cpp b/cloud/filestore/libs/storage/tablet/model/node_session_stat_ut.cpp
@@ -0,0 +1,98 @@
+#include "node_session_stat.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+namespace NCloud::NFileStore::NStorage {
+
+////////////////////////////////////////////////////////////////////////////////
+
+Y_UNIT_TEST_SUITE(TNodeToSessionStat)
+{
+    Y_UNIT_TEST(ShouldStat)
+    {
+        TNodeToSessionStat nodeToSessionStat;
+        const ui64 nodeId1 = 1;
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.GetKind(nodeId1),
+            TNodeToSessionStat::EKind::None);
+
+        TString sessionId1 = "1";
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.AddRead(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::NodesOpenForReadingBySingleSession);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.AddRead(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::NodesOpenForReadingBySingleSession);
+
+        TString sessionId2 = "2";
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.AddRead(nodeId1, sessionId2),
+            TNodeToSessionStat::EKind::NodesOpenForReadingByMultipleSessions);
+
+        TString sessionId3 = "3";
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.AddWrite(nodeId1, sessionId3),
+            TNodeToSessionStat::EKind::NodesOpenForWritingBySingleSession);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.AddWrite(nodeId1, sessionId2),
+            TNodeToSessionStat::EKind::NodesOpenForWritingByMultipleSessions);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveRead(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::NodesOpenForWritingByMultipleSessions);
+
+        const ui64 nodeId2 = 2;
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.AddWrite(nodeId2, sessionId2),
+            TNodeToSessionStat::EKind::NodesOpenForWritingBySingleSession);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.GetKind(nodeId1),
+            TNodeToSessionStat::EKind::NodesOpenForWritingByMultipleSessions);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveWrite(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::NodesOpenForWritingByMultipleSessions);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveWrite(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::NodesOpenForWritingByMultipleSessions);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveWrite(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::NodesOpenForWritingByMultipleSessions);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveWrite(nodeId2, sessionId2),
+            TNodeToSessionStat::EKind::None);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.GetKind(nodeId1),
+            TNodeToSessionStat::EKind::NodesOpenForWritingByMultipleSessions);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveWrite(nodeId1, sessionId2),
+            TNodeToSessionStat::EKind::NodesOpenForWritingBySingleSession);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveWrite(nodeId1, sessionId3),
+            TNodeToSessionStat::EKind::NodesOpenForReadingByMultipleSessions);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveRead(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::NodesOpenForReadingBySingleSession);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveRead(nodeId1, sessionId2),
+            TNodeToSessionStat::EKind::None);
+
+        UNIT_ASSERT_EQUAL(
+            nodeToSessionStat.RemoveRead(nodeId1, sessionId1),
+            TNodeToSessionStat::EKind::None);
+    }
+}
+
+}   // namespace NCloud::NFileStore::NStorage
diff --git a/cloud/filestore/libs/storage/tablet/model/ut/ya.make b/cloud/filestore/libs/storage/tablet/model/ut/ya.make
@@ -12,6 +12,7 @@ SRCS(
     garbage_queue_ut.cpp
     mixed_blocks_ut.cpp
     node_index_cache_ut.cpp
+    node_session_stat_ut.cpp
     operation_ut.cpp
     range_locks_ut.cpp
     read_ahead_ut.cpp

diff --git a/cloud/filestore/libs/storage/tablet/model/ya.make b/cloud/filestore/libs/storage/tablet/model/ya.make
@@ -25,6 +25,7 @@ SRCS(
     group_by.cpp
     mixed_blocks.cpp
     node_index_cache.cpp
+    node_session_stat.cpp
     operation.cpp
     range_locks.cpp
     read_ahead.cpp

diff --git a/cloud/filestore/libs/storage/tablet/tablet_actor.h b/cloud/filestore/libs/storage/tablet/tablet_actor.h
@@ -137,6 +137,11 @@ class TIndexTabletActor final
         std::atomic<i64> UncompressedBytesWritten{0};
         std::atomic<i64> CompressedBytesWritten{0};
 
+        std::atomic<i64> NodesOpenForWritingBySingleSession{0};
+        std::atomic<i64> NodesOpenForWritingByMultipleSessions{0};
+        std::atomic<i64> NodesOpenForReadingBySingleSession{0};
+        std::atomic<i64> NodesOpenForReadingByMultipleSessions{0};
+
         NMetrics::TDefaultWindowCalculator MaxUsedQuota{0};
         using TLatHistogram =
             NMetrics::THistogram<NMetrics::EHistUnit::HU_TIME_MICROSECONDS>;
@@ -201,7 +206,8 @@ class TIndexTabletActor final
             const TSessionsStats& sessionsStats,
             const TChannelsStats& channelsStats,
             const TReadAheadCacheStats& readAheadStats,
-            const TNodeIndexCacheStats& nodeIndexCacheStats);
+            const TNodeIndexCacheStats& nodeIndexCacheStats,
+            const TNodeToSessionCounters& nodeToSessionCounters);
     } Metrics;
 
     const IProfileLogPtr ProfileLog;

diff --git a/cloud/filestore/libs/storage/tablet/tablet_actor_counters.cpp b/cloud/filestore/libs/storage/tablet/tablet_actor_counters.cpp
@@ -297,6 +297,19 @@ void TIndexTabletActor::TMetrics::Register(
     REGISTER_AGGREGATABLE_SUM(AllocatedCompactionRangesCount, EMetricType::MT_ABSOLUTE);
     REGISTER_AGGREGATABLE_SUM(UsedCompactionRangesCount, EMetricType::MT_ABSOLUTE);
 
+    REGISTER_AGGREGATABLE_SUM(
+        NodesOpenForWritingBySingleSession,
+        EMetricType::MT_ABSOLUTE);
+    REGISTER_AGGREGATABLE_SUM(
+        NodesOpenForWritingByMultipleSessions,
+        EMetricType::MT_ABSOLUTE);
+    REGISTER_AGGREGATABLE_SUM(
+        NodesOpenForReadingBySingleSession,
+        EMetricType::MT_ABSOLUTE);
+    REGISTER_AGGREGATABLE_SUM(
+        NodesOpenForReadingByMultipleSessions,
+        EMetricType::MT_ABSOLUTE);
+
     // Throttling
     REGISTER_LOCAL(MaxReadBandwidth, EMetricType::MT_ABSOLUTE);
     REGISTER_LOCAL(MaxWriteBandwidth, EMetricType::MT_ABSOLUTE);
@@ -374,7 +387,8 @@ void TIndexTabletActor::TMetrics::Update(
     const TSessionsStats& sessionsStats,
     const TChannelsStats& channelsStats,
     const TReadAheadCacheStats& readAheadStats,
-    const TNodeIndexCacheStats& nodeIndexCacheStats)
+    const TNodeIndexCacheStats& nodeIndexCacheStats,
+    const TNodeToSessionCounters& nodeToSessionCounters)
 {
     const ui32 blockSize = fileSystem.GetBlockSize();
 
@@ -432,6 +446,19 @@ void TIndexTabletActor::TMetrics::Update(
     Store(ReadAheadCacheNodeCount, readAheadStats.NodeCount);
     Store(NodeIndexCacheNodeCount, nodeIndexCacheStats.NodeCount);
 
+    Store(
+        NodesOpenForWritingBySingleSession,
+        nodeToSessionCounters.NodesOpenForWritingBySingleSession);
+    Store(
+        NodesOpenForWritingByMultipleSessions,
+        nodeToSessionCounters.NodesOpenForWritingByMultipleSessions);
+    Store(
+        NodesOpenForReadingBySingleSession,
+        nodeToSessionCounters.NodesOpenForReadingBySingleSession);
+    Store(
+        NodesOpenForReadingByMultipleSessions,
+        nodeToSessionCounters.NodesOpenForReadingByMultipleSessions);
+
     BusyIdleCalc.OnUpdateStats();
 }
 
@@ -479,7 +506,8 @@ void TIndexTabletActor::RegisterStatCounters()
         CalculateSessionsStats(),
         CalculateChannelsStats(),
         CalculateReadAheadCacheStats(),
-        CalculateNodeIndexCacheStats());
+        CalculateNodeIndexCacheStats(),
+        GetNodeToSessionCounters());
 
     Metrics.Register(fsId, storageMediaKind);
 }
@@ -524,7 +552,8 @@ void TIndexTabletActor::HandleUpdateCounters(
         CalculateSessionsStats(),
         CalculateChannelsStats(),
         CalculateReadAheadCacheStats(),
-        CalculateNodeIndexCacheStats());
+        CalculateNodeIndexCacheStats(),
+        GetNodeToSessionCounters());
     SendMetricsToExecutor(ctx);
 
     UpdateCountersScheduled = false;