Skip to content

Commit ed16048

Browse files
Vladilendorooleg
Vladilen
authored and
dorooleg
committed
Refactor CS memory configuration (ydb-platform#22608)
1 parent 0ef6ebd commit ed16048

File tree

14 files changed

+152
-68
lines changed

14 files changed

+152
-68
lines changed

‎ydb/core/base/ut/memory_stats_ut.cpp

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -178,16 +178,12 @@ Y_UNIT_TEST_SUITE (TMemoryStatsAggregator) {
178178
"AnonRss: 36 CGroupLimit: 66 MemTotal: 65 MemAvailable: 85 AllocatedMemory: 156 AllocatorCachesMemory: 186 HardLimit: 145 SoftLimit: 165 TargetUtilization: 185 ExternalConsumption: 194 SharedCacheConsumption: 336 SharedCacheLimit: 366 MemTableConsumption: 396 MemTableLimit: 426 QueryExecutionConsumption: 456 QueryExecutionLimit: 486");
179179
}
180180

181-
Y_UNIT_TEST(ColumnShard_Single) {
181+
Y_UNIT_TEST(Compaction_Single) {
182182
TMemoryStatsAggregator aggregator;
183183

184184
TMemoryStats stats;
185-
stats.SetColumnTablesReadExecutionConsumption(1);
186-
stats.SetColumnTablesReadExecutionLimit(2);
187-
stats.SetColumnTablesCompactionConsumption(3);
188-
stats.SetColumnTablesCompactionLimit(4);
189-
stats.SetColumnTablesCacheConsumption(5);
190-
stats.SetColumnTablesCacheLimit(6);
185+
stats.SetCompactionConsumption(3);
186+
stats.SetCompactionLimit(4);
191187

192188
aggregator.Add(stats, "host");
193189

‎ydb/core/memory_controller/memory_controller.cpp

Lines changed: 12 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -433,7 +433,7 @@ class TMemoryController : public TActorBootstrapped<TMemoryController> {
433433
LOG_INFO_S(ctx, NKikimrServices::MEMORY_CONTROLLER, "Consumer QueryExecution state:" << " Consumption: " << HumanReadableBytes(queryExecutionConsumption) << " Limit: " << HumanReadableBytes(config.QueueLimits[NLocalDb::KqpResourceManagerQueue]));
434434
Counters->GetCounter("Consumer/QueryExecution/Consumption")->Set(queryExecutionConsumption);
435435
Counters->GetCounter("Consumer/QueryExecution/Limit")->Set(config.QueueLimits[NLocalDb::KqpResourceManagerQueue]);
436-
memoryStats.SetQueryExecutionConsumption(queryExecutionConsumption);
436+
memoryStats.SetQueryExecutionConsumption(memoryStats.GetQueryExecutionConsumption() + queryExecutionConsumption);
437437
memoryStats.SetQueryExecutionLimit(config.QueueLimits[NLocalDb::KqpResourceManagerQueue]);
438438

439439
// Note: for now ResourceBroker and its queues aren't MemoryController consumers and don't share limits with other caches
@@ -489,32 +489,28 @@ class TMemoryController : public TActorBootstrapped<TMemoryController> {
489489
break;
490490
}
491491
case EMemoryConsumerKind::SharedCache: {
492-
Y_ASSERT(!stats.HasSharedCacheConsumption());
493492
Y_ASSERT(!stats.HasSharedCacheLimit());
494-
stats.SetSharedCacheConsumption(consumer.Consumption);
493+
stats.SetSharedCacheConsumption(stats.GetSharedCacheConsumption() + consumer.Consumption);
495494
stats.SetSharedCacheLimit(limitBytes);
496495
break;
497496
}
498-
case EMemoryConsumerKind::ColumnTablesScanGroupedMemory:
499-
case EMemoryConsumerKind::ColumnTablesDeduplicationGroupedMemory: {
500-
stats.SetColumnTablesReadExecutionConsumption(stats.GetColumnTablesReadExecutionConsumption() + consumer.Consumption);
501-
stats.SetColumnTablesReadExecutionLimit(stats.GetColumnTablesReadExecutionLimit() + limitBytes);
502-
break;
503-
}
504497
case EMemoryConsumerKind::ColumnTablesCompGroupedMemory: {
505-
// TODO: what about resource broker queues?
506-
Y_ASSERT(!stats.HasColumnTablesCompactionConsumption());
507-
Y_ASSERT(!stats.HasColumnTablesCompactionLimit());
508-
stats.SetColumnTablesCompactionConsumption(consumer.Consumption);
509-
stats.SetColumnTablesCompactionLimit(limitBytes);
498+
Y_ASSERT(!stats.HasCompactionConsumption());
499+
Y_ASSERT(!stats.HasCompactionLimit());
500+
stats.SetCompactionConsumption(consumer.Consumption);
501+
stats.SetCompactionLimit(limitBytes);
510502
break;
511503
}
512504
case EMemoryConsumerKind::ColumnTablesPortionsMetaDataCache:
513505
case EMemoryConsumerKind::ColumnTablesDataAccessorCache:
514506
case EMemoryConsumerKind::ColumnTablesColumnDataCache:
515507
case EMemoryConsumerKind::ColumnTablesBlobCache: {
516-
stats.SetColumnTablesCacheConsumption(stats.GetColumnTablesCacheConsumption() + consumer.Consumption);
517-
stats.SetColumnTablesCacheLimit(stats.GetColumnTablesCacheLimit() + limitBytes);
508+
stats.SetSharedCacheConsumption(stats.GetSharedCacheConsumption() + consumer.Consumption);
509+
break;
510+
}
511+
case EMemoryConsumerKind::ColumnTablesScanGroupedMemory:
512+
case EMemoryConsumerKind::ColumnTablesDeduplicationGroupedMemory: {
513+
stats.SetQueryExecutionConsumption(stats.GetQueryExecutionConsumption() + consumer.Consumption);
518514
break;
519515
}
520516
}

‎ydb/core/memory_controller/memory_controller_config.h

Lines changed: 15 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -84,10 +84,7 @@ GET_MIN_LIMIT(SharedCache)
8484
GET_MAX_LIMIT(SharedCache)
8585

8686
GET_LIMIT(QueryExecutionLimit)
87-
88-
GET_LIMIT(ColumnTablesReadExecutionLimit)
89-
GET_LIMIT(ColumnTablesCompactionLimit)
90-
GET_LIMIT(ColumnTablesCacheLimit)
87+
GET_LIMIT(CompactionLimit)
9188

9289
// ColumnTablesReadExecution memory is split into:
9390
// - ColumnTablesScanGroupedMemory
@@ -100,11 +97,11 @@ static_assert(ColumnTablesReadExecutionFraction + ColumnTablesDeduplicationGroup
10097

10198
inline ui64 GetColumnTablesScanGroupedMemoryLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
10299
return GetFraction(ColumnTablesReadExecutionFraction,
103-
GetColumnTablesReadExecutionLimitBytes(config, hardLimitBytes));
100+
GetQueryExecutionLimitBytes(config, hardLimitBytes));
104101
}
105102
inline ui64 GetColumnTablesDeduplicationGroupedMemoryLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
106103
return GetFraction(ColumnTablesDeduplicationGroupedMemoryFraction,
107-
GetColumnTablesReadExecutionLimitBytes(config, hardLimitBytes));
104+
GetQueryExecutionLimitBytes(config, hardLimitBytes));
108105
}
109106

110107
// ColumnTablesCompaction memory is split into:
@@ -126,27 +123,27 @@ static_assert(ColumnTablesCompactionIndexationQueueFraction
126123
+ ColumnTablesNormalizerQueueFraction == 1);
127124

128125
inline ui64 GetColumnTablesCompGroupedMemoryLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
129-
return GetColumnTablesCompactionLimitBytes(config, hardLimitBytes);
126+
return GetCompactionLimitBytes(config, hardLimitBytes);
130127
}
131128

132129
inline ui64 GetColumnTablesCompactionIndexationQueueLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
133130
return GetFraction(ColumnTablesCompactionIndexationQueueFraction,
134-
GetColumnTablesCompactionLimitBytes(config, hardLimitBytes));
131+
GetCompactionLimitBytes(config, hardLimitBytes));
135132
}
136133

137134
inline ui64 GetColumnTablesTtlQueueLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
138135
return GetFraction(ColumnTablesTtlQueueFraction,
139-
GetColumnTablesCompactionLimitBytes(config, hardLimitBytes));
136+
GetCompactionLimitBytes(config, hardLimitBytes));
140137
}
141138

142139
inline ui64 GetColumnTablesGeneralQueueQueueLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
143140
return GetFraction(ColumnTablesGeneralQueueFraction,
144-
GetColumnTablesCompactionLimitBytes(config, hardLimitBytes));
141+
GetCompactionLimitBytes(config, hardLimitBytes));
145142
}
146143

147144
inline ui64 GetColumnTablesNormalizerQueueLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
148145
return GetFraction(ColumnTablesNormalizerQueueFraction,
149-
GetColumnTablesCompactionLimitBytes(config, hardLimitBytes));
146+
GetCompactionLimitBytes(config, hardLimitBytes));
150147
}
151148

152149
// ColumnTablesCache memory is split into:
@@ -164,23 +161,25 @@ static_assert(ColumnTablesBlobCacheFraction
164161
+ ColumnTablesColumnDataCacheFraction
165162
+ ColumnTablesPortionsMetaDataCacheFraction == 1);
166163

164+
static constexpr float ColumnTablesCachesPercentFromShared = 20.0f;
165+
167166
inline ui64 GetColumnTablesBlobCacheLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
168167
return GetFraction(ColumnTablesBlobCacheFraction,
169-
GetColumnTablesCacheLimitBytes(config, hardLimitBytes));
168+
GetPercent(ColumnTablesCachesPercentFromShared, GetSharedCacheMaxBytes(config, hardLimitBytes)));
170169
}
171170

172171
inline ui64 GetColumnTablesDataAccessorCacheLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
173-
return GetFraction(ColumnTablesDeduplicationGroupedMemoryFraction,
174-
GetColumnTablesCacheLimitBytes(config, hardLimitBytes));
172+
return GetFraction(ColumnTablesColumnTablesDataAccessorCacheFraction,
173+
GetPercent(ColumnTablesCachesPercentFromShared, GetSharedCacheMaxBytes(config, hardLimitBytes)));
175174
}
176175

177176
inline ui64 GetColumnTablesColumnDataCacheLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
178177
return GetFraction(ColumnTablesColumnDataCacheFraction,
179-
GetColumnTablesCacheLimitBytes(config, hardLimitBytes));
178+
GetPercent(ColumnTablesCachesPercentFromShared, GetSharedCacheMaxBytes(config, hardLimitBytes)));
180179
}
181180

182181
inline ui64 GetPortionsMetaDataCacheLimitBytes(const NKikimrConfig::TMemoryControllerConfig& config, const ui64 hardLimitBytes) {
183182
return GetFraction(ColumnTablesPortionsMetaDataCacheFraction,
184-
GetColumnTablesCacheLimitBytes(config, hardLimitBytes));
183+
GetPercent(ColumnTablesCachesPercentFromShared, GetSharedCacheMaxBytes(config, hardLimitBytes)));
185184
}
186185
}

‎ydb/core/memory_controller/memory_controller_ut.cpp

Lines changed: 88 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
#include <ydb/core/tablet_flat/shared_sausagecache.h>
66
#include <ydb/core/tx/datashard/ut_common/datashard_ut_common.h>
77
#include <ydb/core/tx/columnshard/common/limits.h>
8+
#include <ydb/core/tx/columnshard/engines/storage/optimizer/abstract/optimizer.h>
89
#include <ydb/core/tx/limiter/grouped_memory/usage/service.h>
910
#include <ydb/library/actors/testlib/test_runtime.h>
1011

@@ -505,7 +506,7 @@ Y_UNIT_TEST(ResourceBroker_ConfigCS) {
505506

506507
const ui64 compactionMemoryLimitPercent = 36;
507508
auto memoryControllerConfig = serverSettings.AppConfig->MutableMemoryControllerConfig();
508-
memoryControllerConfig->SetColumnTablesCompactionLimitPercent(compactionMemoryLimitPercent);
509+
memoryControllerConfig->SetCompactionLimitPercent(compactionMemoryLimitPercent);
509510

510511
auto server = MakeIntrusive<TWithMemoryControllerServer>(serverSettings);
511512
auto& runtime = *server->GetRuntime();
@@ -553,8 +554,8 @@ Y_UNIT_TEST(GroupedMemoryLimiter_ConfigCS) {
553554
const ui64 compactionMemoryLimitPercent = 36;
554555
const ui64 readExecutionMemoryLimitPercent = 20;
555556
auto memoryControllerConfig = serverSettings.AppConfig->MutableMemoryControllerConfig();
556-
memoryControllerConfig->SetColumnTablesCompactionLimitPercent(compactionMemoryLimitPercent);
557-
memoryControllerConfig->SetColumnTablesReadExecutionLimitPercent(readExecutionMemoryLimitPercent);
557+
memoryControllerConfig->SetCompactionLimitPercent(compactionMemoryLimitPercent);
558+
memoryControllerConfig->SetQueryExecutionLimitPercent(readExecutionMemoryLimitPercent);
558559

559560
ui64 currentHardMemoryLimit = 1000_MB;
560561
auto server = MakeIntrusive<TWithMemoryControllerServer>(serverSettings);
@@ -566,29 +567,47 @@ Y_UNIT_TEST(GroupedMemoryLimiter_ConfigCS) {
566567
auto counters = runtime.GetAppData().Counters;
567568
auto compactionCounters = counters->GetSubgroup("module_id", "grouped_memory_limiter")->GetSubgroup("limiter_name", "Comp_0")->GetSubgroup("stage", "general");
568569
auto scanCounters = counters->GetSubgroup("module_id", "grouped_memory_limiter")->GetSubgroup("limiter_name", "Scan_0")->GetSubgroup("stage", "general");
570+
auto dedupCounters = counters->GetSubgroup("module_id", "grouped_memory_limiter")->GetSubgroup("limiter_name", "Dedu_0")->GetSubgroup("stage", "general");
569571

570572
InitRoot(server, sender);
571573

572574
auto checkMemoryLimits = [&]() {
573575
using OlapLimits = NKikimr::NOlap::TGlobalLimits;
574576
UNIT_ASSERT_DOUBLES_EQUAL(
575577
static_cast<double>(currentHardMemoryLimit * OlapLimits::GroupedMemoryLimiterSoftLimitCoefficient *
576-
(1.0 - ColumnTablesDeduplicationGroupedMemoryFraction) * readExecutionMemoryLimitPercent / 100),
578+
(1.0 - ColumnTablesDeduplicationGroupedMemoryFraction) * readExecutionMemoryLimitPercent / 100 *
579+
NOlap::NGroupedMemoryManager::TScanMemoryLimiterPolicy::HardLimitMultiplier),
577580
static_cast<double>(scanCounters->GetCounter("Value/Limit/Soft/Bytes")->Val()),
578581
1_KB);
579582

580583
UNIT_ASSERT_DOUBLES_EQUAL(
581-
static_cast<double>(currentHardMemoryLimit * (1.0 - ColumnTablesDeduplicationGroupedMemoryFraction) * readExecutionMemoryLimitPercent / 100),
584+
static_cast<double>(currentHardMemoryLimit * (1.0 - ColumnTablesDeduplicationGroupedMemoryFraction) * readExecutionMemoryLimitPercent / 100 *
585+
NOlap::NGroupedMemoryManager::TScanMemoryLimiterPolicy::HardLimitMultiplier),
582586
static_cast<double>(scanCounters->GetCounter("Value/Limit/Hard/Bytes")->Val()),
583587
1_KB);
584588

585589
UNIT_ASSERT_DOUBLES_EQUAL(
586-
static_cast<double>(currentHardMemoryLimit * OlapLimits::GroupedMemoryLimiterSoftLimitCoefficient * compactionMemoryLimitPercent / 100),
590+
static_cast<double>(currentHardMemoryLimit * OlapLimits::GroupedMemoryLimiterSoftLimitCoefficient *
591+
(1.0 - ColumnTablesDeduplicationGroupedMemoryFraction) * readExecutionMemoryLimitPercent / 100 *
592+
NOlap::NGroupedMemoryManager::TDeduplicationMemoryLimiterPolicy::HardLimitMultiplier),
593+
static_cast<double>(dedupCounters->GetCounter("Value/Limit/Soft/Bytes")->Val()),
594+
1_KB);
595+
596+
UNIT_ASSERT_DOUBLES_EQUAL(
597+
static_cast<double>(currentHardMemoryLimit * (1.0 - ColumnTablesDeduplicationGroupedMemoryFraction) * readExecutionMemoryLimitPercent / 100 *
598+
NOlap::NGroupedMemoryManager::TDeduplicationMemoryLimiterPolicy::HardLimitMultiplier),
599+
static_cast<double>(dedupCounters->GetCounter("Value/Limit/Hard/Bytes")->Val()),
600+
1_KB);
601+
602+
UNIT_ASSERT_DOUBLES_EQUAL(
603+
static_cast<double>(currentHardMemoryLimit * OlapLimits::GroupedMemoryLimiterSoftLimitCoefficient * compactionMemoryLimitPercent / 100 *
604+
NOlap::NGroupedMemoryManager::TCompMemoryLimiterPolicy::HardLimitMultiplier),
587605
static_cast<double>(compactionCounters->GetCounter("Value/Limit/Soft/Bytes")->Val()),
588606
1_KB);
589607

590608
UNIT_ASSERT_DOUBLES_EQUAL(
591-
static_cast<double>(currentHardMemoryLimit * compactionMemoryLimitPercent / 100.0),
609+
static_cast<double>(currentHardMemoryLimit * compactionMemoryLimitPercent / 100.0 *
610+
NOlap::NGroupedMemoryManager::TCompMemoryLimiterPolicy::HardLimitMultiplier),
592611
static_cast<double>(compactionCounters->GetCounter("Value/Limit/Hard/Bytes")->Val()),
593612
1_KB);
594613
};
@@ -608,6 +627,68 @@ Y_UNIT_TEST(GroupedMemoryLimiter_ConfigCS) {
608627
runtime.SimulateSleep(TDuration::Seconds(2));
609628
checkMemoryLimits();
610629
}
630+
631+
Y_UNIT_TEST(ColumnShardCaches_Config) {
632+
using namespace NResourceBroker;
633+
634+
TPortManager pm;
635+
TServerSettings serverSettings(pm.GetPort(2134));
636+
serverSettings.SetDomainName("Root").SetUseRealThreads(false);
637+
638+
const ui64 sharedCacheMaxPercent = 50;
639+
auto memoryControllerConfig = serverSettings.AppConfig->MutableMemoryControllerConfig();
640+
memoryControllerConfig->SetSharedCacheMaxPercent(sharedCacheMaxPercent);
641+
642+
ui64 currentHardMemoryLimit = 1000_MB;
643+
auto server = MakeIntrusive<TWithMemoryControllerServer>(serverSettings);
644+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
645+
auto& runtime = *server->GetRuntime();
646+
TAutoPtr<IEventHandle> handle;
647+
auto sender = runtime.AllocateEdgeActor();
648+
649+
InitRoot(server, sender);
650+
auto counters = runtime.GetAppData().Counters;
651+
auto dataAccessorCache = counters->GetSubgroup("module_id", "general_cache")->GetSubgroup("cache_name", "portions_metadata")->GetSubgroup("signals_owner", "manager");
652+
auto columnDataCache = counters->GetSubgroup("module_id", "general_cache")->GetSubgroup("cache_name", "column_data")->GetSubgroup("signals_owner", "manager");
653+
auto blobCache = counters->GetSubgroup("type", "BLOB_CACHE");
654+
655+
auto checkMemoryLimits = [&]() {
656+
UNIT_ASSERT_DOUBLES_EQUAL(
657+
static_cast<double>(currentHardMemoryLimit * ColumnTablesPortionsMetaDataCacheFraction * sharedCacheMaxPercent / 100.0 * ColumnTablesCachesPercentFromShared / 100.0),
658+
static_cast<double>(NKikimr::NOlap::NStorageOptimizer::IOptimizerPlanner::GetPortionsCacheLimit()),
659+
1_KB);
660+
661+
UNIT_ASSERT_DOUBLES_EQUAL(
662+
static_cast<double>(currentHardMemoryLimit * ColumnTablesColumnTablesDataAccessorCacheFraction * sharedCacheMaxPercent / 100.0 * ColumnTablesCachesPercentFromShared / 100.0),
663+
static_cast<double>(dataAccessorCache->GetCounter("Value/Cache/SizeLimit/Bytes")->Val()),
664+
1_KB);
665+
666+
UNIT_ASSERT_DOUBLES_EQUAL(
667+
static_cast<double>(currentHardMemoryLimit * ColumnTablesColumnDataCacheFraction * sharedCacheMaxPercent / 100.0 * ColumnTablesCachesPercentFromShared / 100.0),
668+
static_cast<double>(columnDataCache->GetCounter("Value/Cache/SizeLimit/Bytes")->Val()),
669+
1_KB);
670+
671+
UNIT_ASSERT_DOUBLES_EQUAL(
672+
static_cast<double>(currentHardMemoryLimit * ColumnTablesBlobCacheFraction * sharedCacheMaxPercent / 100.0 * ColumnTablesCachesPercentFromShared / 100.0),
673+
static_cast<double>(blobCache->GetCounter("MaxSizeBytes")->Val()),
674+
1_KB);
675+
};
676+
677+
runtime.SimulateSleep(TDuration::Seconds(2));
678+
checkMemoryLimits();
679+
680+
// Check memory decrease
681+
currentHardMemoryLimit = 500_MB;
682+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
683+
runtime.SimulateSleep(TDuration::Seconds(2));
684+
checkMemoryLimits();
685+
686+
// Check memory increase
687+
currentHardMemoryLimit = 2000_MB;
688+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
689+
runtime.SimulateSleep(TDuration::Seconds(2));
690+
checkMemoryLimits();
691+
}
611692
}
612693

613694
}

‎ydb/core/protos/memory_controller_config.proto

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -26,10 +26,6 @@ message TMemoryControllerConfig {
2626
optional float QueryExecutionLimitPercent = 120 [default = 20];
2727
optional uint64 QueryExecutionLimitBytes = 121;
2828

29-
optional float ColumnTablesReadExecutionLimitPercent = 200 [default = 20];
30-
optional uint64 ColumnTablesReadExecutionLimitBytes = 201;
31-
optional float ColumnTablesCompactionLimitPercent = 202 [default = 20];
32-
optional uint64 ColumnTablesCompactionLimitBytes = 203;
33-
optional float ColumnTablesCacheLimitPercent = 204 [default = 10];
34-
optional uint64 ColumnTablesCacheLimitBytes = 205;
29+
optional float CompactionLimitPercent = 130 [default = 10];
30+
optional uint64 CompactionLimitBytes = 131;
3531
}

‎ydb/core/protos/memory_stats.proto

Lines changed: 2 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -28,11 +28,6 @@ message TMemoryStats {
2828
optional uint64 QueryExecutionConsumption = 18;
2929
optional uint64 QueryExecutionLimit = 19;
3030

31-
optional uint64 ColumnTablesReadExecutionConsumption = 20;
32-
optional uint64 ColumnTablesReadExecutionLimit = 21;
33-
optional uint64 ColumnTablesCompactionConsumption = 22;
34-
optional uint64 ColumnTablesCompactionLimit = 23;
35-
optional uint64 ColumnTablesCacheConsumption = 24;
36-
optional uint64 ColumnTablesCacheLimit = 25;
37-
31+
optional uint64 CompactionConsumption = 22;
32+
optional uint64 CompactionLimit = 23;
3833
}

‎ydb/core/testlib/basics/services.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -186,7 +186,7 @@ namespace NPDisk {
186186
{
187187
runtime.AddLocalService(NBlobCache::MakeBlobCacheServiceId(),
188188
TActorSetupCmd(
189-
NBlobCache::CreateBlobCache(20<<20, runtime.GetDynamicCounters(nodeIndex)),
189+
NBlobCache::CreateBlobCache(std::nullopt, runtime.GetDynamicCounters(nodeIndex)->GetSubgroup("type", "BLOB_CACHE")),
190190
TMailboxType::ReadAsFilled,
191191
0),
192192
nodeIndex);

0 commit comments

Comments
 (0)