Skip to content

Commit 2b5f88d

Browse files
robdrynkinrobdrynkin
authored
Fix double release repl token + SendOnlyHugeBlobs setting + move settings from consts to config (#9569)
1 parent 1a5bc4d commit 2b5f88d

File tree

11 files changed

+146
-71
lines changed

11 files changed

+146
-71
lines changed

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

+13
Original file line numberDiff line numberDiff line change
@@ -210,6 +210,19 @@ namespace NKikimr::NStorage {
210210
}
211211
}
212212

213+
vdiskConfig->BalancingEnableSend = Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetEnableSend();
214+
vdiskConfig->BalancingEnableDelete = Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetEnableDelete();
215+
vdiskConfig->BalancingBalanceOnlyHugeBlobs = Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetBalanceOnlyHugeBlobs();
216+
vdiskConfig->BalancingJobGranularity = TDuration::MicroSeconds(Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetJobGranularityUs());
217+
vdiskConfig->BalancingBatchSize = Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetBatchSize();
218+
vdiskConfig->BalancingMaxToSendPerEpoch = Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetMaxToSendPerEpoch();
219+
vdiskConfig->BalancingMaxToDeletePerEpoch = Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetMaxToDeletePerEpoch();
220+
vdiskConfig->BalancingReadBatchTimeout = TDuration::MilliSeconds(Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetReadBatchTimeoutMs());
221+
vdiskConfig->BalancingSendBatchTimeout = TDuration::MilliSeconds(Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetSendBatchTimeoutMs());
222+
vdiskConfig->BalancingRequestBlobsOnMainTimeout = TDuration::MilliSeconds(Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetRequestBlobsOnMainTimeoutMs());
223+
vdiskConfig->BalancingDeleteBatchTimeout = TDuration::MilliSeconds(Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetDeleteBatchTimeoutMs());
224+
vdiskConfig->BalancingEpochTimeout = TDuration::MilliSeconds(Cfg->BlobStorageConfig.GetVDiskBalancingConfig().GetEpochTimeoutMs());
225+
213226
// issue initial report to whiteboard before creating actor to avoid races
214227
Send(WhiteboardId, new NNodeWhiteboard::TEvWhiteboard::TEvVDiskStateUpdate(vdiskId, groupInfo->GetStoragePoolName(),
215228
vslotId.PDiskId, vslotId.VDiskSlotId, pdiskGuid, kind, donorMode, whiteboardInstanceGuid, std::move(donors)));

‎ydb/core/blobstorage/ut_blobstorage/balancing.cpp

+6-7
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,12 @@ struct TTestEnv {
3131
.NodeCount = nodeCount,
3232
.VDiskReplPausedAtStart = false,
3333
.Erasure = erasure,
34-
.FeatureFlags = MakeFeatureFlags(),
34+
.ConfigPreprocessor = [](ui32, TNodeWardenConfig& conf) {
35+
auto* balancingConf = conf.BlobStorageConfig.MutableVDiskBalancingConfig();
36+
balancingConf->SetEnableSend(true);
37+
balancingConf->SetEnableDelete(true);
38+
balancingConf->SetBalanceOnlyHugeBlobs(false);
39+
},
3540
})
3641
{
3742
Env.CreateBoxAndPool(1, 1);
@@ -46,12 +51,6 @@ struct TTestEnv {
4651
}
4752
}
4853

49-
static TFeatureFlags MakeFeatureFlags() {
50-
TFeatureFlags res;
51-
res.SetUseVDisksBalancing(true);
52-
return res;
53-
}
54-
5554
static TString PrepareData(const ui32 dataLen, const ui32 start) {
5655
TString data(Reserve(dataLen));
5756
for (ui32 i = 0; i < dataLen; ++i) {

‎ydb/core/blobstorage/vdisk/balance/balancing_actor.cpp

+45-35
Original file line numberDiff line numberDiff line change
@@ -87,6 +87,9 @@ namespace NBalancing {
8787
///////////////////////////////////////////////////////////////////////////////////////////
8888

8989
void ContinueBalancing() {
90+
Ctx->MonGroup.PlannedToSendOnMain() = SendOnMainParts.Data.size();
91+
Ctx->MonGroup.CandidatesToDelete() = TryDeleteParts.Data.size();
92+
9093
if (SendOnMainParts.Empty() && TryDeleteParts.Empty()) {
9194
// no more parts to send or delete
9295
STLOG(PRI_INFO, BS_VDISK_BALANCING, BSVB03, VDISKP(Ctx->VCtx, "Balancing completed"));
@@ -101,8 +104,6 @@ namespace NBalancing {
101104

102105
void ScheduleJobQuant() {
103106
Ctx->MonGroup.ReplTokenAquired()++;
104-
Ctx->MonGroup.PlannedToSendOnMain() = SendOnMainParts.Data.size();
105-
Ctx->MonGroup.CandidatesToDelete() = TryDeleteParts.Data.size();
106107

107108
// once repl token received, start balancing - waking up sender and deleter
108109
STLOG(PRI_INFO, BS_VDISK_BALANCING, BSVB02, VDISKP(Ctx->VCtx, "Schedule job quant"),
@@ -125,57 +126,65 @@ namespace NBalancing {
125126
return;
126127
}
127128

129+
const auto& top = GInfo->GetTopology();
130+
TPartsCollectorMerger merger(top.GType);
128131
THPTimer timer;
129132

130133
for (ui32 cnt = 0; It.Valid(); It.Next(), ++cnt) {
131-
if (cnt % 100 == 99 && TDuration::Seconds(timer.Passed()) > JOB_GRANULARITY) {
134+
if (cnt % 128 == 127 && TDuration::Seconds(timer.Passed()) > Ctx->Cfg.JobGranularity) {
132135
// actor should not block the thread for a long time, so we should yield
133-
// STLOG(PRI_DEBUG, BS_VDISK_BALANCING, BSVB04, VDISKP(Ctx->VCtx, "Collect keys"), (collected, cnt), (passed, timer.Passed()));
136+
STLOG(PRI_DEBUG, BS_VDISK_BALANCING, BSVB04, VDISKP(Ctx->VCtx, "Collect keys"), (collected, cnt), (passed, timer.Passed()));
134137
Send(SelfId(), new NActors::TEvents::TEvWakeup());
135138
return;
136139
}
137140

138-
const auto& top = GInfo->GetTopology();
139141
const auto& key = It.GetCurKey().LogoBlobID();
140142

141-
TPartsCollectorMerger merger(top.GType);
143+
if (Ctx->Cfg.BalanceOnlyHugeBlobs && !Ctx->HugeBlobCtx->IsHugeBlob(GInfo->Type, key, Ctx->MinREALHugeBlobInBytes)) {
144+
// skip non huge blobs
145+
continue;
146+
}
147+
148+
merger.Clear();
142149
It.PutToMerger(&merger);
143150

144151
auto [moveMask, delMask] = merger.Ingress.HandoffParts(&top, Ctx->VCtx->ShortSelfVDisk, key);
145152

146-
if (auto partsToSend = merger.Ingress.LocalParts(top.GType) & moveMask; !partsToSend.Empty() && SendOnMainParts.Size() < MAX_TO_SEND_PER_EPOCH) {
147-
// collect parts to send on main
148-
for (const auto& [parts, data]: merger.Parts) {
149-
if (!(partsToSend & parts).Empty()) {
150-
SendOnMainParts.Data.emplace_back(TPartInfo{
151-
.Key=It.GetCurKey().LogoBlobID(),
152-
.PartsMask=parts,
153-
.PartData=data
154-
});
153+
// collect parts to send on main
154+
if (Ctx->Cfg.EnableSend && SendOnMainParts.Size() < Ctx->Cfg.MaxToSendPerEpoch) {
155+
if (auto partsToSend = merger.Ingress.LocalParts(top.GType) & moveMask; !partsToSend.Empty()) {
156+
for (const auto& [parts, data]: merger.Parts) {
157+
if (!(partsToSend & parts).Empty()) {
158+
SendOnMainParts.Data.emplace_back(TPartInfo{
159+
.Key=It.GetCurKey().LogoBlobID(),
160+
.PartsMask=parts,
161+
.PartData=data
162+
});
163+
}
155164
}
156165
}
157166
}
158167

159-
if (auto partsToDelete = merger.Ingress.LocalParts(top.GType) & delMask; !partsToDelete.Empty() && TryDeleteParts.Size() < MAX_TO_DELETE_PER_EPOCH) {
160-
// collect parts to delete
161-
auto key = It.GetCurKey().LogoBlobID();
162-
for (ui8 partIdx = partsToDelete.FirstPosition(); partIdx < partsToDelete.GetSize(); partIdx = partsToDelete.NextPosition(partIdx)) {
163-
TryDeleteParts.Data.emplace_back(TLogoBlobID(key, partIdx + 1));
164-
STLOG(PRI_DEBUG, BS_VDISK_BALANCING, BSVB10, VDISKP(Ctx->VCtx, "Delete"), (LogoBlobId, TryDeleteParts.Data.back().ToString()));
165-
}
168+
// collect parts to delete
169+
if (Ctx->Cfg.EnableDelete && TryDeleteParts.Size() < Ctx->Cfg.MaxToDeletePerEpoch) {
170+
if (auto partsToDelete = merger.Ingress.LocalParts(top.GType) & delMask; !partsToDelete.Empty()) {
171+
auto key = It.GetCurKey().LogoBlobID();
172+
for (ui8 partIdx = partsToDelete.FirstPosition(); partIdx < partsToDelete.GetSize(); partIdx = partsToDelete.NextPosition(partIdx)) {
173+
TryDeleteParts.Data.emplace_back(TLogoBlobID(key, partIdx + 1));
174+
STLOG(PRI_DEBUG, BS_VDISK_BALANCING, BSVB10, VDISKP(Ctx->VCtx, "Delete"), (LogoBlobId, TryDeleteParts.Data.back().ToString()));
175+
}
166176

167-
for (const auto& [parts, data]: merger.Parts) {
168-
if (!(partsToDelete & parts).Empty()) {
169-
TryDeletePartsFullData[key].emplace_back(TPartInfo{
170-
.Key=key, .PartsMask=parts, .PartData=data
171-
});
177+
for (const auto& [parts, data]: merger.Parts) {
178+
if (!(partsToDelete & parts).Empty()) {
179+
TryDeletePartsFullData[key].emplace_back(TPartInfo{
180+
.Key=key, .PartsMask=parts, .PartData=data
181+
});
182+
}
172183
}
173184
}
174185
}
175186

176-
merger.Clear();
177-
178-
if (SendOnMainParts.Size() >= MAX_TO_SEND_PER_EPOCH && TryDeleteParts.Size() >= MAX_TO_DELETE_PER_EPOCH) {
187+
if (SendOnMainParts.Size() >= Ctx->Cfg.MaxToSendPerEpoch && TryDeleteParts.Size() >= Ctx->Cfg.MaxToDeletePerEpoch) {
179188
// reached the limit of parts to send and delete
180189
break;
181190
}
@@ -192,11 +201,12 @@ namespace NBalancing {
192201
STLOG(PRI_INFO, BS_VDISK_BALANCING, BSVB04, VDISKP(Ctx->VCtx, "TEvCompleted"), (Type, ev->Type));
193202
BatchManager.Handle(ev);
194203

195-
if (StartTime + EPOCH_TIMEOUT < TlsActivationContext->Now()) {
204+
if (StartTime + Ctx->Cfg.EpochTimeout < TlsActivationContext->Now()) {
196205
Ctx->MonGroup.EpochTimeouts()++;
197206
Send(MakeBlobStorageReplBrokerID(), new TEvReleaseReplToken);
198207
STLOG(PRI_INFO, BS_VDISK_BALANCING, BSVB04, VDISKP(Ctx->VCtx, "Epoch timeout"));
199208
PassAway();
209+
return;
200210
}
201211

202212
if (BatchManager.IsBatchCompleted()) {
@@ -242,8 +252,8 @@ namespace NBalancing {
242252

243253
void Handle(NActors::TEvents::TEvUndelivered::TPtr ev) {
244254
if (ev.Get()->Type == TEvReplToken::EventType) {
245-
STLOG(PRI_WARN, BS_VDISK_BALANCING, BSVB06, VDISKP(Ctx->VCtx, "Ask repl token msg not delivered"), (SelfId, SelfId()), (PDiskId, Ctx->VDiskCfg->BaseInfo.PDiskId));
246-
ScheduleJobQuant();
255+
STLOG(PRI_ERROR, BS_VDISK_BALANCING, BSVB06, VDISKP(Ctx->VCtx, "Ask repl token msg not delivered"), (SelfId, SelfId()), (PDiskId, Ctx->VDiskCfg->BaseInfo.PDiskId));
256+
ContinueBalancing();
247257
}
248258
}
249259

@@ -302,8 +312,8 @@ namespace NBalancing {
302312
, Ctx(ctx)
303313
, GInfo(ctx->GInfo)
304314
, It(Ctx->Snap.HullCtx, &Ctx->Snap.LogoBlobsSnap)
305-
, SendOnMainParts(BATCH_SIZE)
306-
, TryDeleteParts(BATCH_SIZE)
315+
, SendOnMainParts(Ctx->Cfg.BatchSize)
316+
, TryDeleteParts(Ctx->Cfg.BatchSize)
307317
, StartTime(TlsActivationContext->Now())
308318
{
309319
}

‎ydb/core/blobstorage/vdisk/balance/defs.h

+23-18
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,27 @@
88

99

1010
namespace NKikimr {
11+
12+
struct TBalancingCfg {
13+
bool EnableSend;
14+
bool EnableDelete;
15+
16+
bool BalanceOnlyHugeBlobs;
17+
TDuration JobGranularity;
18+
19+
ui64 BatchSize;
20+
ui64 MaxToSendPerEpoch;
21+
ui64 MaxToDeletePerEpoch;
22+
23+
TDuration ReadBatchTimeout;
24+
TDuration SendBatchTimeout;
25+
TDuration RequestBlobsOnMainTimeout;
26+
TDuration DeleteBatchTimeout;
27+
TDuration EpochTimeout;
28+
};
29+
1130
struct TBalancingCtx {
31+
const TBalancingCfg Cfg;
1232
TIntrusivePtr<TVDiskContext> VCtx;
1333
TPDiskCtxPtr PDiskCtx;
1434
THugeBlobCtxPtr HugeBlobCtx;
@@ -23,6 +43,7 @@ namespace NKikimr {
2343
ui32 MinREALHugeBlobInBytes;
2444

2545
TBalancingCtx(
46+
const TBalancingCfg& cfg,
2647
TIntrusivePtr<TVDiskContext> vCtx,
2748
TPDiskCtxPtr pDiskCtx,
2849
THugeBlobCtxPtr hugeBlobCtx,
@@ -32,7 +53,8 @@ namespace NKikimr {
3253
TIntrusivePtr<TBlobStorageGroupInfo> gInfo,
3354
ui32 minREALHugeBlobInBytes
3455
)
35-
: VCtx(std::move(vCtx))
56+
: Cfg(cfg)
57+
, VCtx(std::move(vCtx))
3658
, PDiskCtx(std::move(pDiskCtx))
3759
, HugeBlobCtx(std::move(hugeBlobCtx))
3860
, SkeletonId(skeletonId)
@@ -55,28 +77,11 @@ namespace NBalancing {
5577
std::variant<TDiskPart, TRope> PartData;
5678
};
5779

58-
static constexpr ui32 SENDER_ID = 0;
59-
static constexpr ui32 DELETER_ID = 1;
60-
61-
static constexpr TDuration JOB_GRANULARITY = TDuration::MilliSeconds(1);
62-
63-
static constexpr TDuration READ_BATCH_TIMEOUT = TDuration::Seconds(10);
64-
static constexpr TDuration SEND_BATCH_TIMEOUT = TDuration::Seconds(10);
65-
static constexpr TDuration REQUEST_BLOBS_ON_MAIN_BATCH_TIMEOUT = TDuration::Seconds(10);
66-
static constexpr TDuration DELETE_BATCH_TIMEOUT = TDuration::Seconds(10);
67-
6880
static constexpr ui64 READ_TIMEOUT_TAG = 0;
6981
static constexpr ui64 SEND_TIMEOUT_TAG = 1;
7082
static constexpr ui64 REQUEST_TIMEOUT_TAG = 2;
7183
static constexpr ui64 DELETE_TIMEOUT_TAG = 3;
7284

73-
static constexpr ui32 BATCH_SIZE = 32;
74-
75-
static constexpr ui32 MAX_TO_SEND_PER_EPOCH = 1000;
76-
static constexpr ui32 MAX_TO_DELETE_PER_EPOCH = 1000;
77-
static constexpr TDuration EPOCH_TIMEOUT = TDuration::Minutes(1);
78-
79-
8085
struct TEvBalancingSendPartsOnMain : TEventLocal<TEvBalancingSendPartsOnMain, TEvBlobStorage::EvBalancingSendPartsOnMain> {
8186
TEvBalancingSendPartsOnMain(const TVector<TLogoBlobID>& ids)
8287
: Ids(ids)

‎ydb/core/blobstorage/vdisk/balance/deleter.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -186,7 +186,7 @@ namespace {
186186

187187
PartsRequester.SendRequestsToCheckPartsOnMain(SelfId());
188188

189-
Schedule(TDuration::Seconds(15), new NActors::TEvents::TEvWakeup(REQUEST_TIMEOUT_TAG)); // read timeout
189+
Schedule(Ctx->Cfg.RequestBlobsOnMainTimeout, new NActors::TEvents::TEvWakeup(REQUEST_TIMEOUT_TAG)); // read timeout
190190
}
191191

192192
void Handle(TEvBlobStorage::TEvVGetResult::TPtr ev) {
@@ -248,7 +248,7 @@ namespace {
248248

249249
PartsDeleter.DeleteParts(SelfId(), PartsRequester.GetResult());
250250

251-
Schedule(TDuration::Seconds(15), new NActors::TEvents::TEvWakeup(DELETE_TIMEOUT_TAG)); // delete timeout
251+
Schedule(Ctx->Cfg.DeleteBatchTimeout, new NActors::TEvents::TEvWakeup(DELETE_TIMEOUT_TAG)); // delete timeout
252252
}
253253

254254
void HandleDelLogoBlobResult(TEvDelLogoBlobDataSyncLogResult::TPtr ev) {
@@ -269,7 +269,7 @@ namespace {
269269
}
270270

271271
void PassAway() override {
272-
Send(NotifyId, new NActors::TEvents::TEvCompleted(DELETER_ID));
272+
Send(NotifyId, new NActors::TEvents::TEvCompleted());
273273
STLOG(PRI_INFO, BS_VDISK_BALANCING, BSVB32, VDISKP(Ctx->VCtx, "TDeleter::PassAway"));
274274
TActorBootstrapped::PassAway();
275275
}

‎ydb/core/blobstorage/vdisk/balance/sender.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -249,7 +249,7 @@ namespace {
249249
return;
250250
}
251251

252-
Schedule(TDuration::Seconds(15), new NActors::TEvents::TEvWakeup(READ_TIMEOUT_TAG)); // read timeout
252+
Schedule(Ctx->Cfg.ReadBatchTimeout, new NActors::TEvents::TEvWakeup(READ_TIMEOUT_TAG)); // read timeout
253253
}
254254

255255
void Handle(NPDisk::TEvChunkReadResult::TPtr ev) {
@@ -293,7 +293,7 @@ namespace {
293293

294294
Sender.SendPartsOnMain(SelfId(), Reader.GetResult());
295295

296-
Schedule(TDuration::Seconds(15), new NActors::TEvents::TEvWakeup(SEND_TIMEOUT_TAG)); // send timeout
296+
Schedule(Ctx->Cfg.SendBatchTimeout, new NActors::TEvents::TEvWakeup(SEND_TIMEOUT_TAG)); // send timeout
297297
}
298298

299299
template<class TEvPutResult>
@@ -314,7 +314,7 @@ namespace {
314314
}
315315

316316
void PassAway() override {
317-
Send(NotifyId, new NActors::TEvents::TEvCompleted(SENDER_ID));
317+
Send(NotifyId, new NActors::TEvents::TEvCompleted());
318318
STLOG(PRI_INFO, BS_VDISK_BALANCING, BSVB28, VDISKP(Ctx->VCtx, "TSender::PassAway"));
319319
TActorBootstrapped::PassAway();
320320
}

‎ydb/core/blobstorage/vdisk/balance/utils.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -76,8 +76,8 @@ namespace NBalancing {
7676
}
7777

7878
void TPartsCollectorMerger::Clear() {
79+
Ingress = TIngress();
7980
Parts.clear();
80-
Parts.resize(GType.TotalPartCount());
8181
}
8282

8383
} // NBalancing

‎ydb/core/blobstorage/vdisk/common/vdisk_config.h

+14
Original file line numberDiff line numberDiff line change
@@ -221,6 +221,20 @@ namespace NKikimr {
221221
TControlWrapper DefaultHugeGarbagePerMille;
222222
bool UseActorSystemTimeInBSQueue = false;
223223

224+
///////////// BALANCING SETTINGS ////////////////////
225+
bool BalancingEnableSend;
226+
bool BalancingEnableDelete;
227+
TDuration BalancingJobGranularity;
228+
bool BalancingBalanceOnlyHugeBlobs;
229+
ui64 BalancingBatchSize;
230+
ui64 BalancingMaxToSendPerEpoch;
231+
ui64 BalancingMaxToDeletePerEpoch;
232+
TDuration BalancingReadBatchTimeout;
233+
TDuration BalancingSendBatchTimeout;
234+
TDuration BalancingRequestBlobsOnMainTimeout;
235+
TDuration BalancingDeleteBatchTimeout;
236+
TDuration BalancingEpochTimeout;
237+
224238
///////////// COST METRICS SETTINGS ////////////////
225239
bool UseCostTracker = true;
226240
TCostMetricsParametersByMedia CostMetricsParametersByMedia;

‎ydb/core/blobstorage/vdisk/skeleton/blobstorage_skeleton.cpp

+18-3
Original file line numberDiff line numberDiff line change
@@ -1930,7 +1930,7 @@ namespace NKikimr {
19301930

19311931
// create Hull
19321932
Hull = std::make_shared<THull>(Db->LsnMngr, PDiskCtx, Db->SkeletonID,
1933-
Config->FeatureFlags.GetUseVDisksBalancing(), std::move(*ev->Get()->Uncond),
1933+
Config->BalancingEnableDelete, std::move(*ev->Get()->Uncond),
19341934
ctx.ExecutorThread.ActorSystem, Config->BarrierValidation);
19351935
ActiveActors.Insert(Hull->RunHullServices(Config, HullLogCtx, Db->SyncLogFirstLsnToKeep,
19361936
Db->LoggerID, Db->LogCutterID, ctx), ctx, NKikimrServices::BLOBSTORAGE);
@@ -2556,15 +2556,30 @@ namespace NKikimr {
25562556
// don't run balancing for the static group
25572557
return;
25582558
}
2559-
if (!Config->FeatureFlags.GetUseVDisksBalancing() || VCtx->Top->GType.GetErasure() == TErasureType::ErasureMirror3of4) {
2559+
bool balancingEnabled = Config->BalancingEnableSend || Config->BalancingEnableDelete;
2560+
if (!balancingEnabled || VCtx->Top->GType.GetErasure() == TErasureType::ErasureMirror3of4) {
25602561
return;
25612562
}
25622563
if (BalancingId) {
25632564
Send(BalancingId, new NActors::TEvents::TEvPoison());
25642565
ActiveActors.Erase(BalancingId);
25652566
}
2567+
TBalancingCfg balancingCfg{
2568+
.EnableSend=Config->BalancingEnableSend,
2569+
.EnableDelete=Config->BalancingEnableDelete,
2570+
.BalanceOnlyHugeBlobs=Config->BalancingBalanceOnlyHugeBlobs,
2571+
.JobGranularity=Config->BalancingJobGranularity,
2572+
.BatchSize=Config->BalancingBatchSize,
2573+
.MaxToSendPerEpoch=Config->BalancingMaxToSendPerEpoch,
2574+
.MaxToDeletePerEpoch=Config->BalancingMaxToDeletePerEpoch,
2575+
.ReadBatchTimeout=Config->BalancingReadBatchTimeout,
2576+
.SendBatchTimeout=Config->BalancingSendBatchTimeout,
2577+
.RequestBlobsOnMainTimeout=Config->BalancingRequestBlobsOnMainTimeout,
2578+
.DeleteBatchTimeout=Config->BalancingDeleteBatchTimeout,
2579+
.EpochTimeout=Config->BalancingEpochTimeout,
2580+
};
25662581
auto balancingCtx = std::make_shared<TBalancingCtx>(
2567-
VCtx, PDiskCtx, HugeBlobCtx, SelfId(), Hull->GetSnapshot(), Config, GInfo, MinREALHugeBlobInBytes);
2582+
balancingCfg, VCtx, PDiskCtx, HugeBlobCtx, SelfId(), Hull->GetSnapshot(), Config, GInfo, MinREALHugeBlobInBytes);
25682583
BalancingId = ctx.Register(CreateBalancingActor(balancingCtx));
25692584
ActiveActors.Insert(BalancingId, __FILE__, __LINE__, ctx, NKikimrServices::BLOBSTORAGE);
25702585
}

0 commit comments

Comments
 (0)