issue-1146: load NodeRefs upon tablet load (#2241)

* issue-1146: load NodeRefs upon tablet load

cloud/filestore/config/storage.proto

@@ -365,6 +365,8 @@ message TStorageConfig
     reserved 375; // InMemoryIndexCacheNodeAttrsVerCapacity
     optional uint64 InMemoryIndexCacheNodeRefsCapacity = 376;
     reserved 377; // InMemoryIndexCacheNodeRefsVerCapacity
+    optional bool InMemoryIndexCacheLoadOnTabletStart = 398;
+    optional uint64 InMemoryIndexCacheLoadOnTabletStartRowsPerTx = 399;
 
     // Used to send non-network metrics as network ones to HIVE,
     // while we use them for load balancing

cloud/filestore/libs/storage/core/config.cpp

@@ -199,6 +199,9 @@ using TAliases = NProto::TStorageConfig::TFilestoreAliases;
     xxx(InMemoryIndexCacheNodesCapacity,                ui64,       0         )\
     xxx(InMemoryIndexCacheNodeAttrsCapacity,            ui64,       0         )\
     xxx(InMemoryIndexCacheNodeRefsCapacity,             ui64,       0         )\
+    xxx(InMemoryIndexCacheLoadOnTabletStart,            bool,       false     )\
+    xxx(InMemoryIndexCacheLoadOnTabletStartRowsPerTx,   ui64,       1000000   )\
+                                                                               \
     xxx(NonNetworkMetricsBalancingFactor,               ui32,      1_KB       )\
                                                                                \
     xxx(AsyncDestroyHandleEnabled,     bool,       false                      )\

cloud/filestore/libs/storage/core/config.h

@@ -233,6 +233,8 @@ class TStorageConfig
     ui64 GetInMemoryIndexCacheNodesCapacity() const;
     ui64 GetInMemoryIndexCacheNodeAttrsCapacity() const;
     ui64 GetInMemoryIndexCacheNodeRefsCapacity() const;
+    bool GetInMemoryIndexCacheLoadOnTabletStart() const;
+    ui64 GetInMemoryIndexCacheLoadOnTabletStartRowsPerTx() const;
 
     bool GetAsyncDestroyHandleEnabled() const;
     TDuration GetAsyncHandleOperationPeriod() const;

cloud/filestore/libs/storage/service/service_ut.cpp

@@ -5820,11 +5820,11 @@ Y_UNIT_TEST_SUITE(TStorageServiceTest)
                         break;
                     }
                     case TEvIndexTabletPrivate::
-                        EvLoadCompactionMapChunkCompleted: {
+                        EvLoadCompactionMapChunkResponse: {
                         lastCompactionMapRangeId = Max(
                             event
                                 ->Get<TEvIndexTabletPrivate::
-                                        TEvLoadCompactionMapChunkCompleted>()
+                                          TEvLoadCompactionMapChunkResponse>()
                                 ->LastRangeId,
                             lastCompactionMapRangeId);
                         break;

cloud/filestore/libs/storage/tablet/tablet_actor.cpp

@@ -875,6 +875,9 @@ STFUNC(TIndexTabletActor::StateWork)
         HFunc(TEvIndexTabletPrivate::TEvReadDataCompleted, HandleReadDataCompleted);
         HFunc(TEvIndexTabletPrivate::TEvWriteDataCompleted, HandleWriteDataCompleted);
         HFunc(TEvIndexTabletPrivate::TEvAddDataCompleted, HandleAddDataCompleted);
+        HFunc(
+            TEvIndexTabletPrivate::TEvLoadCompactionMapChunkResponse,
+            HandleLoadCompactionMapChunkResponse);
 
         HFunc(TEvIndexTabletPrivate::TEvUpdateCounters, HandleUpdateCounters);
         HFunc(TEvIndexTabletPrivate::TEvUpdateLeakyBucketCounters, HandleUpdateLeakyBucketCounters);

cloud/filestore/libs/storage/tablet/tablet_actor.h

@@ -362,6 +362,17 @@ class TIndexTabletActor final
 
     TVector<ui32> GenerateForceDeleteZeroCompactionRanges() const;
 
+    /**
+     * @brief If necessary, code can iteratively call ReadNodeRefs for all
+     * nodes. This will populate cache with node refs and allow us to perform
+     * ListNodes using in-memory index state by knowing that the nodeRefs cache
+     * is exhaustive.
+     */
+    void LoadNodeRefs(
+        const NActors::TActorContext& ctx,
+        ui64 nodeId,
+        const TString& name);
+
     void AddTransaction(
         TRequestInfo& transaction,
         TRequestInfo::TCancelRoutine cancelRoutine);
@@ -602,6 +613,10 @@ class TIndexTabletActor final
         const TEvIndexTabletPrivate::TEvNodeUnlinkedInShard::TPtr& ev,
         const NActors::TActorContext& ctx);
 
+    void HandleLoadCompactionMapChunkResponse(
+        const TEvIndexTabletPrivate::TEvLoadCompactionMapChunkResponse::TPtr& ev,
+        const NActors::TActorContext& ctx);
+
     void SendMetricsToExecutor(const NActors::TActorContext& ctx);
 
     bool HandleRequests(STFUNC_SIG);

cloud/filestore/libs/storage/tablet/tablet_actor_loadstate.cpp

@@ -307,6 +307,13 @@ void TIndexTabletActor::CompleteTx_LoadState(
 
     LOG_INFO_S(ctx, TFileStoreComponents::TABLET,
         LogTag << " Scheduling startup events");
+
+    if (Config->GetInMemoryIndexCacheEnabled() &&
+        Config->GetInMemoryIndexCacheLoadOnTabletStart())
+    {
+        LoadNodeRefs(ctx, 0, "");
+    }
+
     ScheduleSyncSessions(ctx);
     ScheduleCleanupSessions(ctx);
     RestartCheckpointDestruction(ctx);
@@ -373,8 +380,8 @@ void TIndexTabletActor::LoadNextCompactionMapChunkIfNeeded(
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void TIndexTabletActor::HandleLoadCompactionMapChunkCompleted(
-    const TEvIndexTabletPrivate::TEvLoadCompactionMapChunkCompleted::TPtr& ev,
+void TIndexTabletActor::HandleLoadCompactionMapChunkResponse(
+    const TEvIndexTabletPrivate::TEvLoadCompactionMapChunkResponse::TPtr& ev,
     const TActorContext& ctx)
 {
     const auto* msg = ev->Get();
@@ -488,18 +495,11 @@ void TIndexTabletActor::CompleteTx_LoadCompactionMapChunk(
     }
 
     using TNotification =
-        TEvIndexTabletPrivate::TEvLoadCompactionMapChunkCompleted;
+        TEvIndexTabletPrivate::TEvLoadCompactionMapChunkResponse;
     auto notification = std::make_unique<TNotification>(
         args.FirstRangeId,
         args.LastRangeId);
     NCloud::Send(ctx, SelfId(), std::move(notification));
-
-    if (args.RequestInfo->Sender != ctx.SelfID) {
-        using TResponse =
-            TEvIndexTabletPrivate::TEvLoadCompactionMapChunkResponse;
-        auto response = std::make_unique<TResponse>();
-        NCloud::Reply(ctx, *args.RequestInfo, std::move(response));
-    }
 }
 
 }   // namespace NCloud::NFileStore::NStorage

cloud/filestore/libs/storage/tablet/tablet_actor_loadstate_noderefs.cpp

@@ -0,0 +1,106 @@
+#include "tablet_actor.h"
+
+namespace NCloud::NFileStore::NStorage {
+
+using namespace NActors;
+
+////////////////////////////////////////////////////////////////////////////////
+
+void TIndexTabletActor::LoadNodeRefs(
+    const NActors::TActorContext& ctx,
+    ui64 nodeId,
+    const TString& name)
+{
+    const ui64 maxNodeRefs = Config->GetInMemoryIndexCacheLoadOnTabletStartRowsPerTx();
+
+    LOG_INFO(
+        ctx,
+        TFileStoreComponents::TABLET,
+        "%s LoadNodeRefs iteration started (nodeId: %lu, name: %s, "
+        "maxNodeRefs: %lu)",
+        LogTag.c_str(),
+        nodeId,
+        name.c_str(),
+        maxNodeRefs);
+
+    ExecuteTx<TLoadNodeRefs>(
+        ctx,
+        nodeId,
+        name,
+        maxNodeRefs);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+bool TIndexTabletActor::ValidateTx_LoadNodeRefs(
+    const TActorContext& ctx,
+    TTxIndexTablet::TLoadNodeRefs& args)
+{
+    LOG_INFO(
+        ctx,
+        TFileStoreComponents::TABLET,
+        "%s LoadingNodeRefs (nodeId: %lu, name: %s, maxNodeRefs: %lu)",
+        LogTag.c_str(),
+        args.NodeId,
+        args.Cookie.c_str(),
+        args.MaxNodeRefs);
+    return true;
+}
+
+bool TIndexTabletActor::PrepareTx_LoadNodeRefs(
+    const TActorContext& ctx,
+    IIndexTabletDatabase& db,
+    TTxIndexTablet::TLoadNodeRefs& args)
+{
+    TVector<TIndexTabletDatabase::TNodeRef> nodeRefs;
+
+    bool ready = db.ReadNodeRefs(
+        args.NodeId,
+        args.Cookie,
+        args.MaxNodeRefs,
+        nodeRefs,
+        args.NextNodeId,
+        args.NextCookie);
+
+    LOG_INFO(
+        ctx,
+        TFileStoreComponents::TABLET,
+        "%s LoadingNodeRefs (nodeId: %lu, name: %s, maxNodeRefs: %lu), read "
+        "%lu nodeRefs: %s",
+        LogTag.c_str(),
+        args.NodeId,
+        args.Cookie.c_str(),
+        args.MaxNodeRefs,
+        nodeRefs.size(),
+        ready ? "finished" : "restarted");
+
+    return ready;
+}
+
+void TIndexTabletActor::CompleteTx_LoadNodeRefs(
+    const TActorContext& ctx,
+    TTxIndexTablet::TLoadNodeRefs& args)
+{
+    LOG_INFO(
+        ctx,
+        TFileStoreComponents::TABLET,
+        "%s LoadNodeRefs iteration completed, next nodeId: %lu, next cookie: "
+        "%s",
+        LogTag.c_str(),
+        args.NextNodeId,
+        args.NextCookie.c_str());
+
+    if (args.NextCookie || args.NextNodeId) {
+        LoadNodeRefs(ctx, args.NextNodeId, args.NextCookie);
+    } else {
+        LOG_INFO(
+            ctx,
+            TFileStoreComponents::TABLET,
+            "%s LoadNodeRefs completed",
+            LogTag.c_str());
+
+        MarkNodeRefsLoadComplete();
+    }
+}
+
+}   // namespace NCloud::NFileStore::NStorage

cloud/filestore/libs/storage/tablet/tablet_database.cpp

@@ -598,6 +598,50 @@ bool TIndexTabletDatabase::ReadNodeRefs(
     return true;
 }
 
+bool TIndexTabletDatabase::ReadNodeRefs(
+    ui64 startNodeId,
+    const TString& startCookie,
+    ui64 maxCount,
+    TVector<IIndexTabletDatabase::TNodeRef>& refs,
+    ui64& nextNodeId,
+    TString& nextCookie)
+{
+    using TTable = TIndexTabletSchema::NodeRefs;
+
+    if (!startNodeId && startCookie.empty()) {
+        Table<TTable>().Precharge();
+    }
+
+    auto it = Table<TTable>().GreaterOrEqual(startNodeId, startCookie).Select();
+
+    if (!it.IsReady()) {
+        return false;   // not ready
+    }
+
+    while (it.IsValid() && maxCount > 0) {
+        refs.emplace_back(TNodeRef{
+            it.GetValue<TTable::NodeId>(),
+            it.GetValue<TTable::Name>(),
+            it.GetValue<TTable::ChildId>(),
+            it.GetValue<TTable::ShardId>(),
+            it.GetValue<TTable::ShardName>(),
+            it.GetValue<TTable::CommitId>(),
+            InvalidCommitId});
+        --maxCount;
+
+        if (!it.Next()) {
+            return false;   // not ready
+        }
+    }
+
+    if (it.IsValid()) {
+        nextNodeId = it.GetValue<TTable::NodeId>();
+        nextCookie = it.GetValue<TTable::Name>();
+    }
+
+    return true;
+}
+
 bool TIndexTabletDatabase::PrechargeNodeRefs(
     ui64 nodeId,
     const TString& cookie,
@@ -2030,13 +2074,7 @@ bool TIndexTabletDatabaseProxy::ReadNodeRef(
     if (result && ref) {
         // If ReadNodeRef was successful, it is reasonable to update the cache
         // with the value that has just been read.
-        NodeUpdates.emplace_back(TInMemoryIndexState::TWriteNodeRefsRequest{
-            .NodeRefsKey = {nodeId, name},
-            .NodeRefsRow = {
-                .CommitId = ref->MinCommitId,
-                .ChildId = ref->ChildNodeId,
-                .ShardId = ref->ShardId,
-                .ShardName = ref->ShardName}});
+        NodeUpdates.emplace_back(ExtractWriteNodeRefsFromNodeRef(*ref));
     }
     return result;
 }
@@ -2055,13 +2093,32 @@ bool TIndexTabletDatabaseProxy::ReadNodeRefs(
         // If ReadNodeRefs was successful, it is reasonable to update the cache
         // with the values that have just been read.
         for (const auto& ref: refs) {
-            NodeUpdates.emplace_back(TInMemoryIndexState::TWriteNodeRefsRequest{
-                .NodeRefsKey = {nodeId, ref.Name},
-                .NodeRefsRow = {
-                    .CommitId = ref.MinCommitId,
-                    .ChildId = ref.ChildNodeId,
-                    .ShardId = ref.ShardId,
-                    .ShardName = ref.ShardName}});
+            NodeUpdates.emplace_back(ExtractWriteNodeRefsFromNodeRef(ref));
+        }
+    }
+    return result;
+}
+
+bool TIndexTabletDatabaseProxy::ReadNodeRefs(
+    ui64 startNodeId,
+    const TString& startCookie,
+    ui64 maxCount,
+    TVector<IIndexTabletDatabase::TNodeRef>& refs,
+    ui64& nextNodeId,
+    TString& nextCookie)
+{
+    auto result = TIndexTabletDatabase::ReadNodeRefs(
+        startNodeId,
+        startCookie,
+        maxCount,
+        refs,
+        nextNodeId,
+        nextCookie);
+    if (result) {
+        // If ReadNodeRefs was successful, it is reasonable to update the cache
+        // with the values that have just been read.
+        for (const auto& ref: refs) {
+            NodeUpdates.emplace_back(ExtractWriteNodeRefsFromNodeRef(ref));
         }
     }
     return result;
@@ -2127,4 +2184,16 @@ void TIndexTabletDatabaseProxy::DeleteNodeRefVer(
     // TODO(#1146): _Ver tables not yet supported
 }
 
+TInMemoryIndexState::TWriteNodeRefsRequest
+TIndexTabletDatabaseProxy::ExtractWriteNodeRefsFromNodeRef(const TNodeRef& ref)
+{
+    return TInMemoryIndexState::TWriteNodeRefsRequest{
+        .NodeRefsKey = {ref.NodeId, ref.Name},
+        .NodeRefsRow = {
+            .CommitId = ref.MinCommitId,
+            .ChildId = ref.ChildNodeId,
+            .ShardId = ref.ShardId,
+            .ShardName = ref.ShardName}};
+}
+
 }   // namespace NCloud::NFileStore::NStorage

cloud/filestore/libs/storage/tablet/tablet_database.h

@@ -207,6 +207,14 @@ FILESTORE_FILESYSTEM_STATS(FILESTORE_DECLARE_STATS)
         ui32 maxBytes,
         TString* next = nullptr) override;
 
+    virtual bool ReadNodeRefs(
+        ui64 startNodeId,
+        const TString& startCookie,
+        ui64 maxCount,
+        TVector<IIndexTabletDatabase::TNodeRef>& refs,
+        ui64& nextNodeId,
+        TString& nextCookie) override;
+
     virtual bool PrechargeNodeRefs(
         ui64 nodeId,
         const TString& cookie,
@@ -611,6 +619,14 @@ class TIndexTabletDatabaseProxy: public TIndexTabletDatabase
         ui32 maxBytes,
         TString* next = nullptr) override;
 
+    bool ReadNodeRefs(
+        ui64 startNodeId,
+        const TString& startCookie,
+        ui64 maxCount,
+        TVector<IIndexTabletDatabase::TNodeRef>& refs,
+        ui64& nextNodeId,
+        TString& nextCookie) override;
+
     void WriteNodeRef(
         ui64 nodeId,
         ui64 commitId,
@@ -641,6 +657,9 @@ class TIndexTabletDatabaseProxy: public TIndexTabletDatabase
 
 private:
     TVector<TInMemoryIndexState::TIndexStateRequest>& NodeUpdates;
+
+    static TInMemoryIndexState::TWriteNodeRefsRequest
+    ExtractWriteNodeRefsFromNodeRef(const TNodeRef& ref);
 };
 
 }   // namespace NCloud::NFileStore::NStorage