change VDisk compaction params when working on a tiny PDisk (#22538)

alexd65536 · web-flow · commit cff3af972bdc · 2025-08-11T13:24:27.000+03:00
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk.h
@@ -188,7 +188,7 @@ struct TEvYardInitResult : TEventLocal<TEvYardInitResult, TEvBlobStorage::EvYard
     TEvYardInitResult(const NKikimrProto::EReplyStatus status, TString errorReason)
         : Status(status)
         , StatusFlags(0)
-        , PDiskParams(new TPDiskParams(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, DEVICE_TYPE_ROT))
+        , PDiskParams(new TPDiskParams(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, DEVICE_TYPE_ROT, false))
         , ErrorReason(std::move(errorReason))
     {
         Y_VERIFY(status != NKikimrProto::OK, "Single-parameter constructor is for error responses only");
@@ -199,7 +199,7 @@ struct TEvYardInitResult : TEventLocal<TEvYardInitResult, TEvBlobStorage::EvYard
             ui64 bulkWriteBlockSize, ui32 chunkSize, ui32 appendBlockSize,
             TOwner owner, TOwnerRound ownerRound, ui32 ownerWeight, ui32 slotSizeInUnits,
             TStatusFlags statusFlags, TVector<TChunkIdx> ownedChunks,
-            EDeviceType trueMediaType, TString errorReason)
+            EDeviceType trueMediaType, bool isTinyDisk, TString errorReason)
         : Status(status)
         , StatusFlags(statusFlags)
         , PDiskParams(new TPDiskParams(
@@ -215,7 +215,8 @@ struct TEvYardInitResult : TEventLocal<TEvYardInitResult, TEvBlobStorage::EvYard
                     readBlockSize,
                     writeBlockSize,
                     bulkWriteBlockSize,
-                    trueMediaType))
+                    trueMediaType,
+                    isTinyDisk))
         , OwnedChunks(std::move(ownedChunks))
         , ErrorReason(std::move(errorReason))
     {}
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_data.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_data.h
@@ -38,6 +38,7 @@ constexpr ui32 RecordsInSysLog = 16;
 
 constexpr ui64 FullSizeDiskMinimumSize = 800ull * (1 << 30); // 800GB, all disks smaller are considered "small"
 constexpr ui32 SmallDiskMaximumChunkSize = 32 * (1 << 20); // 32MB
+constexpr ui64 TinyDiskSizeThreshold = 80ull * (1 << 30); // 80GB, all disks smaller are considered "tiny"
 
 #define PDISK_FORMAT_VERSION 3
 #define PDISK_DATA_VERSION 2
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp
@@ -1837,14 +1837,15 @@ void TPDisk::ReplyErrorYardInitResult(TYardInit &evYardInit, const TString &str,
     P_LOG(PRI_ERROR, BPD01, error.Str());
     ui64 writeBlockSize = ForsetiOpPieceSizeCached;
     ui64 readBlockSize = ForsetiOpPieceSizeCached;
+    bool isTinyDisk = (Format.DiskSize < NPDisk::TinyDiskSizeThreshold);
     PCtx->ActorSystem->Send(evYardInit.Sender, new NPDisk::TEvYardInitResult(status,
         DriveModel.SeekTimeNs() / 1000ull, DriveModel.Speed(TDriveModel::OP_TYPE_READ),
         DriveModel.Speed(TDriveModel::OP_TYPE_WRITE), readBlockSize, writeBlockSize,
         DriveModel.BulkWriteBlockSize(),
         Format.GetUserAccessibleChunkSize(), Format.GetAppendBlockSize(), OwnerSystem, 0,
         0, Cfg->SlotSizeInUnits,
         GetStatusFlags(OwnerSystem, evYardInit.OwnerGroupType), TVector<TChunkIdx>(),
-        Cfg->RetrieveDeviceType(), error.Str()));
+        Cfg->RetrieveDeviceType(), isTinyDisk, error.Str()));
     Mon.YardInit.CountResponse();
 }
 
@@ -1892,13 +1893,16 @@ bool TPDisk::YardInitForKnownVDisk(TYardInit &evYardInit, TOwner owner) {
     ui64 writeBlockSize = ForsetiOpPieceSizeCached;
     ui64 readBlockSize = ForsetiOpPieceSizeCached;
     ui32 ownerWeight = Cfg->GetOwnerWeight(evYardInit.GroupSizeInUnits);
+    bool isTinyDisk = (Format.DiskSize < NPDisk::TinyDiskSizeThreshold);
+
     THolder<NPDisk::TEvYardInitResult> result(new NPDisk::TEvYardInitResult(NKikimrProto::OK,
                 DriveModel.SeekTimeNs() / 1000ull, DriveModel.Speed(TDriveModel::OP_TYPE_READ),
                 DriveModel.Speed(TDriveModel::OP_TYPE_WRITE), readBlockSize, writeBlockSize,
                 DriveModel.BulkWriteBlockSize(), Format.GetUserAccessibleChunkSize(), Format.GetAppendBlockSize(), owner,
                 ownerRound, ownerWeight, Cfg->SlotSizeInUnits,
                 GetStatusFlags(OwnerSystem, evYardInit.OwnerGroupType), ownedChunks,
-                Cfg->RetrieveDeviceType(), ""));
+                Cfg->RetrieveDeviceType(), isTinyDisk, ""));
+
     GetStartingPoints(owner, result->StartingPoints);
     ownerData.VDiskId = vDiskId;
     ownerData.CutLogId = evYardInit.CutLogId;
@@ -2053,6 +2057,7 @@ void TPDisk::YardInitFinish(TYardInit &evYardInit) {
 
     ui64 writeBlockSize = ForsetiOpPieceSizeCached;
     ui64 readBlockSize = ForsetiOpPieceSizeCached;
+    bool isTinyDisk = (Format.DiskSize < NPDisk::TinyDiskSizeThreshold);
 
     THolder<NPDisk::TEvYardInitResult> result(new NPDisk::TEvYardInitResult(
         NKikimrProto::OK,
@@ -2061,7 +2066,8 @@ void TPDisk::YardInitFinish(TYardInit &evYardInit) {
         DriveModel.BulkWriteBlockSize(), Format.GetUserAccessibleChunkSize(), Format.GetAppendBlockSize(), owner, ownerRound,
         Cfg->GetOwnerWeight(evYardInit.GroupSizeInUnits), Cfg->SlotSizeInUnits,
         GetStatusFlags(OwnerSystem, evYardInit.OwnerGroupType) | ui32(NKikimrBlobStorage::StatusNewOwner), TVector<TChunkIdx>(),
-        Cfg->RetrieveDeviceType(), ""));
+        Cfg->RetrieveDeviceType(), isTinyDisk, ""));
+
     GetStartingPoints(result->PDiskParams->Owner, result->StartingPoints);
     WriteSysLogRestorePoint(new TCompletionEventSender(
         this, evYardInit.Sender, result.Release(), Mon.YardInit.Results), evYardInit.ReqId, {});
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_params.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_params.cpp
@@ -12,7 +12,8 @@ namespace NKikimr {
     TPDiskParams::TPDiskParams(NPDisk::TOwner owner, ui64 ownerRound, ui32 OwnerWeight, ui32 slotSizeInUnits,
                                ui32 chunkSize, ui32 appendBlockSize,
                                ui64 seekTimeUs, ui64 readSpeedBps, ui64 writeSpeedBps, ui64 readBlockSize,
-                               ui64 writeBlockSize, ui64 bulkWriteBlockSize, NPDisk::EDeviceType trueMediaType)
+                               ui64 writeBlockSize, ui64 bulkWriteBlockSize, NPDisk::EDeviceType trueMediaType,
+                               bool isTinyDisk)
         : Owner(owner)
         , OwnerRound(ownerRound)
         , OwnerWeight(OwnerWeight)
@@ -29,6 +30,7 @@ namespace NKikimr {
         , PrefetchSizeBytes(CalculatePrefetchSizeBytes(seekTimeUs, readSpeedBps))
         , GlueRequestDistanceBytes(CalculateGlueRequestDistanceBytes(seekTimeUs, readSpeedBps))
         , TrueMediaType(trueMediaType)
+        , IsTinyDisk(isTinyDisk)
     {
         Y_VERIFY_DEBUG(AppendBlockSize <= ChunkSize);
     }
@@ -74,6 +76,7 @@ namespace NKikimr {
         str << " BulkWriteBlockSize# " << BulkWriteBlockSize;
         str << " PrefetchSizeBytes# " << PrefetchSizeBytes;
         str << " GlueRequestDistanceBytes# " << GlueRequestDistanceBytes;
+        str << " IsTinyDisk# " << IsTinyDisk;
         str << "}";
         return str.Str();
     }
@@ -144,6 +147,10 @@ namespace NKikimr {
                         TABLED() {str << "GlueRequestDistanceBytes";}
                         TABLED() {str << GlueRequestDistanceBytes;}
                     }
+                    TABLER() {
+                        TABLED() {str << "IsTinyDisk";}
+                        TABLED() {str << IsTinyDisk;}
+                    }
                 }
             }
         }
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_params.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_params.h
@@ -31,14 +31,17 @@ namespace NKikimr {
 
         const NPDisk::EDeviceType TrueMediaType;
 
+        bool IsTinyDisk;
+
         static ui32 CalculateRecommendedReadSize(ui64 seekTimeUs, ui64 readSpeedBps, ui64 appendBlockSize);
         static ui64 CalculatePrefetchSizeBytes(ui64 seekTimeUs, ui64 readSpeedBps);
         static ui64 CalculateGlueRequestDistanceBytes(ui64 seekTimeUs, ui64 readSpeedBps);
 
         TPDiskParams(NPDisk::TOwner owner, ui64 ownerRound, ui32 ownerWeight, ui32 slotSizeInUnits,
                      ui32 chunkSize, ui32 appendBlockSize,
                      ui64 seekTimeUs, ui64 readSpeedBps, ui64 writeSpeedBps, ui64 readBlockSize,
-                     ui64 writeBlockSize, ui64 bulkWriteBlockSize, NPDisk::EDeviceType trueMediaType);
+                     ui64 writeBlockSize, ui64 bulkWriteBlockSize, NPDisk::EDeviceType trueMediaType,
+                     bool isTinyDisk);
         void OutputHtml(IOutputStream &str) const;
         TString ToString() const;
     };
diff --git a/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp b/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp
@@ -491,7 +491,7 @@ class TPDiskMockActor : public TActorBootstrapped<TPDiskMockActor> {
             const ui64 bulkWriteBlockSize = 65536;
             res = std::make_unique<NPDisk::TEvYardInitResult>(NKikimrProto::OK, seekTimeUs, readSpeedBps, writeSpeedBps,
                 readBlockSize, writeBlockSize, bulkWriteBlockSize, Impl.ChunkSize, Impl.AppendBlockSize, ownerId,
-                owner->OwnerRound, owner->Weight, 0u, GetStatusFlags(), std::move(ownedChunks), NPDisk::DEVICE_TYPE_NVME, TString());
+                owner->OwnerRound, owner->Weight, 0u, GetStatusFlags(), std::move(ownedChunks), NPDisk::DEVICE_TYPE_NVME, false, TString());
             res->StartingPoints = owner->StartingPoints;
         } else {
             res = std::make_unique<NPDisk::TEvYardInitResult>(NKikimrProto::INVALID_ROUND, "invalid owner round");
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_config.cpp b/ydb/core/blobstorage/vdisk/common/vdisk_config.cpp
@@ -132,6 +132,9 @@ namespace NKikimr {
 
     }
 
+    const ui32 TVDiskConfig::TinyDiskHullCompLevel0MaxSstsAtOnce = 2u;
+    const ui32 TVDiskConfig::TinyDiskHullCompSortedPartsNum = 2u;
+
     void TVDiskConfig::SetupHugeBytes() {
         switch (BaseInfo.DeviceType) {
             case NPDisk::DEVICE_TYPE_SSD:
diff --git a/ydb/core/blobstorage/vdisk/common/vdisk_config.h b/ydb/core/blobstorage/vdisk/common/vdisk_config.h
@@ -134,6 +134,9 @@ namespace NKikimr {
         ui64 AnubisOsirisMaxInFly;
         bool AddHeader;
 
+        static const ui32 TinyDiskHullCompLevel0MaxSstsAtOnce;
+        static const ui32 TinyDiskHullCompSortedPartsNum;
+
         //////////////// LOG CUTTER SETTINGS ////////////////
         TDuration RecoveryLogCutterFirstDuration;
         TDuration RecoveryLogCutterRegularDuration;
diff --git a/ydb/core/blobstorage/vdisk/hulldb/base/blobstorage_hulldefs.cpp b/ydb/core/blobstorage/vdisk/hulldb/base/blobstorage_hulldefs.cpp
@@ -111,7 +111,8 @@ namespace NKikimr {
     THullCtx::THullCtx(TVDiskContextPtr vctx, const TIntrusivePtr<TVDiskConfig> vcfg, ui32 chunkSize, ui32 compWorthReadSize,
             bool freshCompaction, bool gcOnlySynced, bool allowKeepFlags, bool barrierValidation, ui32 hullSstSizeInChunksFresh,
             ui32 hullSstSizeInChunksLevel, double hullCompFreeSpaceThreshold, double hullCompReadBatchEfficiencyThreshold,
-            TDuration hullCompStorageRatioCalcPeriod, TDuration hullCompStorageRatioMaxCalcDuration, bool addHeader)
+            TDuration hullCompStorageRatioCalcPeriod, TDuration hullCompStorageRatioMaxCalcDuration, bool addHeader,
+            ui32 hullCompLevel0MaxSstsAtOnce, ui32 hullCompSortedPartsNum)
         : VCtx(std::move(vctx))
         , VCfg(vcfg)
         , IngressCache(TIngressCache::Create(VCtx->Top, VCtx->ShortSelfVDisk))
@@ -128,6 +129,8 @@ namespace NKikimr {
         , HullCompStorageRatioCalcPeriod(hullCompStorageRatioCalcPeriod)
         , HullCompStorageRatioMaxCalcDuration(hullCompStorageRatioMaxCalcDuration)
         , AddHeader(addHeader)
+        , HullCompLevel0MaxSstsAtOnce(hullCompLevel0MaxSstsAtOnce)
+        , HullCompSortedPartsNum(hullCompSortedPartsNum)
         , CompactionStrategyGroup(VCtx->VDiskCounters, "subsystem", "compstrategy")
         , LsmHullGroup(VCtx->VDiskCounters, "subsystem", "lsmhull")
         , LsmHullSpaceGroup(VCtx->VDiskCounters, "subsystem", "outofspace")
diff --git a/ydb/core/blobstorage/vdisk/hulldb/base/blobstorage_hulldefs.h b/ydb/core/blobstorage/vdisk/hulldb/base/blobstorage_hulldefs.h
@@ -136,6 +136,8 @@ namespace NKikimr {
         const TDuration HullCompStorageRatioCalcPeriod;
         const TDuration HullCompStorageRatioMaxCalcDuration;
         const bool AddHeader;
+        ui32 HullCompLevel0MaxSstsAtOnce;
+        ui32 HullCompSortedPartsNum;
 
         NMonGroup::TCompactionStrategyGroup CompactionStrategyGroup;
         NMonGroup::TLsmHullGroup LsmHullGroup;
@@ -156,7 +158,10 @@ namespace NKikimr {
                 double hullCompReadBatchEfficiencyThreshold,
                 TDuration hullCompStorageRatioCalcPeriod,
                 TDuration hullCompStorageRatioMaxCalcDuration,
-                bool addHeader);
+                bool addHeader,
+                ui32 hullCompLevel0MaxSstsAtOnce,
+                ui32 hullCompSortedPartsNum
+        );
 
         void UpdateSpaceCounters(const NHullComp::TSstRatio& prev, const NHullComp::TSstRatio& current);
     };
@@ -192,4 +197,3 @@ namespace NKikimr {
     };
 
 } // NKikimr
-
diff --git a/ydb/core/blobstorage/vdisk/hulldb/base/hullds_ut.h b/ydb/core/blobstorage/vdisk/hulldb/base/hullds_ut.h
@@ -31,7 +31,9 @@ namespace NKikimr {
                         0.5,
                         TDuration::Minutes(5),
                         TDuration::Seconds(1),
-                        true)) // AddHeader
+                        true,
+                        8u,
+                        8u)) // AddHeader
             , LevelIndexSettings(
                 HullCtx,
                 8u,                         // Level0MaxSstsAtOnce
@@ -156,4 +158,3 @@ namespace NKikimr {
     };
 
 } // NKikimr
-
diff --git a/ydb/core/blobstorage/vdisk/hullop/blobstorage_hullactor.cpp b/ydb/core/blobstorage/vdisk/hullop/blobstorage_hullactor.cpp
@@ -717,8 +717,8 @@ namespace NKikimr {
             , RTCtx(std::move(rtCtx))
             , SyncLogFirstLsnToKeep(std::move(syncLogFirstLsnToKeep))
             , Boundaries(new NHullComp::TBoundaries(RTCtx->PDiskCtx->Dsk->ChunkSize,
-                                                    Config->HullCompLevel0MaxSstsAtOnce,
-                                                    Config->HullCompSortedPartsNum,
+                                                    HullDs->HullCtx->HullCompLevel0MaxSstsAtOnce,
+                                                    HullDs->HullCtx->HullCompSortedPartsNum,
                                                     Config->Level0UseDreg))
             , HullDbCommitterCtx(new THullDbCommitterCtx(RTCtx->PDiskCtx,
                                                     HullDs->HullCtx,
diff --git a/ydb/core/blobstorage/vdisk/hullop/blobstorage_hullcommit.h b/ydb/core/blobstorage/vdisk/hullop/blobstorage_hullcommit.h
@@ -234,6 +234,8 @@ namespace NKikimr {
             LevelIndex->SerializeToProto(*pb.MutableLevelIndex());
             Metadata.RemovedHugeBlobs.SerializeToProto(*pb.MutableRemovedHugeBlobs());
             Metadata.AllocatedHugeBlobs.SerializeToProto(*pb.MutableAllocatedHugeBlobs());
+            pb.SetHullCompLevel0MaxSstsAtOnce(Ctx->HullCtx->HullCompLevel0MaxSstsAtOnce);
+            pb.SetHullCompSortedPartsNum(Ctx->HullCtx->HullCompSortedPartsNum);
             return THullDbSignatureRoutines::Serialize(pb);
         }
 
diff --git a/ydb/core/blobstorage/vdisk/localrecovery/localrecovery_public.cpp b/ydb/core/blobstorage/vdisk/localrecovery/localrecovery_public.cpp
@@ -84,6 +84,7 @@ namespace NKikimr {
         ui64 SyncLogMaxLsnStored = 0;
         NKikimrVDiskData::TScrubEntrypoint ScrubEntrypoint;
         ui64 ScrubEntrypointLsn = 0;
+        bool IsTinyDisk = false;
 
         TActiveActors ActiveActors;
 
@@ -256,30 +257,40 @@ namespace NKikimr {
         bool InitMetabase(const TStartingPoints &startingPoints, TIntrusivePtr<TMetaBase> &metabase,
                           bool &initFlag, NMonitoring::TDeprecatedCounter &counter, bool &emptyDb,
                           ui64 freshBufSize, ui64 compThreshold, const TActorContext &ctx) {
-            TStartingPoints::const_iterator it;
-            // Settings
-            TLevelIndexSettings settings(LocRecCtx->HullCtx,
-                                         Config->HullCompLevel0MaxSstsAtOnce,
-                                         freshBufSize,
-                                         compThreshold,
-                                         Config->FreshHistoryWindow,
-                                         Config->FreshHistoryBuckets,
-                                         Config->FreshUseDreg,
-                                         Config->Level0UseDreg);
+            ui32 hullCompLevel0MaxSstsAtOnce = Config->HullCompLevel0MaxSstsAtOnce;
+            ui32 hullCompSortedPartsNum = Config->HullCompSortedPartsNum;
 
+            TStartingPoints::const_iterator it;
             it = startingPoints.find(signature);
             if (it == startingPoints.end()) {
                 // create an empty DB
                 emptyDb = true;
                 counter = 1;
+
+                if (IsTinyDisk) {
+                    hullCompLevel0MaxSstsAtOnce = TVDiskConfig::TinyDiskHullCompLevel0MaxSstsAtOnce;
+                    hullCompSortedPartsNum = TVDiskConfig::TinyDiskHullCompSortedPartsNum;
+                }
+
+                TLevelIndexSettings settings(LocRecCtx->HullCtx,
+                    hullCompLevel0MaxSstsAtOnce,
+                    freshBufSize,
+                    compThreshold,
+                    Config->FreshHistoryWindow,
+                    Config->FreshHistoryBuckets,
+                    Config->FreshUseDreg,
+                    Config->Level0UseDreg);
+
                 auto mb = MakeIntrusive<TMetaBase>(settings, Arena);
+
                 metabase.Swap(mb);
                 initFlag = true;
                 metabase->LoadCompleted();
             } else {
                 // read existing one
                 emptyDb = false;
                 counter = 0;
+
                 const TRcBuf &data = it->second.Data;
                 TString explanation;
                 NKikimrVDiskData::THullDbEntryPoint pb;
@@ -290,13 +301,34 @@ namespace NKikimr {
                     SignalErrorAndDie(ctx, NKikimrProto::ERROR, explanation);
                     return false;
                 }
+
+                if (pb.HasHullCompLevel0MaxSstsAtOnce()) {
+                    hullCompLevel0MaxSstsAtOnce = pb.GetHullCompLevel0MaxSstsAtOnce();
+                }
+                if (pb.HasHullCompSortedPartsNum()) {
+                    hullCompSortedPartsNum = pb.GetHullCompSortedPartsNum();
+                }
+
+                TLevelIndexSettings settings(LocRecCtx->HullCtx,
+                    hullCompLevel0MaxSstsAtOnce,
+                    freshBufSize,
+                    compThreshold,
+                    Config->FreshHistoryWindow,
+                    Config->FreshHistoryBuckets,
+                    Config->FreshUseDreg,
+                    Config->Level0UseDreg);
+
                 auto mb = MakeIntrusive<TMetaBase>(settings, pb.GetLevelIndex(), it->second.Lsn, Arena);
                 metabase.Swap(mb);
                 initFlag = false;
                 // run reader actor
                 auto aid = ctx.Register(new TLoader(LocRecCtx->VCtx, LocRecCtx->PDiskCtx, metabase.Get(), ctx.SelfID));
                 ActiveActors.Insert(aid, __FILE__, __LINE__, ctx, NKikimrServices::BLOBSTORAGE);
             }
+
+            LocRecCtx->HullCtx->HullCompLevel0MaxSstsAtOnce = hullCompLevel0MaxSstsAtOnce;
+            LocRecCtx->HullCtx->HullCompSortedPartsNum = hullCompSortedPartsNum;
+
             return true;
         }
 
@@ -497,6 +529,7 @@ namespace NKikimr {
             } else {
                 VDiskMonGroup.VDiskLocalRecoveryState() = TDbMon::TDbLocalRecovery::LoadDb;
                 const auto &m = ev->Get();
+                IsTinyDisk = m->PDiskParams->IsTinyDisk;
                 LocRecCtx->PDiskCtx = TPDiskCtx::Create(m->PDiskParams, Config);
 
                 LOG_DEBUG(ctx, NKikimrServices::BS_VDISK_CHUNKS, VDISKP(LocRecCtx->VCtx->VDiskLogPrefix,
@@ -519,7 +552,9 @@ namespace NKikimr {
                         Config->HullCompReadBatchEfficiencyThreshold,
                         Config->HullCompStorageRatioCalcPeriod,
                         Config->HullCompStorageRatioMaxCalcDuration,
-                        Config->AddHeader);
+                        Config->AddHeader,
+                        Config->HullCompLevel0MaxSstsAtOnce,
+                        Config->HullCompSortedPartsNum);
 
                 // create THullDbRecovery, which creates THullDs
                 LocRecCtx->HullDbRecovery = std::make_shared<THullDbRecovery>(hullCtx);
diff --git a/ydb/core/blobstorage/vdisk/repl/blobstorage_hullreplwritesst_ut.cpp b/ydb/core/blobstorage/vdisk/repl/blobstorage_hullreplwritesst_ut.cpp
diff --git a/ydb/core/protos/blobstorage_vdisk_internal.proto b/ydb/core/protos/blobstorage_vdisk_internal.proto

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,8 @@ namespace NKikimr {`
`12`	`12`	`TPDiskParams::TPDiskParams(NPDisk::TOwner owner, ui64 ownerRound, ui32 OwnerWeight, ui32 slotSizeInUnits,`
`13`	`13`	`ui32 chunkSize, ui32 appendBlockSize,`
`14`	`14`	`ui64 seekTimeUs, ui64 readSpeedBps, ui64 writeSpeedBps, ui64 readBlockSize,`
`15`		`- ui64 writeBlockSize, ui64 bulkWriteBlockSize, NPDisk::EDeviceType trueMediaType)`
	`15`	`+ ui64 writeBlockSize, ui64 bulkWriteBlockSize, NPDisk::EDeviceType trueMediaType,`
	`16`	`+ bool isTinyDisk)`
`16`	`17`	`: Owner(owner)`
`17`	`18`	`, OwnerRound(ownerRound)`
`18`	`19`	`, OwnerWeight(OwnerWeight)`
`@@ -29,6 +30,7 @@ namespace NKikimr {`
`29`	`30`	`, PrefetchSizeBytes(CalculatePrefetchSizeBytes(seekTimeUs, readSpeedBps))`
`30`	`31`	`, GlueRequestDistanceBytes(CalculateGlueRequestDistanceBytes(seekTimeUs, readSpeedBps))`
`31`	`32`	`, TrueMediaType(trueMediaType)`
	`33`	`+ , IsTinyDisk(isTinyDisk)`
`32`	`34`	`{`
`33`	`35`	`Y_VERIFY_DEBUG(AppendBlockSize <= ChunkSize);`
`34`	`36`	`}`
`@@ -74,6 +76,7 @@ namespace NKikimr {`
`74`	`76`	`str << " BulkWriteBlockSize# " << BulkWriteBlockSize;`
`75`	`77`	`str << " PrefetchSizeBytes# " << PrefetchSizeBytes;`
`76`	`78`	`str << " GlueRequestDistanceBytes# " << GlueRequestDistanceBytes;`
	`79`	`+ str << " IsTinyDisk# " << IsTinyDisk;`
`77`	`80`	`str << "}";`
`78`	`81`	`return str.Str();`
`79`	`82`	`}`
`@@ -144,6 +147,10 @@ namespace NKikimr {`
`144`	`147`	`TABLED() {str << "GlueRequestDistanceBytes";}`
`145`	`148`	`TABLED() {str << GlueRequestDistanceBytes;}`
`146`	`149`	`}`
	`150`	`+ TABLER() {`
	`151`	`+ TABLED() {str << "IsTinyDisk";}`
	`152`	`+ TABLED() {str << IsTinyDisk;}`
	`153`	`+ }`
`147`	`154`	`}`
`148`	`155`	`}`
`149`	`156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,6 +132,9 @@ namespace NKikimr {`
`132`	`132`
`133`	`133`	`}`
`134`	`134`
	`135`	`+ const ui32 TVDiskConfig::TinyDiskHullCompLevel0MaxSstsAtOnce = 2u;`
	`136`	`+ const ui32 TVDiskConfig::TinyDiskHullCompSortedPartsNum = 2u;`
	`137`	`+`
`135`	`138`	`void TVDiskConfig::SetupHugeBytes() {`
`136`	`139`	`switch (BaseInfo.DeviceType) {`
`137`	`140`	`case NPDisk::DEVICE_TYPE_SSD:`