Skip to content

Commit abfe046

Browse files
VladilenVladilen
committed
Add CS Group Memory Limiter and Blob cache configuration to MemoryController (#19708)
1 parent c43f398 commit abfe046

File tree

12 files changed

+160
-60
lines changed

12 files changed

+160
-60
lines changed

‎ydb/core/driver_lib/run/kikimr_services_initializers.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2858,7 +2858,7 @@ void TKafkaProxyServiceInitializer::InitializeServices(NActors::TActorSystemSetu
28582858
TActorSetupCmd(CreateDiscoveryCache(NGRpcService::KafkaEndpointId),
28592859
TMailboxType::HTSwap, appData->UserPoolId)
28602860
);
2861-
2861+
28622862
setup->LocalServices.emplace_back(
28632863
NKafka::MakeTransactionsServiceID(NodeId),
28642864
TActorSetupCmd(NKafka::CreateTransactionsCoordinator(),

‎ydb/core/memory_controller/memory_controller.cpp

Lines changed: 24 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@
1414
#include <ydb/core/tablet_flat/shared_sausagecache.h>
1515
#include <ydb/core/tablet/resource_broker.h>
1616
#include <ydb/core/tx/columnshard/common/limits.h>
17+
#include <ydb/core/tx/columnshard/blob_cache.h>
1718
#include <ydb/core/tx/limiter/grouped_memory/usage/events.h>
1819
#include <ydb/core/tx/limiter/grouped_memory/usage/service.h>
1920
#include <ydb/library/actors/core/actor_bootstrapped.h>
@@ -288,6 +289,7 @@ class TMemoryController : public TActorBootstrapped<TMemoryController> {
288289

289290
ProcessResourceBrokerConfig(ctx, memoryStats, hardLimitBytes, activitiesLimitBytes);
290291
ProcessGroupedMemoryLimiterConfig(ctx, memoryStats, hardLimitBytes);
292+
ProcessCacheConfig(ctx, memoryStats, hardLimitBytes);
291293

292294
Send(NNodeWhiteboard::MakeNodeWhiteboardServiceId(SelfId().NodeId()), memoryStatsUpdate);
293295

@@ -377,7 +379,7 @@ class TMemoryController : public TActorBootstrapped<TMemoryController> {
377379
void ProcessGroupedMemoryLimiterConfig(const TActorContext& /*ctx*/, NKikimrMemory::TMemoryStats& /*memoryStats*/, ui64 hardLimitBytes) {
378380
ui64 columnTablesScanLimitBytes = GetColumnTablesReadExecutionLimitBytes(Config, hardLimitBytes);
379381
ui64 columnTablesCompactionLimitBytes = GetColumnTablesCompactionLimitBytes(Config, hardLimitBytes) *
380-
NKikimr::NOlap::TGlobalLimits::GroupedMemoryLimiterCompactionLimitCoefficient;
382+
NKikimr::NOlap::TGlobalLimits::GroupedMemoryLimiterCompactionLimitCoefficient;
381383

382384
ApplyGroupedMemoryLimiterConfig(columnTablesScanLimitBytes, columnTablesCompactionLimitBytes);
383385
}
@@ -387,12 +389,25 @@ class TMemoryController : public TActorBootstrapped<TMemoryController> {
387389
using UpdateMemoryLimitsEv = NGroupedMemoryManager::NEvents::TEvExternal::TEvUpdateMemoryLimits;
388390

389391
Send(NGroupedMemoryManager::TScanMemoryLimiterOperator::MakeServiceId(SelfId().NodeId()),
390-
new UpdateMemoryLimitsEv(scanHardLimitBytes * NKikimr::NOlap::TGlobalLimits::GroupedMemoryLimiterSoftLimitCoefficient,
391-
scanHardLimitBytes));
392+
new UpdateMemoryLimitsEv(scanHardLimitBytes * NKikimr::NOlap::TGlobalLimits::GroupedMemoryLimiterSoftLimitCoefficient,
393+
scanHardLimitBytes));
392394

393395
Send(NGroupedMemoryManager::TCompMemoryLimiterOperator::MakeServiceId(SelfId().NodeId()),
394-
new UpdateMemoryLimitsEv(compactionHardLimitBytes * NKikimr::NOlap::TGlobalLimits::GroupedMemoryLimiterSoftLimitCoefficient,
395-
compactionHardLimitBytes));
396+
new UpdateMemoryLimitsEv(compactionHardLimitBytes * NKikimr::NOlap::TGlobalLimits::GroupedMemoryLimiterSoftLimitCoefficient,
397+
compactionHardLimitBytes));
398+
}
399+
400+
void ProcessCacheConfig(const TActorContext& /*ctx*/, NKikimrMemory::TMemoryStats& /*memoryStats*/, ui64 hardLimitBytes) {
401+
ui64 columnTablesBlobCacheLimitBytes = GetColumnTablesCacheLimitBytes(Config, hardLimitBytes);
402+
403+
ApplyCacheConfig(columnTablesBlobCacheLimitBytes);
404+
}
405+
406+
void ApplyCacheConfig(const ui64 cacheLimitBytes) {
407+
namespace NBlobCache = ::NKikimr::NBlobCache;
408+
using UpdateMaxCacheDataSizeEv = NBlobCache::TEvBlobCache::TEvUpdateMaxCacheDataSize;
409+
410+
Send(NBlobCache::MakeBlobCacheServiceId(), new UpdateMaxCacheDataSizeEv(cacheLimitBytes * NKikimr::NOlap::TGlobalLimits::BlobCacheCoefficient));
396411
}
397412

398413
void ProcessResourceBrokerConfig(const TActorContext& ctx, NKikimrMemory::TMemoryStats& memoryStats, ui64 hardLimitBytes,
@@ -416,14 +431,6 @@ class TMemoryController : public TActorBootstrapped<TMemoryController> {
416431
.ColumnTablesCompactionLimitBytes = columnTablesCompactionLimitBytes});
417432
}
418433

419-
void SetConsumerCounters(const TActorContext& ctx, const TString& name, const ui64 consumption, const ui64 limit) {
420-
LOG_INFO_S(ctx, NKikimrServices::MEMORY_CONTROLLER,
421-
"Consumer " << name << " state:"
422-
<< " Consumption: " << HumanReadableBytes(consumption) << " Limit: " << HumanReadableBytes(limit));
423-
Counters->GetCounter(TStringBuilder() << "Consumer/" << name << "/Consumption")->Set(consumption);
424-
Counters->GetCounter(TStringBuilder() << "Consumer/" << name << "/Limit")->Set(limit);
425-
}
426-
427434
void ApplyResourceBrokerConfig(TResourceBrokerConfig config) {
428435
if (config == CurrentResourceBrokerConfig) {
429436
return;
@@ -438,13 +445,13 @@ class TMemoryController : public TActorBootstrapped<TMemoryController> {
438445
// Compaction uses 4 queues, but there is only one memory limit setting in the configuration,
439446
// so the coefficients are used to split allocated memory between the queues.
440447
AddLimitToQueueConfig(record, NLocalDb::KqpResourceManagerQueue, config.QueryExecutionLimitBytes);
441-
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionIndexationQueue,
448+
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionIndexationQueue,
442449
config.ColumnTablesCompactionLimitBytes * NKikimr::NOlap::TGlobalLimits::CompactionIndexationQueueLimitCoefficient);
443-
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionTtlQueue,
450+
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionTtlQueue,
444451
config.ColumnTablesCompactionLimitBytes * NKikimr::NOlap::TGlobalLimits::CompactionTtlQueueLimitCoefficient);
445-
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionGeneralQueue,
452+
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionGeneralQueue,
446453
config.ColumnTablesCompactionLimitBytes * NKikimr::NOlap::TGlobalLimits::CompactionGeneralQueueLimitCoefficient);
447-
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionNormalizerQueue,
454+
AddLimitToQueueConfig(record, NLocalDb::ColumnShardCompactionNormalizerQueue,
448455
config.ColumnTablesCompactionLimitBytes * NKikimr::NOlap::TGlobalLimits::CompactionNormalizerQueueLimitCoefficient);
449456

450457
Send(MakeResourceBrokerID(), configure.Release());

‎ydb/core/memory_controller/memory_controller_ut.cpp

Lines changed: 74 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@
33
#include <ydb/core/tablet/resource_broker.h>
44
#include <ydb/core/tablet_flat/shared_sausagecache.h>
55
#include <ydb/core/tx/datashard/ut_common/datashard_ut_common.h>
6+
#include <ydb/core/tx/columnshard/common/limits.h>
7+
#include <ydb/core/tx/limiter/grouped_memory/usage/service.h>
68
#include <ydb/library/actors/testlib/test_runtime.h>
79

810
namespace NKikimr::NMemory {
@@ -502,11 +504,13 @@ Y_UNIT_TEST(ResourceBroker_ConfigCS) {
502504
TServerSettings serverSettings(pm.GetPort(2134));
503505
serverSettings.SetDomainName("Root").SetUseRealThreads(false);
504506

507+
const ui64 compactionMemoryLimitPercent = 36;
505508
auto memoryControllerConfig = serverSettings.AppConfig->MutableMemoryControllerConfig();
506-
memoryControllerConfig->SetColumnTablesCompactionLimitPercent(32);
509+
memoryControllerConfig->SetColumnTablesCompactionLimitPercent(compactionMemoryLimitPercent);
507510

511+
ui64 currentHardMemoryLimit = 1000_MB;
508512
auto resourceBrokerConfig = serverSettings.AppConfig->MutableResourceBrokerConfig();
509-
resourceBrokerConfig->MutableResourceLimit()->SetMemory(1000_MB);
513+
resourceBrokerConfig->MutableResourceLimit()->SetMemory(currentHardMemoryLimit);
510514

511515
auto addQueueWithMemoryLimit = [&](const TString& name, const ui64 memoryLimit) {
512516
auto queue = resourceBrokerConfig->AddQueues();
@@ -520,7 +524,7 @@ Y_UNIT_TEST(ResourceBroker_ConfigCS) {
520524
addQueueWithMemoryLimit(NLocalDb::ColumnShardCompactionNormalizerQueue, 1_MB);
521525

522526
auto server = MakeIntrusive<TWithMemoryControllerServer>(serverSettings);
523-
server->ProcessMemoryInfo->CGroupLimit = 1000_MB;
527+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
524528
auto& runtime = *server->GetRuntime();
525529
TAutoPtr<IEventHandle> handle;
526530
auto sender = runtime.AllocateEdgeActor();
@@ -529,25 +533,81 @@ Y_UNIT_TEST(ResourceBroker_ConfigCS) {
529533

530534
runtime.SimulateSleep(TDuration::Seconds(2));
531535

532-
auto checkMemoryLimit = [&](const TString& queueName, const ui64 expectedLimit) {
536+
auto checkMemoryLimit = [&](const TString& queueName, const double coeff) {
533537
runtime.Send(new IEventHandle(MakeResourceBrokerID(), sender, new TEvResourceBroker::TEvConfigRequest(queueName)));
534538
auto config = runtime.GrabEdgeEvent<TEvResourceBroker::TEvConfigResponse>(handle);
535-
UNIT_ASSERT_VALUES_EQUAL(config->QueueConfig->GetLimit().GetMemory(), expectedLimit);
539+
UNIT_ASSERT_VALUES_EQUAL(config->QueueConfig->GetLimit().GetMemory(),
540+
static_cast<ui64>(currentHardMemoryLimit * coeff * compactionMemoryLimitPercent / 100));
536541
};
537542

538-
checkMemoryLimit(NLocalDb::ColumnShardCompactionIndexationQueue, 40_MB);
539-
checkMemoryLimit(NLocalDb::ColumnShardCompactionTtlQueue, 40_MB);
540-
checkMemoryLimit(NLocalDb::ColumnShardCompactionGeneralQueue, 120_MB);
541-
checkMemoryLimit(NLocalDb::ColumnShardCompactionNormalizerQueue, 120_MB);
543+
using OlapLimits = NKikimr::NOlap::TGlobalLimits;
544+
checkMemoryLimit(NLocalDb::ColumnShardCompactionIndexationQueue, OlapLimits::CompactionIndexationQueueLimitCoefficient);
545+
checkMemoryLimit(NLocalDb::ColumnShardCompactionTtlQueue, OlapLimits::CompactionTtlQueueLimitCoefficient);
546+
checkMemoryLimit(NLocalDb::ColumnShardCompactionGeneralQueue, OlapLimits::CompactionGeneralQueueLimitCoefficient);
547+
checkMemoryLimit(NLocalDb::ColumnShardCompactionNormalizerQueue, OlapLimits::CompactionNormalizerQueueLimitCoefficient);
542548

543549
// Check memory change
544-
server->ProcessMemoryInfo->CGroupLimit = 50_MB;
550+
currentHardMemoryLimit = 100_MB;
551+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
552+
runtime.SimulateSleep(TDuration::Seconds(2));
553+
554+
checkMemoryLimit(NLocalDb::ColumnShardCompactionIndexationQueue, OlapLimits::CompactionIndexationQueueLimitCoefficient);
555+
checkMemoryLimit(NLocalDb::ColumnShardCompactionTtlQueue, OlapLimits::CompactionTtlQueueLimitCoefficient);
556+
checkMemoryLimit(NLocalDb::ColumnShardCompactionGeneralQueue, OlapLimits::CompactionGeneralQueueLimitCoefficient);
557+
checkMemoryLimit(NLocalDb::ColumnShardCompactionNormalizerQueue, OlapLimits::CompactionNormalizerQueueLimitCoefficient);
558+
}
559+
560+
Y_UNIT_TEST(GroupedMemoryLimiter_ConfigCS) {
561+
using namespace NResourceBroker;
562+
563+
TPortManager pm;
564+
TServerSettings serverSettings(pm.GetPort(2134));
565+
serverSettings.SetDomainName("Root").SetUseRealThreads(false);
566+
567+
const ui64 compactionMemoryLimitPercent = 36;
568+
const ui64 readExecutionMemoryLimitPercent = 20;
569+
auto memoryControllerConfig = serverSettings.AppConfig->MutableMemoryControllerConfig();
570+
memoryControllerConfig->SetColumnTablesCompactionLimitPercent(compactionMemoryLimitPercent);
571+
memoryControllerConfig->SetColumnTablesReadExecutionLimitPercent(readExecutionMemoryLimitPercent);
572+
573+
ui64 currentHardMemoryLimit = 1000_MB;
574+
auto server = MakeIntrusive<TWithMemoryControllerServer>(serverSettings);
575+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
576+
auto& runtime = *server->GetRuntime();
577+
TAutoPtr<IEventHandle> handle;
578+
auto sender = runtime.AllocateEdgeActor();
579+
580+
auto scanLimits = NKikimr::NOlap::NGroupedMemoryManager::TScanMemoryLimiterOperator::GetDefaultStageFeatures();
581+
auto compactionLimits = NKikimr::NOlap::NGroupedMemoryManager::TCompMemoryLimiterOperator::GetDefaultStageFeatures();
582+
583+
InitRoot(server, sender);
584+
585+
auto checkMemoryLimits = [&]() {
586+
using OlapLimits = NKikimr::NOlap::TGlobalLimits;
587+
UNIT_ASSERT_VALUES_EQUAL(static_cast<ui64>(currentHardMemoryLimit * OlapLimits::GroupedMemoryLimiterSoftLimitCoefficient * readExecutionMemoryLimitPercent / 100),
588+
scanLimits->GetLimit());
589+
UNIT_ASSERT_VALUES_EQUAL(currentHardMemoryLimit * readExecutionMemoryLimitPercent / 100, scanLimits->GetHardLimit());
590+
591+
UNIT_ASSERT_VALUES_EQUAL(static_cast<ui64>(currentHardMemoryLimit * OlapLimits::GroupedMemoryLimiterCompactionLimitCoefficient * OlapLimits::GroupedMemoryLimiterSoftLimitCoefficient * compactionMemoryLimitPercent / 100),
592+
compactionLimits->GetLimit());
593+
UNIT_ASSERT_VALUES_EQUAL(static_cast<ui64>(currentHardMemoryLimit * OlapLimits::GroupedMemoryLimiterCompactionLimitCoefficient * compactionMemoryLimitPercent / 100),
594+
compactionLimits->GetHardLimit());
595+
};
596+
545597
runtime.SimulateSleep(TDuration::Seconds(2));
598+
checkMemoryLimits();
546599

547-
checkMemoryLimit(NLocalDb::ColumnShardCompactionIndexationQueue, 2_MB);
548-
checkMemoryLimit(NLocalDb::ColumnShardCompactionTtlQueue, 2_MB);
549-
checkMemoryLimit(NLocalDb::ColumnShardCompactionGeneralQueue, 6_MB);
550-
checkMemoryLimit(NLocalDb::ColumnShardCompactionNormalizerQueue, 6_MB);
600+
// Check memory decrease
601+
currentHardMemoryLimit = 500_MB;
602+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
603+
runtime.SimulateSleep(TDuration::Seconds(2));
604+
checkMemoryLimits();
605+
606+
// Check memory increase
607+
currentHardMemoryLimit = 2000_MB;
608+
server->ProcessMemoryInfo->CGroupLimit = currentHardMemoryLimit;
609+
runtime.SimulateSleep(TDuration::Seconds(2));
610+
checkMemoryLimits();
551611
}
552612
}
553613

‎ydb/core/protos/memory_controller_config.proto

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

29-
optional float ColumnTablesReadExecutionLimitPercent = 200 [default = 20]; // 20 / 6
29+
optional float ColumnTablesReadExecutionLimitPercent = 200 [default = 20];
3030
optional uint64 ColumnTablesReadExecutionLimitBytes = 201;
31-
optional float ColumnTablesCompactionLimitPercent = 202 [default = 36]; // 20/6% for memory limiter
31+
optional float ColumnTablesCompactionLimitPercent = 202 [default = 36];
3232
optional uint64 ColumnTablesCompactionLimitBytes = 203;
3333
optional float ColumnTablesCacheLimitPercent = 204 [default = 4];
3434
optional uint64 ColumnTablesCacheLimitBytes = 205;

‎ydb/core/testlib/test_client.cpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -445,8 +445,10 @@ namespace Tests {
445445
const auto nodeCount = StaticNodes() + DynamicNodes();
446446

447447
if (Settings->AuditLogBackendLines) {
448-
Runtime = MakeHolder<TTestBasicRuntime>(nodeCount, Settings->DataCenterCount ? *Settings->DataCenterCount : nodeCount,
449-
Settings->UseRealThreads, CreateTestAuditLogBackends(*Settings->AuditLogBackendLines));
448+
Runtime = MakeHolder<TTestBasicRuntime>(nodeCount,
449+
Settings->DataCenterCount ? *Settings->DataCenterCount : nodeCount,
450+
Settings->UseRealThreads,
451+
CreateTestAuditLogBackends(*Settings->AuditLogBackendLines));
450452
} else {
451453
Runtime = MakeHolder<TTestBasicRuntime>(nodeCount,
452454
Settings->DataCenterCount ? *Settings->DataCenterCount : nodeCount,
@@ -686,7 +688,7 @@ namespace Tests {
686688
if (const auto& domain = appData.DomainsInfo->Domain) {
687689
rootDomains.emplace_back("/" + domain->Name);
688690
}
689-
desc->ServedDatabases.insert(desc->ServedDatabases.end(), rootDomains.begin(), rootDomains.end());
691+
desc->ServedDatabases.insert(desc->ServedDatabases.end(), rootDomains.begin(), rootDomains.end());
690692
} else {
691693
desc->ServedDatabases.emplace_back(CanonizePath(*tenant));
692694
}
@@ -1169,11 +1171,9 @@ namespace Tests {
11691171
Runtime->RegisterService(NOlap::NGroupedMemoryManager::TScanMemoryLimiterOperator::MakeServiceId(Runtime->GetNodeId(nodeIdx)), aid, nodeIdx);
11701172
}
11711173
{
1172-
auto* actor = NOlap::NGroupedMemoryManager::TCompMemoryLimiterOperator::CreateService(NOlap::NGroupedMemoryManager::TConfig(),
1173-
new ::NMonitoring::TDynamicCounters());
1174+
auto* actor = NOlap::NGroupedMemoryManager::TCompMemoryLimiterOperator::CreateService(NOlap::NGroupedMemoryManager::TConfig(), new ::NMonitoring::TDynamicCounters());
11741175
const auto aid = Runtime->Register(actor, nodeIdx, appData.UserPoolId, TMailboxType::Revolving, 0);
1175-
Runtime->RegisterService(NOlap::NGroupedMemoryManager::TCompMemoryLimiterOperator::MakeServiceId(Runtime->GetNodeId(nodeIdx)), aid,
1176-
nodeIdx);
1176+
Runtime->RegisterService(NOlap::NGroupedMemoryManager::TCompMemoryLimiterOperator::MakeServiceId(Runtime->GetNodeId(nodeIdx)), aid, nodeIdx);
11771177
}
11781178
{
11791179
auto* actor = NPrioritiesQueue::TCompServiceOperator::CreateService(NPrioritiesQueue::TConfig(), new ::NMonitoring::TDynamicCounters());
@@ -1459,7 +1459,7 @@ namespace Tests {
14591459
IActor* discoveryCache = CreateDiscoveryCache(NGRpcService::KafkaEndpointId);
14601460
TActorId discoveryCacheId = Runtime->Register(discoveryCache, nodeIdx, userPoolId);
14611461
Runtime->RegisterService(NKafka::MakeKafkaDiscoveryCacheID(), discoveryCacheId, nodeIdx);
1462-
1462+
14631463
TActorId kafkaTxnCoordinatorActorId = Runtime->Register(NKafka::CreateTransactionsCoordinator(), nodeIdx, userPoolId);
14641464
Runtime->RegisterService(NKafka::MakeTransactionsServiceID(Runtime->GetNodeId(nodeIdx)), kafkaTxnCoordinatorActorId, nodeIdx);
14651465

‎ydb/core/tx/columnshard/blob_cache.cpp

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -191,6 +191,7 @@ class TBlobCache: public TActorBootstrapped<TBlobCache> {
191191
HFunc(TEvBlobCache::TEvReadBlobRangeBatch, Handle);
192192
HFunc(TEvBlobCache::TEvCacheBlobRange, Handle);
193193
HFunc(TEvBlobCache::TEvForgetBlob, Handle);
194+
HFunc(TEvBlobCache::TEvUpdateMaxCacheDataSize, Handle);
194195
HFunc(TEvBlobStorage::TEvGetResult, Handle);
195196
HFunc(TEvTabletPipe::TEvClientConnected, Handle);
196197
HFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
@@ -333,6 +334,17 @@ class TBlobCache: public TActorBootstrapped<TBlobCache> {
333334
CachedRanges.erase(begin, end);
334335
}
335336

337+
void Handle(TEvBlobCache::TEvUpdateMaxCacheDataSize::TPtr& ev, const TActorContext&) {
338+
const i64 newMaxCacheDataSize = ev->Get()->MaxCacheDataSize;
339+
if (newMaxCacheDataSize == (i64)MaxCacheDataSize) {
340+
return;
341+
}
342+
343+
LOG_S_INFO("Update max cache data size: " << newMaxCacheDataSize);
344+
345+
MaxCacheDataSize = newMaxCacheDataSize;
346+
}
347+
336348
void SendBatchReadRequestToDS(const std::vector<TBlobRange>& blobRanges, const ui64 cookie,
337349
ui32 dsGroup, TReadItem::EReadVariant readVariant, const TActorContext& ctx)
338350
{

‎ydb/core/tx/columnshard/blob_cache.h

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,7 @@ struct TEvBlobCache {
3939
EvReadBlobRangeResult,
4040
EvCacheBlobRange,
4141
EvForgetBlob,
42+
EvUpdateMemoryLimit,
4243

4344
EvEnd
4445
};
@@ -108,6 +109,14 @@ struct TEvBlobCache {
108109
: BlobId(blobId)
109110
{}
110111
};
112+
113+
struct TEvUpdateMaxCacheDataSize: public NActors::TEventLocal<TEvUpdateMaxCacheDataSize, EvUpdateMemoryLimit> {
114+
i64 MaxCacheDataSize = 0;
115+
116+
explicit TEvUpdateMaxCacheDataSize(const i64 maxCacheDataSize)
117+
: MaxCacheDataSize(maxCacheDataSize) {
118+
}
119+
};
111120
};
112121

113122
inline

0 commit comments

Comments
 (0)