Skip to content

Commit 0382086

Browse files
rosikrosik
authored
Infer PDisk ExpectedSlotCount from drive size (#20966)
1 parent e9467a0 commit 0382086

File tree

19 files changed

+233
-25
lines changed

19 files changed

+233
-25
lines changed

‎ydb/core/blobstorage/nodewarden/blobstorage_node_warden_ut.cpp

Lines changed: 106 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -264,7 +264,8 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
264264
return MakeBSControllerID();
265265
}
266266

267-
ui32 CreatePDisk(TTestActorRuntime &runtime, ui32 nodeIdx, TString path, ui64 guid, ui32 pdiskId, ui64 pDiskCategory) {
267+
ui32 CreatePDisk(TTestActorRuntime &runtime, ui32 nodeIdx, TString path, ui64 guid, ui32 pdiskId, ui64 pDiskCategory,
268+
ui64 inferPDiskSlotCountFromUnitSize = 0) {
268269
VERBOSE_COUT(" Creating pdisk");
269270

270271
ui32 nodeId = runtime.GetNodeId(nodeIdx);
@@ -277,6 +278,10 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
277278
pdisk->SetPDiskGuid(guid);
278279
pdisk->SetPDiskCategory(pDiskCategory);
279280
pdisk->SetEntityStatus(NKikimrBlobStorage::CREATE);
281+
if (inferPDiskSlotCountFromUnitSize) {
282+
pdisk->SetInferPDiskSlotCountFromUnitSize(inferPDiskSlotCountFromUnitSize);
283+
}
284+
280285
runtime.Send(new IEventHandle(MakeBlobStorageNodeWardenID(nodeId), TActorId(), ev.release()));
281286

282287
return pdiskId;
@@ -914,6 +919,106 @@ Y_UNIT_TEST_SUITE(TBlobStorageWardenTest) {
914919

915920
UNIT_ASSERT_EQUAL(pdiskId, restartPDiskEv->PDiskId);
916921
}
922+
923+
void TestInferPDiskSlotCount(ui64 driveSize, ui64 unitSizeInBytes,
924+
ui64 expectedSlotCount, ui32 expectedSlotSizeInUnits, double expectedRelativeError = 0) {
925+
TIntrusivePtr<TPDiskConfig> pdiskConfig = new TPDiskConfig("fake_drive", 0, 0, 0);
926+
927+
NStorage::TNodeWarden::InferPDiskSlotCount(pdiskConfig, driveSize, unitSizeInBytes);
928+
929+
double unitSizeCalculated = double(driveSize) / pdiskConfig->ExpectedSlotCount / pdiskConfig->SlotSizeInUnits;
930+
double unitSizeRelativeError = (unitSizeCalculated - unitSizeInBytes) / unitSizeInBytes;
931+
932+
VERBOSE_COUT(""
933+
<< " driveSize# " << driveSize
934+
<< " unitSizeInBytes# " << unitSizeInBytes
935+
<< " ->"
936+
<< " ExpectedSlotCount# " << pdiskConfig->ExpectedSlotCount
937+
<< " SlotSizeInUnits# " << pdiskConfig->SlotSizeInUnits
938+
<< " relativeError# " << unitSizeRelativeError
939+
);
940+
941+
if (expectedSlotCount) {
942+
UNIT_ASSERT_VALUES_EQUAL(pdiskConfig->ExpectedSlotCount, expectedSlotCount);
943+
}
944+
if (expectedSlotSizeInUnits) {
945+
UNIT_ASSERT_VALUES_EQUAL(pdiskConfig->SlotSizeInUnits, expectedSlotSizeInUnits);
946+
}
947+
948+
if (expectedRelativeError > 0) {
949+
UNIT_ASSERT_LE_C(abs(unitSizeRelativeError), expectedRelativeError,
950+
TStringBuilder() << "abs(" << unitSizeRelativeError << ") < " << expectedRelativeError
951+
);
952+
}
953+
}
954+
955+
CUSTOM_UNIT_TEST(TestInferPDiskSlotCountPureFunction) {
956+
TestInferPDiskSlotCount(7900, 1000, 8, 1u, 0.0125);
957+
TestInferPDiskSlotCount(8000, 1000, 8, 1u, std::numeric_limits<double>::epsilon());
958+
TestInferPDiskSlotCount(8100, 1000, 8, 1u, 0.0125);
959+
TestInferPDiskSlotCount(16000, 1000, 16, 1u, std::numeric_limits<double>::epsilon());
960+
TestInferPDiskSlotCount(24000, 1000, 12, 2u, std::numeric_limits<double>::epsilon());
961+
TestInferPDiskSlotCount(31000, 1000, 16, 2u, 0.032);
962+
TestInferPDiskSlotCount(50000, 1000, 13, 4u, 0.039);
963+
TestInferPDiskSlotCount(50000, 100, 16, 32u, 0.024);
964+
TestInferPDiskSlotCount(18000, 200, 11, 8u, 0.023);
965+
966+
for (ui64 i=1; i<=1024; i++) {
967+
// In all cases the relative error doesn't exceed 1/maxSlotCount
968+
TestInferPDiskSlotCount(i, 1, 0, 0, 1./16);
969+
}
970+
971+
const size_t c_200GB = 200'000'000'000;
972+
const size_t c_2000GB = 2000'000'000'000;
973+
974+
// Some real-world examples
975+
TestInferPDiskSlotCount(1919'366'987'776, c_200GB, 10, 1u, 0.041); // "Micron_5200_MTFDDAK1T9TDD"
976+
TestInferPDiskSlotCount(3199'243'124'736, c_200GB, 16, 1u, 0.001); // "SAMSUNG MZWLR3T8HBLS-00007"
977+
TestInferPDiskSlotCount(6400'161'873'920, c_200GB, 16, 2u, 0.001); // "INTEL SSDPE2KE064T8"
978+
TestInferPDiskSlotCount(6398'611'030'016, c_200GB, 16, 2u, 0.001); // "INTEL SSDPF2KX076T1"
979+
TestInferPDiskSlotCount(17999'117'418'496, c_2000GB, 9, 1u, 0.001); // "WDC WUH721818ALE6L4"
980+
}
981+
982+
std::optional<NKikimrWhiteboard::TPDiskStateInfo> GrabEvPDiskStateUpdate(TTestBasicRuntime& runtime, TActorId edge, ui32 pdiskId) {
983+
VERBOSE_COUT("Awaiting EvPDiskStateUpdate PDiskId# " << pdiskId);
984+
for (int attempt=0; attempt<10;) {
985+
const auto evPDiskStateUpdate = runtime.GrabEdgeEventRethrow<NNodeWhiteboard::TEvWhiteboard::TEvPDiskStateUpdate>(edge);
986+
NKikimrWhiteboard::TPDiskStateInfo pdiskInfo = evPDiskStateUpdate->Get()->Record;
987+
if (pdiskInfo.GetPDiskId() != pdiskId) {
988+
continue;
989+
}
990+
991+
VERBOSE_COUT("- Got EvPDiskStateUpdate# " << evPDiskStateUpdate->ToString());
992+
if (!pdiskInfo.HasSlotSizeInUnits()) {
993+
attempt++;
994+
continue;
995+
}
996+
997+
return pdiskInfo;
998+
}
999+
return std::nullopt;
1000+
}
1001+
1002+
CUSTOM_UNIT_TEST(TestInferPDiskSlotCountComplexSetup) {
1003+
TTempDir tempDir;
1004+
1005+
TTestBasicRuntime runtime(1, false);
1006+
auto nodeId = runtime.GetNodeId(0);
1007+
TString pdiskPath = "SectorMap:TestInferPDiskSlotCountComplexSetup";
1008+
TIntrusivePtr<NPDisk::TSectorMap> sectorMap(new NPDisk::TSectorMap(32_GB));
1009+
Setup(runtime, pdiskPath, sectorMap);
1010+
1011+
TActorId edge = runtime.AllocateEdgeActor();
1012+
runtime.SetDispatchTimeout(TDuration::Seconds(10));
1013+
runtime.RegisterService(NNodeWhiteboard::MakeNodeWhiteboardServiceId(nodeId), edge);
1014+
1015+
NKikimrBlobStorage::TPDiskConfig pdiskConfig;
1016+
ui32 pdiskId = CreatePDisk(runtime, 0, pdiskPath, 0, 1001, 0, 1_GB);
1017+
std::optional<NKikimrWhiteboard::TPDiskStateInfo> pdiskInfo = GrabEvPDiskStateUpdate(runtime, edge, pdiskId);
1018+
UNIT_ASSERT_C(pdiskInfo, "No appropriate TEvPDiskStateUpdate received");
1019+
UNIT_ASSERT_VALUES_EQUAL(pdiskInfo->GetExpectedSlotCount(), 16);
1020+
UNIT_ASSERT_VALUES_EQUAL(pdiskInfo->GetSlotSizeInUnits(), 2u);
1021+
}
9171022
}
9181023

9191024
} // namespace NBlobStorageNodeWardenTest

‎ydb/core/blobstorage/nodewarden/node_warden_impl.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -270,6 +270,7 @@ namespace NKikimr::NStorage {
270270
}
271271

272272
TIntrusivePtr<TPDiskConfig> CreatePDiskConfig(const NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk& pdisk);
273+
static void InferPDiskSlotCount(TIntrusivePtr<TPDiskConfig> pdiskConfig, ui64 driveSize, ui64 unitSizeInBytes);
273274
void StartLocalPDisk(const NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk& pdisk, bool temporary);
274275
void AskBSCToRestartPDisk(ui32 pdiskId, bool ignoreDegradedGroups, ui64 requestCookie);
275276
void OnPDiskRestartFinished(ui32 pdiskId, NKikimrProto::EReplyStatus status);

‎ydb/core/blobstorage/nodewarden/node_warden_pdisk.cpp

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,22 @@ namespace NKikimr::NStorage {
1616
{NPDisk::DEVICE_TYPE_NVME, 300000000},
1717
};
1818

19+
void TNodeWarden::InferPDiskSlotCount(TIntrusivePtr<TPDiskConfig> pdiskConfig, ui64 driveSize, ui64 unitSizeInBytes) {
20+
Y_ABORT_UNLESS(driveSize);
21+
Y_ABORT_UNLESS(unitSizeInBytes);
22+
23+
const double slotCount = lround(double(driveSize) / unitSizeInBytes);
24+
ui32 slotSizeInUnits = 1u;
25+
26+
constexpr long MaxSlots = 16;
27+
while (lround(slotCount/slotSizeInUnits) > MaxSlots) {
28+
slotSizeInUnits *= 2;
29+
}
30+
31+
pdiskConfig->ExpectedSlotCount = lround(slotCount/slotSizeInUnits);
32+
pdiskConfig->SlotSizeInUnits = slotSizeInUnits;
33+
}
34+
1935
TIntrusivePtr<TPDiskConfig> TNodeWarden::CreatePDiskConfig(const NKikimrBlobStorage::TNodeWardenServiceSet::TPDisk& pdisk) {
2036
const TString& path = pdisk.GetPath();
2137
const ui64 pdiskGuid = pdisk.GetPDiskGuid();
@@ -121,6 +137,24 @@ namespace NKikimr::NStorage {
121137
pdiskConfig->EnableSectorEncryption = !pdiskConfig->SectorMap;
122138
}
123139

140+
if (ui64 unitSizeInBytes = pdisk.GetInferPDiskSlotCountFromUnitSize()) {
141+
ui64 driveSize = 0;
142+
TStringStream outDetails;
143+
if (pdiskConfig->SectorMap) {
144+
driveSize = pdiskConfig->SectorMap->DeviceSize;
145+
outDetails << "drive size obtained from SectorMap";
146+
} else if (std::optional<NPDisk::TDriveData> data = NPDisk::GetDriveData(path, &outDetails)) {
147+
driveSize = data->Size;
148+
}
149+
150+
if (!driveSize) {
151+
STLOG(PRI_ERROR, BS_NODE, NW91, "Unable to determine drive size for inferring PDisk slot count",
152+
(Path, path), (Details, outDetails.Str()));
153+
} else {
154+
InferPDiskSlotCount(pdiskConfig, driveSize, unitSizeInBytes);
155+
}
156+
}
157+
124158
const NPDisk::TMainKey& pdiskKey = Cfg->PDiskKey;
125159
TString keyPrintSalt = "@N2#_lW19)2-31!iifI@n1178349617";
126160
pdiskConfig->HashedMainKey.resize(pdiskKey.Keys.size());

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_config.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -136,6 +136,7 @@ struct TPDiskConfig : public TThrRefBase {
136136
ui32 MaxQueuedCompletionActions;
137137
bool UseSpdkNvmeDriver;
138138

139+
// Next 2 are either user-defined or inferred from drive size
139140
ui64 ExpectedSlotCount = 0;
140141
ui32 SlotSizeInUnits = 0;
141142

‎ydb/core/mind/bscontroller/cmds_host_config.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ namespace NKikimr::NBsController {
2323
driveInfo.SharedWithOs = drive.GetSharedWithOs();
2424
driveInfo.ReadCentric = drive.GetReadCentric();
2525
driveInfo.Kind = drive.GetKind();
26+
driveInfo.InferPDiskSlotCountFromUnitSize = drive.GetInferPDiskSlotCountFromUnitSize();
2627

2728
if (drive.HasPDiskConfig()) {
2829
TString config;
@@ -46,6 +47,7 @@ namespace NKikimr::NBsController {
4647
driveInfo.SharedWithOs = false;
4748
driveInfo.ReadCentric = false;
4849
driveInfo.Kind = 0;
50+
driveInfo.InferPDiskSlotCountFromUnitSize = 0;
4951
driveInfo.PDiskConfig = defaultPDiskConfig;
5052

5153
for (const auto& path : field) {

‎ydb/core/mind/bscontroller/cmds_storage_pool.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -597,6 +597,7 @@ namespace NKikimr::NBsController {
597597
x->SetDriveStatus(NKikimrBlobStorage::EDriveStatus::ACTIVE);
598598
x->SetExpectedSlotCount(pdisk.ExpectedSlotCount);
599599
x->SetDecommitStatus(NKikimrBlobStorage::EDecommitStatus::DECOMMIT_NONE);
600+
x->SetInferPDiskSlotCountFromUnitSize(pdisk.InferPDiskSlotCountFromUnitSize);
600601
if (pdisk.PDiskMetrics) {
601602
x->MutablePDiskMetrics()->CopyFrom(*pdisk.PDiskMetrics);
602603
x->MutablePDiskMetrics()->ClearPDiskId();

‎ydb/core/mind/bscontroller/config.cpp

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -115,6 +115,7 @@ namespace NKikimr::NBsController {
115115
pdisk->SetPDiskCategory(pdiskInfo.Kind.GetRaw());
116116
pdisk->SetExpectedSerial(pdiskInfo.ExpectedSerial);
117117
pdisk->SetManagementStage(Self->SerialManagementStage);
118+
pdisk->SetInferPDiskSlotCountFromUnitSize(pdiskInfo.InferPDiskSlotCountFromUnitSize);
118119
if (pdiskInfo.PDiskConfig && !pdisk->MutablePDiskConfig()->ParseFromString(pdiskInfo.PDiskConfig)) {
119120
// TODO(alexvru): report this somehow
120121
}
@@ -908,6 +909,7 @@ namespace NKikimr::NBsController {
908909
drive.SetSharedWithOs(value.SharedWithOs);
909910
drive.SetReadCentric(value.ReadCentric);
910911
drive.SetKind(value.Kind);
912+
drive.SetInferPDiskSlotCountFromUnitSize(value.InferPDiskSlotCountFromUnitSize);
911913

912914
if (const auto& config = value.PDiskConfig) {
913915
NKikimrBlobStorage::TPDiskConfig& pb = *drive.MutablePDiskConfig();
@@ -1044,6 +1046,7 @@ namespace NKikimr::NBsController {
10441046
pb->SetLastSeenSerial(pdisk.LastSeenSerial);
10451047
pb->SetReadOnly(pdisk.Mood == TPDiskMood::ReadOnly);
10461048
pb->SetMaintenanceStatus(pdisk.MaintenanceStatus);
1049+
pb->SetInferPDiskSlotCountFromUnitSize(pdisk.InferPDiskSlotCountFromUnitSize);
10471050
}
10481051

10491052
void TBlobStorageController::Serialize(NKikimrBlobStorage::TVSlotId *pb, TVSlotId id) {

‎ydb/core/mind/bscontroller/config_fit_pdisks.cpp

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@ namespace NKikimr {
2525
bool ReadCentric = false;
2626
TPDiskCategory PDiskCategory = {};
2727
TString PDiskConfig;
28+
ui64 InferPDiskSlotCountFromUnitSize = 0;
2829

2930
TDiskId GetId() const {
3031
return {NodeId, Path};
@@ -72,7 +73,8 @@ namespace NKikimr {
7273
pdiskInfo->SharedWithOs != disk.SharedWithOs ||
7374
pdiskInfo->ReadCentric != disk.ReadCentric ||
7475
pdiskInfo->BoxId != disk.BoxId ||
75-
pdiskInfo->PDiskConfig != disk.PDiskConfig)
76+
pdiskInfo->PDiskConfig != disk.PDiskConfig ||
77+
pdiskInfo->InferPDiskSlotCountFromUnitSize != disk.InferPDiskSlotCountFromUnitSize)
7678
{
7779
// update PDisk configuration
7880
auto pdiskInfo = state.PDisks.FindForUpdate(pdiskId);
@@ -81,11 +83,13 @@ namespace NKikimr {
8183
pdiskInfo->SharedWithOs = disk.SharedWithOs;
8284
pdiskInfo->ReadCentric = disk.ReadCentric;
8385
pdiskInfo->BoxId = disk.BoxId;
84-
if (pdiskInfo->PDiskConfig != disk.PDiskConfig) {
86+
if (pdiskInfo->PDiskConfig != disk.PDiskConfig
87+
|| pdiskInfo->InferPDiskSlotCountFromUnitSize != disk.InferPDiskSlotCountFromUnitSize) {
8588
if (const auto id = FindStaticPDisk(disk, state); id && state.StaticPDisks.at(*id).PDiskConfig != disk.PDiskConfig) {
8689
throw TExError() << "PDiskConfig mismatch for static disk" << TErrorParams::NodeId(disk.NodeId) << TErrorParams::Path(disk.Path);
8790
} else {
8891
pdiskInfo->PDiskConfig = disk.PDiskConfig;
92+
pdiskInfo->InferPDiskSlotCountFromUnitSize = disk.InferPDiskSlotCountFromUnitSize;
8993
}
9094
}
9195
// run ExtractConfig as the very last step
@@ -178,6 +182,7 @@ namespace NKikimr {
178182
disk.ReadCentric = driveInfo.ReadCentric;
179183
disk.Serial = serial;
180184
disk.SharedWithOs = driveInfo.SharedWithOs;
185+
disk.InferPDiskSlotCountFromUnitSize = driveInfo.InferPDiskSlotCountFromUnitSize;
181186

182187
auto diskId = disk.GetId();
183188
auto [_, inserted] = disks.try_emplace(diskId, std::move(disk));
@@ -329,7 +334,8 @@ namespace NKikimr {
329334
NKikimrBlobStorage::EDecommitStatus::DECOMMIT_NONE, NBsController::TPDiskMood::Normal,
330335
disk.Serial, disk.LastSeenSerial, disk.LastSeenPath, staticSlotUsage,
331336
true /* assume shred completed for this disk */,
332-
NKikimrBlobStorage::TMaintenanceStatus::NO_REQUEST);
337+
NKikimrBlobStorage::TMaintenanceStatus::NO_REQUEST,
338+
disk.InferPDiskSlotCountFromUnitSize);
333339

334340
// Set PDiskId and Guid in DrivesSerials
335341
if (auto info = state.DrivesSerials.FindForUpdate(disk.Serial)) {

‎ydb/core/mind/bscontroller/impl.h

Lines changed: 15 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -344,6 +344,7 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
344344
bool HasExpectedSlotCount = false;
345345
ui32 NumActiveSlots = 0; // sum of owners weights allocated on this PDisk
346346
ui32 SlotSizeInUnits = 0;
347+
ui64 InferPDiskSlotCountFromUnitSize = 0;
347348
TMap<Schema::VSlot::VSlotID::Type, TIndirectReferable<TVSlotInfo>::TPtr> VSlotsOnPDisk; // vslots over this PDisk
348349

349350
bool Operational = false; // set to true when both containing node is connected and Operational is reported in Metrics
@@ -382,7 +383,8 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
382383
Table::LastSeenPath,
383384
Table::DecommitStatus,
384385
Table::ShredComplete,
385-
Table::MaintenanceStatus
386+
Table::MaintenanceStatus,
387+
Table::InferPDiskSlotCountFromUnitSize
386388
> adapter(
387389
&TPDiskInfo::Path,
388390
&TPDiskInfo::Kind,
@@ -399,7 +401,8 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
399401
&TPDiskInfo::LastSeenPath,
400402
&TPDiskInfo::DecommitStatus,
401403
&TPDiskInfo::ShredComplete,
402-
&TPDiskInfo::MaintenanceStatus
404+
&TPDiskInfo::MaintenanceStatus,
405+
&TPDiskInfo::InferPDiskSlotCountFromUnitSize
403406
);
404407
callback(&adapter);
405408
}
@@ -423,7 +426,8 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
423426
const TString& lastSeenPath,
424427
ui32 staticSlotUsage,
425428
bool shredComplete,
426-
NKikimrBlobStorage::TMaintenanceStatus::E maintenanceStatus)
429+
NKikimrBlobStorage::TMaintenanceStatus::E maintenanceStatus,
430+
ui64 inferPDiskSlotCountFromUnitSize)
427431
: HostId(hostId)
428432
, Path(path)
429433
, Kind(kind)
@@ -434,6 +438,7 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
434438
, PDiskConfig(std::move(pdiskConfig))
435439
, ShredComplete(shredComplete)
436440
, BoxId(boxId)
441+
, InferPDiskSlotCountFromUnitSize(inferPDiskSlotCountFromUnitSize)
437442
, Status(status)
438443
, StatusTimestamp(statusTimestamp)
439444
, DecommitStatus(decommitStatus)
@@ -994,6 +999,7 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
994999
Table::ReadCentric::Type ReadCentric;
9951000
Table::Kind::Type Kind;
9961001
TMaybe<Table::PDiskConfig::Type> PDiskConfig;
1002+
Table::InferPDiskSlotCountFromUnitSize::Type InferPDiskSlotCountFromUnitSize;
9971003

9981004
template<typename T>
9991005
static void Apply(TBlobStorageController* /*controller*/, T&& callback) {
@@ -1002,13 +1008,15 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
10021008
Table::SharedWithOs,
10031009
Table::ReadCentric,
10041010
Table::Kind,
1005-
Table::PDiskConfig
1011+
Table::PDiskConfig,
1012+
Table::InferPDiskSlotCountFromUnitSize
10061013
> adapter(
10071014
&TDriveInfo::Type,
10081015
&TDriveInfo::SharedWithOs,
10091016
&TDriveInfo::ReadCentric,
10101017
&TDriveInfo::Kind,
1011-
&TDriveInfo::PDiskConfig
1018+
&TDriveInfo::PDiskConfig,
1019+
&TDriveInfo::InferPDiskSlotCountFromUnitSize
10121020
);
10131021
callback(&adapter);
10141022
}
@@ -2430,6 +2438,7 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
24302438
const Schema::PDisk::Guid::Type Guid;
24312439
Schema::PDisk::PDiskConfig::Type PDiskConfig;
24322440
ui32 ExpectedSlotCount = 0;
2441+
ui64 InferPDiskSlotCountFromUnitSize = 0;
24332442

24342443
// runtime info
24352444
ui32 StaticSlotUsage = 0;
@@ -2442,6 +2451,7 @@ class TBlobStorageController : public TActor<TBlobStorageController>, public TTa
24422451
, Path(pdisk.GetPath())
24432452
, Category(pdisk.GetPDiskCategory())
24442453
, Guid(pdisk.GetPDiskGuid())
2454+
, InferPDiskSlotCountFromUnitSize(pdisk.GetInferPDiskSlotCountFromUnitSize())
24452455
{
24462456
if (pdisk.HasPDiskConfig()) {
24472457
const auto& cfg = pdisk.GetPDiskConfig();

0 commit comments

Comments
 (0)