Fine-grained fitter invocation for better performance

13 files changed, 164 insertions, 81 deletions

diff --git a/ydb/core/mind/bscontroller/cmds_box.cpp b/ydb/core/mind/bscontroller/cmds_box.cpp
index 2b38f3cfb96..17bfc9a2d67 100644
--- a/ydb/core/mind/bscontroller/cmds_box.cpp
+++ b/ydb/core/mind/bscontroller/cmds_box.cpp
@@ -38,6 +38,7 @@ namespace NKikimr::NBsController {
 
         auto &boxes = Boxes.Unshare();
         boxes[id] = std::move(box);
+        Fit.Boxes.insert(id);
     }
 
     void TBlobStorageController::TConfigState::ExecuteStep(const NKikimrBlobStorage::TReadBox& cmd, TStatus& status) {
@@ -80,6 +81,7 @@ namespace NKikimr::NBsController {
         }
 
         boxes.erase(it);
+        Fit.Boxes.insert(id);
     }
 
     void TBlobStorageController::TConfigState::ExecuteStep(const NKikimrBlobStorage::TMergeBoxes& cmd, TStatus& /*status*/) {
diff --git a/ydb/core/mind/bscontroller/cmds_drive_status.cpp b/ydb/core/mind/bscontroller/cmds_drive_status.cpp
index c91295fb2c2..31b1696ea88 100644
--- a/ydb/core/mind/bscontroller/cmds_drive_status.cpp
+++ b/ydb/core/mind/bscontroller/cmds_drive_status.cpp
@@ -24,10 +24,12 @@ namespace NKikimr::NBsController {
         }
 
         TPDiskInfo *pdisk = PDisks.FindForUpdate(pdiskId);
+        bool fitGroups = false;
         const bool wasGoodExpectedStatus = pdisk->HasGoodExpectedStatus();
         if (const auto s = cmd.GetStatus(); s != NKikimrBlobStorage::EDriveStatus::UNKNOWN && s != pdisk->Status) {
             pdisk->Status = s;
             pdisk->StatusTimestamp = Timestamp;
+            fitGroups = s == NKikimrBlobStorage::EDriveStatus::BROKEN;
         }
         if (const auto ds = cmd.GetDecommitStatus(); ds != NKikimrBlobStorage::EDecommitStatus::DECOMMIT_UNSET &&
                 ds != pdisk->DecommitStatus) {
@@ -42,6 +44,14 @@ namespace NKikimr::NBsController {
             }
         }
 
+        if (fitGroups) {
+            for (const auto& [id, slot] : pdisk->VSlotsOnPDisk) {
+                if (slot->Group) {
+                    Fit.PoolsAndGroups.emplace(slot->Group->StoragePoolId, slot->Group->ID);
+                }
+            }
+        }
+
         STLOG(PRI_INFO, BS_CONTROLLER_AUDIT, BSCA01, "UpdateDriveStatus",
             (UniqueId, UniqueId),
             (FQDN, host.GetFqdn()),
@@ -129,6 +139,7 @@ namespace NKikimr::NBsController {
                 }
                 STLOG(PRI_INFO, BS_CONTROLLER_AUDIT, BSCA06, "Set new ExpectedSerial for HostConfigs drive",
                     (UniqueId, UniqueId), (Serial, newSerial), (BoxId, boxId), (PDiskId, *updatePDiskId), (Path, path));
+                Fit.Boxes.insert(boxId);
                 return;
             }
         }
@@ -174,6 +185,8 @@ namespace NKikimr::NBsController {
         Y_VERIFY(success);
         driveInfoNew->PDiskConfig = config;
 
+        Fit.Boxes.insert(boxId);
+
         STLOG(PRI_INFO, BS_CONTROLLER_AUDIT, BSCA00, "AddDriveSerial", (UniqueId, UniqueId), (Serial, newSerial),
             (BoxId, boxId));
     }
@@ -237,6 +250,8 @@ namespace NKikimr::NBsController {
             driveInfoNew->PDiskType = PDiskTypeToPDiskType(pdiskUpdate->Kind.Type());
             driveInfoNew->PDiskConfig = pdiskUpdate->PDiskConfig;
             driveInfoNew->LifeStage = NKikimrBlobStorage::TDriveLifeStage::REMOVED;
+
+            Fit.Boxes.insert(pdiskUpdate->BoxId);
         } else {
             if (driveInfo->LifeStage == NKikimrBlobStorage::TDriveLifeStage::REMOVED) {
                 throw TExAlready() << "Drive is already removed";
@@ -258,6 +273,8 @@ namespace NKikimr::NBsController {
             driveInfoMutable->PDiskId.Clear();
             driveInfoMutable->LifeStage = NKikimrBlobStorage::TDriveLifeStage::REMOVED;
 
+            Fit.Boxes.insert(driveInfoMutable->BoxId);
+
             STLOG(PRI_INFO, BS_CONTROLLER_AUDIT, BSCA07, "RemoveDriveSerial", (UniqueId, UniqueId), (Serial, serial));
         }
     }
diff --git a/ydb/core/mind/bscontroller/cmds_host_config.cpp b/ydb/core/mind/bscontroller/cmds_host_config.cpp
index bd145d8837a..0651ca81c2a 100644
--- a/ydb/core/mind/bscontroller/cmds_host_config.cpp
+++ b/ydb/core/mind/bscontroller/cmds_host_config.cpp
@@ -39,6 +39,15 @@ namespace NKikimr::NBsController {
 
         auto &hostConfigs = HostConfigs.Unshare();
         hostConfigs[id] = std::move(config);
+
+        for (const auto& [boxId, box] : Boxes.Get()) {
+            for (const auto& [hostKey, host] : box.Hosts) {
+                if (host.HostConfigId == id) {
+                    Fit.Boxes.insert(boxId);
+                    break;
+                }
+            }
+        }
     }
 
     void TBlobStorageController::TConfigState::ExecuteStep(const NKikimrBlobStorage::TReadHostConfig& cmd, TStatus& status) {
diff --git a/ydb/core/mind/bscontroller/cmds_storage_pool.cpp b/ydb/core/mind/bscontroller/cmds_storage_pool.cpp
index eca604d6dc9..ca931601bad 100644
--- a/ydb/core/mind/bscontroller/cmds_storage_pool.cpp
+++ b/ydb/core/mind/bscontroller/cmds_storage_pool.cpp
@@ -156,6 +156,7 @@ namespace NKikimr::NBsController {
 
         auto &storagePools = StoragePools.Unshare();
         storagePools[id] = std::move(storagePool);
+        Fit.PoolsAndGroups.emplace(id, std::nullopt);
     }
 
     void TBlobStorageController::TConfigState::ExecuteStep(const NKikimrBlobStorage::TReadStoragePool& cmd, TStatus& status) {
@@ -361,6 +362,9 @@ namespace NKikimr::NBsController {
         if (cmd.GetSuppressDonorMode()) {
             SuppressDonorMode.insert(vslotInfo->VSlotId);
         }
+
+        Y_VERIFY(vslotInfo->Group);
+        Fit.PoolsAndGroups.emplace(vslotInfo->Group->StoragePoolId, vslotInfo->Group->ID);
     }
 
     void TBlobStorageController::TConfigState::ExecuteStep(const NKikimrBlobStorage::TMoveGroups& cmd, TStatus& /*status*/) {
diff --git a/ydb/core/mind/bscontroller/config.h b/ydb/core/mind/bscontroller/config.h
index 1d419da20ce..ca7e5f44d77 100644
--- a/ydb/core/mind/bscontroller/config.h
+++ b/ydb/core/mind/bscontroller/config.h
@@ -7,6 +7,15 @@
 namespace NKikimr {
     namespace NBsController {
 
+        struct TConfigFitAction {
+            std::set<TBoxId> Boxes;
+            std::multiset<std::tuple<TBoxStoragePoolId, std::optional<TGroupId>>> PoolsAndGroups; // nullopt goes first and means 'cover all groups in the pool'
+
+            operator bool() const {
+                return !Boxes.empty() || !PoolsAndGroups.empty();
+            }
+        };
+
         class TBlobStorageController::TConfigState {
             template<typename T>
             class TCowHolder {
@@ -101,6 +110,8 @@ namespace NKikimr {
 
             TStoragePoolStat& StoragePoolStat;
 
+            TConfigFitAction Fit;
+
         public:
             TConfigState(TBlobStorageController &controller, const THostRecordMap &hostRecords, TInstant timestamp)
                 : Self(controller)
@@ -131,6 +142,8 @@ namespace NKikimr {
             }
 
             void Commit() {
+                Y_VERIFY(!Fit);
+
                 HostConfigs.Commit();
                 Boxes.Commit();
                 StoragePools.Commit();
diff --git a/ydb/core/mind/bscontroller/config_cmd.cpp b/ydb/core/mind/bscontroller/config_cmd.cpp
index d4c3c4a3310..86e5dcc2034 100644
--- a/ydb/core/mind/bscontroller/config_cmd.cpp
+++ b/ydb/core/mind/bscontroller/config_cmd.cpp
@@ -175,27 +175,21 @@ namespace NKikimr::NBsController {
                 for (const auto& step : Cmd.GetCommand()) {
                     WrapCommand([&] {
                         THPTimer timer;
-                        bool fitPDisks = false;
-                        bool fitGroups = false;
                         auto& status = *Response->MutableStatus()->rbegin();
-                        ExecuteStep(*State, step, status, fitPDisks, fitGroups);
+                        ExecuteStep(*State, step, status);
                         State->CheckConsistency();
-                        if (fitPDisks) {
-                            Self->FitPDisksForUserConfig(*State);
-                            State->CheckConsistency();
-                        }
-                        if (fitGroups) {
-                            std::deque<ui64> expectedSlotSize;
-                            if (step.GetCommandCase() == NKikimrBlobStorage::TConfigRequest::TCommand::kDefineStoragePool) {
-                                const auto& cmd = step.GetDefineStoragePool();
-                                for (ui64 size : cmd.GetExpectedGroupSlotSize()) {
-                                    expectedSlotSize.push_back(size);
-                                }
+                        Self->FitPDisksForUserConfig(*State);
+
+                        std::deque<ui64> expectedSlotSize;
+                        if (step.GetCommandCase() == NKikimrBlobStorage::TConfigRequest::TCommand::kDefineStoragePool) {
+                            const auto& cmd = step.GetDefineStoragePool();
+                            for (ui64 size : cmd.GetExpectedGroupSlotSize()) {
+                                expectedSlotSize.push_back(size);
                             }
-                            const auto availabilityDomainId = AppData()->DomainsInfo->GetDomainUidByTabletId(Self->TabletID());
-                            Self->FitGroupsForUserConfig(*State, availabilityDomainId, Cmd, std::move(expectedSlotSize), status);
-                            State->CheckConsistency();
                         }
+                        const auto availabilityDomainId = AppData()->DomainsInfo->GetDomainUidByTabletId(Self->TabletID());
+                        Self->FitGroupsForUserConfig(*State, availabilityDomainId, Cmd, std::move(expectedSlotSize), status);
+
                         const TDuration passed = TDuration::Seconds(timer.Passed());
                         switch (step.GetCommandCase()) {
 #define MAP_TIMING(CMD, NAME) \
@@ -289,43 +283,37 @@ namespace NKikimr::NBsController {
             }
 
             void ExecuteStep(TConfigState& state, const NKikimrBlobStorage::TConfigRequest::TCommand& cmd,
-                    NKikimrBlobStorage::TConfigResponse::TStatus& status, bool& fitPDisks, bool& fitGroups) {
+                    NKikimrBlobStorage::TConfigResponse::TStatus& status) {
+                state.ExplicitReconfigureMap.clear();
+                state.SuppressDonorMode.clear();
                 switch (cmd.GetCommandCase()) {
-#define HANDLE_COMMAND(NAME, FP, FG) \
-                    case NKikimrBlobStorage::TConfigRequest::TCommand::k ## NAME: \
-                        if (FG) { \
-                            state.ExplicitReconfigureMap.clear(); \
-                            state.SuppressDonorMode.clear(); \
-                        } \
-                        state.ExecuteStep(cmd.Get ## NAME(), status); \
-                        fitPDisks = FP; \
-                        fitGroups = FG; \
-                        return;
-
-                    HANDLE_COMMAND(DefineHostConfig,     true,  false)
-                    HANDLE_COMMAND(ReadHostConfig,       false, false)
-                    HANDLE_COMMAND(DeleteHostConfig,     false, false)
-                    HANDLE_COMMAND(DefineBox,            true,  false)
-                    HANDLE_COMMAND(ReadBox,              false, false)
-                    HANDLE_COMMAND(DeleteBox,            true,  false)
-                    HANDLE_COMMAND(DefineStoragePool,    false, true )
-                    HANDLE_COMMAND(ReadStoragePool,      false, false)
-                    HANDLE_COMMAND(DeleteStoragePool,    false, false)
-                    HANDLE_COMMAND(UpdateDriveStatus,    false, true )
-                    HANDLE_COMMAND(ReadDriveStatus,      false, false)
-                    HANDLE_COMMAND(ProposeStoragePools,  false, false)
-                    HANDLE_COMMAND(QueryBaseConfig,      false, false)
-                    HANDLE_COMMAND(ReassignGroupDisk,    false, true )
-                    HANDLE_COMMAND(MergeBoxes,           false, false)
-                    HANDLE_COMMAND(MoveGroups,           false, false)
-                    HANDLE_COMMAND(DropDonorDisk,        false, false)
-                    HANDLE_COMMAND(AddDriveSerial,       true,  false)
-                    HANDLE_COMMAND(RemoveDriveSerial,    true,  false)
-                    HANDLE_COMMAND(ForgetDriveSerial,    false, false)
-                    HANDLE_COMMAND(MigrateToSerial,      false, false)
-                    HANDLE_COMMAND(AllocateVirtualGroup, false, false)
-                    HANDLE_COMMAND(DecommitGroups,       false, false)
-                    HANDLE_COMMAND(WipeVDisk,            false, true)
+#define HANDLE_COMMAND(NAME) \
+                    case NKikimrBlobStorage::TConfigRequest::TCommand::k ## NAME: return state.ExecuteStep(cmd.Get ## NAME(), status);
+
+                    HANDLE_COMMAND(DefineHostConfig)
+                    HANDLE_COMMAND(ReadHostConfig)
+                    HANDLE_COMMAND(DeleteHostConfig)
+                    HANDLE_COMMAND(DefineBox)
+                    HANDLE_COMMAND(ReadBox)
+                    HANDLE_COMMAND(DeleteBox)
+                    HANDLE_COMMAND(DefineStoragePool)
+                    HANDLE_COMMAND(ReadStoragePool)
+                    HANDLE_COMMAND(DeleteStoragePool)
+                    HANDLE_COMMAND(UpdateDriveStatus)
+                    HANDLE_COMMAND(ReadDriveStatus)
+                    HANDLE_COMMAND(ProposeStoragePools)
+                    HANDLE_COMMAND(QueryBaseConfig)
+                    HANDLE_COMMAND(ReassignGroupDisk)
+                    HANDLE_COMMAND(MergeBoxes)
+                    HANDLE_COMMAND(MoveGroups)
+                    HANDLE_COMMAND(DropDonorDisk)
+                    HANDLE_COMMAND(AddDriveSerial)
+                    HANDLE_COMMAND(RemoveDriveSerial)
+                    HANDLE_COMMAND(ForgetDriveSerial)
+                    HANDLE_COMMAND(MigrateToSerial)
+                    HANDLE_COMMAND(AllocateVirtualGroup)
+                    HANDLE_COMMAND(DecommitGroups)
+                    HANDLE_COMMAND(WipeVDisk)
 
                     case NKikimrBlobStorage::TConfigRequest::TCommand::kAddMigrationPlan:
                     case NKikimrBlobStorage::TConfigRequest::TCommand::kDeleteMigrationPlan:
diff --git a/ydb/core/mind/bscontroller/config_fit_groups.cpp b/ydb/core/mind/bscontroller/config_fit_groups.cpp
index dfb88493df9..45d3443b8e5 100644
--- a/ydb/core/mind/bscontroller/config_fit_groups.cpp
+++ b/ydb/core/mind/bscontroller/config_fit_groups.cpp
@@ -525,16 +525,20 @@ namespace NKikimr {
         void TBlobStorageController::FitGroupsForUserConfig(TConfigState& state, ui32 availabilityDomainId,
                 const NKikimrBlobStorage::TConfigRequest& cmd, std::deque<ui64> expectedSlotSize,
                 NKikimrBlobStorage::TConfigResponse::TStatus& status) {
+            auto poolsAndGroups = std::exchange(state.Fit.PoolsAndGroups, {});
+            if (poolsAndGroups.empty()) {
+                return; // nothing to do
+            }
+
             std::unordered_map<TString, std::pair<ui32, TBoxStoragePoolId>> filterMap;
             std::unordered_set<TString> changedFilters;
 
             // scan through all storage pools and fit the number of groups to desired one
-            for (const auto& [storagePoolId, storagePool] : state.StoragePools.Get()) {
+            auto processSingleStoragePool = [&](TBoxStoragePoolId storagePoolId, const TStoragePoolInfo& storagePool,
+                    bool createNewGroups, const auto& enumerateGroups) {
                 TGroupFitter fitter(state, availabilityDomainId, cmd, expectedSlotSize, PDiskSpaceMarginPromille,
                     storagePoolId, storagePool, status, VSlotReadyTimestampQ);
 
-                const auto& storagePoolGroups = state.StoragePoolGroups.Get();
-                const auto range = storagePoolGroups.equal_range(storagePoolId);
                 ui32 numActualGroups = 0;
 
                 try {
@@ -552,14 +556,17 @@ namespace NKikimr {
                     numGroups += storagePool.NumGroups;
                     id = storagePoolId;
 
-                    for (auto it = range.first; it != range.second; ++it, ++numActualGroups) {
-                        fitter.CheckExistingGroup(it->second);
-                    }
-                    if (numActualGroups < storagePool.NumGroups) {
-                        changedFilters.insert(identifier);
-                    }
-                    for (; numActualGroups < storagePool.NumGroups; ++numActualGroups) {
-                        fitter.CreateGroup();
+                    enumerateGroups([&](TGroupId groupId) {
+                        fitter.CheckExistingGroup(groupId);
+                        ++numActualGroups;
+                    });
+                    if (createNewGroups) {
+                        if (numActualGroups < storagePool.NumGroups) {
+                            changedFilters.insert(identifier);
+                        }
+                        for (; numActualGroups < storagePool.NumGroups; ++numActualGroups) {
+                            fitter.CreateGroup();
+                        }
                     }
                 } catch (const TExFitGroupError& ex) {
                     throw TExError() << "Group fit error"
@@ -573,6 +580,31 @@ namespace NKikimr {
                         << " StoragePoolId# " << std::get<1>(storagePoolId)
                         << " impossible to reduce number of groups";
                 }
+            };
+
+            const auto& storagePools = state.StoragePools.Get();
+            for (auto it = poolsAndGroups.begin(); it != poolsAndGroups.end(); ) {
+                const auto& [storagePoolId, groupId] = *it;
+                const auto spIt = storagePools.find(storagePoolId);
+                Y_VERIFY(spIt != storagePools.end());
+                if (!groupId) {
+                    // process all groups in this pool and skip the rest
+                    processSingleStoragePool(spIt->first, spIt->second, true, [&](const auto& callback) {
+                        const auto& storagePoolGroups = state.StoragePoolGroups.Get();
+                        for (auto [begin, end] = storagePoolGroups.equal_range(spIt->first); begin != end; ++begin) {
+                            callback(begin->second);
+                        }
+                    });
+                    for (; it != poolsAndGroups.end() && std::get<0>(*it) == storagePoolId; ++it)
+                    {}
+                } else {
+                    // process explicit group set
+                    processSingleStoragePool(spIt->first, spIt->second, false, [&](const auto& callback) {
+                        for (; it != poolsAndGroups.end() && std::get<0>(*it) == spIt->first; ++it) {
+                            callback(*std::get<1>(*it));
+                        }
+                    });
+                }
             }
 
             if (!cmd.GetIgnoreGroupReserve()) {
@@ -584,6 +616,8 @@ namespace NKikimr {
                     fitter.CheckReserve(numGroups, GroupReserveMin, GroupReservePart);
                 }
             }
+
+            state.CheckConsistency();
         }
 
     } // NBsController
diff --git a/ydb/core/mind/bscontroller/config_fit_pdisks.cpp b/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
index 698745df28a..d8934d4b404 100644
--- a/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
+++ b/ydb/core/mind/bscontroller/config_fit_pdisks.cpp
@@ -139,10 +139,17 @@ namespace NKikimr {
         }
 
         void TBlobStorageController::FitPDisksForUserConfig(TConfigState &state) {
+            auto pdisksForBoxes = std::exchange(state.Fit.Boxes, {});
+            if (pdisksForBoxes.empty()) {
+                return;
+            }
+
             // re-fill PDisksToRemove set with all PDisks, we will erase remaining ones from this set a bit later
             state.PDisksToRemove.clear();
-            state.PDisks.ForEach([&](const TPDiskId& pdiskId, const TPDiskInfo& /*pdiskInfo*/) {
-                state.PDisksToRemove.insert(pdiskId);
+            state.PDisks.ForEach([&](const TPDiskId& pdiskId, const TPDiskInfo& pdiskInfo) {
+                if (pdisksForBoxes.contains(pdiskInfo.BoxId)) {
+                    state.PDisksToRemove.insert(pdiskId);
+                }
                 return true;
             });
 
@@ -150,6 +157,9 @@ namespace NKikimr {
 
             // Iterate over initial DrivesSerials map since every call to Unshare will invalidate iterators
             state.DrivesSerials.ScanRange({}, {}, [&](const auto& serial, const auto& driveInfo, const auto& getMutableItem) {
+                if (!pdisksForBoxes.contains(driveInfo.BoxId)) {
+                    return true;
+                }
                 if (driveInfo.LifeStage == NKikimrBlobStorage::TDriveLifeStage::NOT_SEEN) {
                     // Try to find drive in currently online nodes and create new PDisk
                     if (auto nodeIt = NodeForSerial.find(serial.Serial); nodeIt != NodeForSerial.end()) {
@@ -165,10 +175,15 @@ namespace NKikimr {
                 return true;
             });
 
-            const auto &hostConfigs = state.HostConfigs.Get();
-            for (const auto &kvBox : state.Boxes.Get()) {
-                const TBoxId &boxId = kvBox.first;
-                const TBoxInfo &box = kvBox.second;
+            const auto& hostConfigs = state.HostConfigs.Get();
+            const auto& boxes = state.Boxes.Get();
+            for (const TBoxId& boxId : pdisksForBoxes) {
+                const auto boxIt = boxes.find(boxId);
+                if (boxIt == boxes.end()) {
+                    continue; // box was deleted
+                }
+                const TBoxInfo& box = boxIt->second;
+
                 THashSet<TNodeId> usedNodes;
                 for (const auto& [hostKey, hostValue] : box.Hosts) {
                     const THostConfigId &hostConfigId = hostValue.HostConfigId;
@@ -254,6 +269,7 @@ namespace NKikimr {
             for (const auto& pdiskId : state.PDisksToRemove) {
                 STLOG(PRI_NOTICE, BS_CONTROLLER, BSCFP03, "PDisk to remove:", (PDiskId, pdiskId));
             }
+            state.CheckConsistency();
         }
 
         void TBlobStorageController::FitPDisksForNode(TConfigState& state, ui32 nodeId, const std::vector<TSerial>& serials) {
diff --git a/ydb/core/mind/bscontroller/impl.h b/ydb/core/mind/bscontroller/impl.h
index 0dabc02d26c..8a9b182e959 100644
--- a/ydb/core/mind/bscontroller/impl.h
+++ b/ydb/core/mind/bscontroller/impl.h
@@ -43,8 +43,6 @@ public:
 class TBlobStorageController : public TActor<TBlobStorageController>, public TTabletExecutedFlat {
 public:
     using THostConfigId = Schema::HostConfig::TKey::Type;
-    using TBoxId = Schema::Box::TKey::Type;
-    using TBoxStoragePoolId = Schema::BoxStoragePool::TKey::Type;
     using THostId = std::tuple<TString, i32>; // (Host, IcPort) identifier
 
     class TTxInitScheme;
diff --git a/ydb/core/mind/bscontroller/storage_stats_calculator.cpp b/ydb/core/mind/bscontroller/storage_stats_calculator.cpp
index 420471d3b44..f39d7885d3e 100644
--- a/ydb/core/mind/bscontroller/storage_stats_calculator.cpp
+++ b/ydb/core/mind/bscontroller/storage_stats_calculator.cpp
@@ -51,7 +51,7 @@ public:
 
         using TEntityKey = std::tuple<TString, TString>; // PDiskFilter, ErasureSpecies
         std::unordered_map<TEntityKey, size_t> entityMap;
-        std::unordered_map<TBlobStorageController::TBoxStoragePoolId, size_t> spToEntity;
+        std::unordered_map<TBoxStoragePoolId, size_t> spToEntity;
 
         for (const auto erasure : {TBlobStorageGroupType::ErasureMirror3dc, TBlobStorageGroupType::Erasure4Plus2Block}) {
             for (const NKikimrBlobStorage::EPDiskType type : {NKikimrBlobStorage::ROT, NKikimrBlobStorage::SSD}) {
@@ -88,7 +88,7 @@ public:
         }
 
         for (const auto& [groupId, group] : SystemViewsState.Groups) {
-            const TBlobStorageController::TBoxStoragePoolId key(group.GetBoxId(), group.GetStoragePoolId());
+            const TBoxStoragePoolId key(group.GetBoxId(), group.GetStoragePoolId());
             if (const auto it = spToEntity.find(key); it != spToEntity.end()) {
                 auto& e = storageStats[it->second];
                 e.SetCurrentGroupsCreated(e.GetCurrentGroupsCreated() + 1);
@@ -98,7 +98,7 @@ public:
         }
 
         using T = std::decay_t<decltype(SystemViewsState.PDisks)>::value_type;
-        std::unordered_map<TBlobStorageController::TBoxId, std::vector<const T*>> boxes;
+        std::unordered_map<TBoxId, std::vector<const T*>> boxes;
         for (const auto& kv : SystemViewsState.PDisks) {
             if (kv.second.HasBoxId()) {
                 boxes[kv.second.GetBoxId()].push_back(&kv);
diff --git a/ydb/core/mind/bscontroller/sys_view.cpp b/ydb/core/mind/bscontroller/sys_view.cpp
index 81cbc89b545..6c41cedf346 100644
--- a/ydb/core/mind/bscontroller/sys_view.cpp
+++ b/ydb/core/mind/bscontroller/sys_view.cpp
@@ -35,11 +35,11 @@ void FillKey(NKikimrSysView::TGroupKey* key, const TGroupId& id) {
     key->SetGroupId(id);
 }
 
-TBlobStorageController::TBoxStoragePoolId TransformKey(const NKikimrSysView::TStoragePoolKey& key) {
+TBoxStoragePoolId TransformKey(const NKikimrSysView::TStoragePoolKey& key) {
     return std::make_tuple(key.GetBoxId(), key.GetStoragePoolId());
 }
 
-void FillKey(NKikimrSysView::TStoragePoolKey* key, const TBlobStorageController::TBoxStoragePoolId& id) {
+void FillKey(NKikimrSysView::TStoragePoolKey* key, const TBoxStoragePoolId& id) {
     key->SetBoxId(std::get<0>(id));
     key->SetStoragePoolId(std::get<1>(id));
 }
@@ -77,7 +77,7 @@ class TSystemViewsCollector : public TActorBootstrapped<TSystemViewsCollector> {
     std::vector<std::pair<TPDiskId, const NKikimrSysView::TPDiskInfo*>> PDiskIndex;
     std::vector<std::pair<TVSlotId, const NKikimrSysView::TVSlotInfo*>> VSlotIndex;
     std::vector<std::pair<TGroupId, const NKikimrSysView::TGroupInfo*>> GroupIndex;
-    std::vector<std::pair<TBlobStorageController::TBoxStoragePoolId, const NKikimrSysView::TStoragePoolInfo*>> StoragePoolIndex;
+    std::vector<std::pair<TBoxStoragePoolId, const NKikimrSysView::TStoragePoolInfo*>> StoragePoolIndex;
     TBlobStorageController::THostRecordMap HostRecords;
     ui32 GroupReserveMin = 0;
     ui32 GroupReservePart = 0;
diff --git a/ydb/core/mind/bscontroller/sys_view.h b/ydb/core/mind/bscontroller/sys_view.h
index 0fa9fac124e..1dd79766cd2 100644
--- a/ydb/core/mind/bscontroller/sys_view.h
+++ b/ydb/core/mind/bscontroller/sys_view.h
@@ -15,8 +15,7 @@ struct TControllerSystemViewsState {
     std::unordered_map<TPDiskId, NKikimrSysView::TPDiskInfo, THash<TPDiskId>> PDisks;
     std::unordered_map<TVSlotId, NKikimrSysView::TVSlotInfo, THash<TVSlotId>> VSlots;
     std::unordered_map<TGroupId, NKikimrSysView::TGroupInfo, THash<TGroupId>> Groups;
-    std::unordered_map<TBlobStorageController::TBoxStoragePoolId, NKikimrSysView::TStoragePoolInfo,
-        THash<TBlobStorageController::TBoxStoragePoolId>> StoragePools;
+    std::unordered_map<TBoxStoragePoolId, NKikimrSysView::TStoragePoolInfo, THash<TBoxStoragePoolId>> StoragePools;
 };
 
 struct TEvControllerUpdateSystemViews :
@@ -26,7 +25,7 @@ struct TEvControllerUpdateSystemViews :
     std::unordered_set<TPDiskId, THash<TPDiskId>> DeletedPDisks;
     std::unordered_set<TVSlotId, THash<TVSlotId>> DeletedVSlots;
     std::unordered_set<TGroupId, THash<TGroupId>> DeletedGroups;
-    std::unordered_set<TBlobStorageController::TBoxStoragePoolId, THash<TBlobStorageController::TBoxStoragePoolId>> DeletedStoragePools;
+    std::unordered_set<TBoxStoragePoolId, THash<TBoxStoragePoolId>> DeletedStoragePools;
     TBlobStorageController::THostRecordMap HostRecords;
     ui32 GroupReserveMin;
     ui32 GroupReservePart;
diff --git a/ydb/core/mind/bscontroller/types.h b/ydb/core/mind/bscontroller/types.h
index 31a6ac15a5e..83eca1e4760 100644
--- a/ydb/core/mind/bscontroller/types.h
+++ b/ydb/core/mind/bscontroller/types.h
@@ -26,6 +26,9 @@ namespace NKikimr {
         using TNodeId = Schema::Node::TKey::Type;
         using TGroupId = Schema::Group::TKey::Type;
 
+        using TBoxId = ui64;
+        using TBoxStoragePoolId = std::tuple<ui64, ui64>;
+
         class TBlobStorageController;
 
         struct TGroupLatencyStats {