Skip to content

Merge to 24-3: Node TNodeLocation processing to NodeWarden in order to reduce CPU consumption (#12776) #17035

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: stable-24-3
Choose a base branch
from
Open

Merge to 24-3: Node TNodeLocation processing to NodeWarden in order to reduce CPU consumption (#12776) #17035

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 1 addition & 19 deletions ydb/core/blobstorage/dsproxy/dsproxy.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -91,24 +91,6 @@ struct TEvLatencyReport : public TEventLocal<TEvLatencyReport, TEvBlobStorage::E
{}
};

struct TNodeLayoutInfo : TThrRefBase {
// indexed by NodeId
TNodeLocation SelfLocation;
TVector<TNodeLocation> LocationPerOrderNumber;

TNodeLayoutInfo(const TNodeLocation& selfLocation, const TIntrusivePtr<TBlobStorageGroupInfo>& info,
std::unordered_map<ui32, TNodeLocation>& map)
: SelfLocation(selfLocation)
, LocationPerOrderNumber(info->GetTotalVDisksNum())
{
for (ui32 i = 0; i < LocationPerOrderNumber.size(); ++i) {
LocationPerOrderNumber[i] = map[info->GetActorId(i).NodeId()];
}
}
};

using TNodeLayoutInfoPtr = TIntrusivePtr<TNodeLayoutInfo>;

inline TStoragePoolCounters::EHandleClass HandleClassToHandleClass(NKikimrBlobStorage::EGetHandleClass handleClass) {
switch (handleClass) {
case NKikimrBlobStorage::FastRead:
Expand Down Expand Up @@ -859,7 +841,7 @@ struct TBlobStorageProxyParameters {
TBlobStorageProxyControlWrappers Controls;
};

IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TNodeLayoutInfoPtr nodeLayoutInfo,
bool forceWaitAllDrives, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters, const TBlobStorageProxyParameters& params);

Expand Down
14 changes: 8 additions & 6 deletions ydb/core/blobstorage/dsproxy/dsproxy_impl.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,9 +4,9 @@ namespace NKikimr {

std::atomic<TMonotonic> TBlobStorageGroupProxy::ThrottlingTimestamp;

TBlobStorageGroupProxy::TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
const TBlobStorageProxyParameters& params)
TBlobStorageGroupProxy::TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
TNodeLayoutInfoPtr nodeLayoutInfo, bool forceWaitAllDrives, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters, const TBlobStorageProxyParameters& params)
: GroupId(info->GroupID)
, Info(std::move(info))
, Topology(Info->PickTopology())
Expand All @@ -15,10 +15,11 @@ namespace NKikimr {
, IsEjected(false)
, ForceWaitAllDrives(forceWaitAllDrives)
, UseActorSystemTimeInBSQueue(params.UseActorSystemTimeInBSQueue)
, NodeLayoutInfo(std::move(nodeLayoutInfo))
, Controls(std::move(params.Controls))
{}

TBlobStorageGroupProxy::TBlobStorageGroupProxy(ui32 groupId, bool isEjected,TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
TBlobStorageGroupProxy::TBlobStorageGroupProxy(ui32 groupId, bool isEjected, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
const TBlobStorageProxyParameters& params)
: GroupId(TGroupId::FromValue(groupId))
, NodeMon(nodeMon)
Expand All @@ -39,11 +40,12 @@ namespace NKikimr {
);
}

IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
IActor* CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
TNodeLayoutInfoPtr nodeLayoutInfo, bool forceWaitAllDrives,
TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
const TBlobStorageProxyParameters& params) {
Y_ABORT_UNLESS(info);
return new TBlobStorageGroupProxy(std::move(info), forceWaitAllDrives, nodeMon,
return new TBlobStorageGroupProxy(std::move(info), std::move(nodeLayoutInfo), forceWaitAllDrives, nodeMon,
std::move(storagePoolCounters), params);
}

Expand Down
14 changes: 6 additions & 8 deletions ydb/core/blobstorage/dsproxy/dsproxy_impl.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -176,7 +176,8 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
std::optional<TCypherKey> CypherKey;

void Handle(TEvBlobStorage::TEvConfigureProxy::TPtr ev);
void ApplyGroupInfo(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TIntrusivePtr<TStoragePoolCounters>&& counters);
void ApplyGroupInfo(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TNodeLayoutInfoPtr nodeLayoutInfo,
TIntrusivePtr<TStoragePoolCounters>&& counters);

void WakeupUnconfigured(TEvConfigureQueryTimeout::TPtr ev);

Expand Down Expand Up @@ -314,17 +315,15 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
return NKikimrServices::TActivity::BS_PROXY_ACTOR;
}

TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, bool forceWaitAllDrives,
TIntrusivePtr<TDsProxyNodeMon> &nodeMon, TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters,
const TBlobStorageProxyParameters& params);
TBlobStorageGroupProxy(TIntrusivePtr<TBlobStorageGroupInfo>&& info, TNodeLayoutInfoPtr nodeLayoutInfo,
bool forceWaitAllDrives, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
TIntrusivePtr<TStoragePoolCounters>&& storagePoolCounters, const TBlobStorageProxyParameters& params);

TBlobStorageGroupProxy(ui32 groupId, bool isEjected, TIntrusivePtr<TDsProxyNodeMon> &nodeMon,
const TBlobStorageProxyParameters& params);
const TBlobStorageProxyParameters& params);

void Bootstrap();

void Handle(TEvInterconnect::TEvNodesInfo::TPtr& ev);

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Configuration process

Expand Down Expand Up @@ -353,7 +352,6 @@ class TBlobStorageGroupProxy : public TActorBootstrapped<TBlobStorageGroupProxy>
hFunc(TEvBlobStorage::TEvBunchOfEvents, Handle);
hFunc(TEvTimeStats, Handle);
cFunc(TEvents::TSystem::Poison, PassAway);
hFunc(TEvInterconnect::TEvNodesInfo, Handle);
hFunc(TEvBlobStorage::TEvConfigureProxy, Handle);
hFunc(TEvProxyQueueState, Handle);
cFunc(EvUpdateResponsiveness, HandleUpdateResponsiveness);
Expand Down
35 changes: 14 additions & 21 deletions ydb/core/blobstorage/dsproxy/dsproxy_state.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -85,21 +85,29 @@ namespace NKikimr {

void TBlobStorageGroupProxy::Handle(TEvBlobStorage::TEvConfigureProxy::TPtr ev) {
auto *msg = ev->Get();
ApplyGroupInfo(std::move(msg->Info), std::move(msg->StoragePoolCounters));
ApplyGroupInfo(std::move(msg->Info), std::move(msg->NodeLayoutInfo), std::move(msg->StoragePoolCounters));
}

void TBlobStorageGroupProxy::ApplyGroupInfo(TIntrusivePtr<TBlobStorageGroupInfo>&& info,
TIntrusivePtr<TStoragePoolCounters>&& counters) {
Info = std::move(info);
TNodeLayoutInfoPtr nodeLayoutInfo, TIntrusivePtr<TStoragePoolCounters>&& counters) {
auto prevInfo = std::exchange(Info, std::move(info));
if (Info) {
if (Topology) {
Y_DEBUG_ABORT_UNLESS(Topology->EqualityCheck(Info->GetTopology()));
} else {
Topology = Info->PickTopology();
}
}
NodeLayoutInfo = nullptr;
Send(MonActor, new TEvBlobStorage::TEvConfigureProxy(Info));
NodeLayoutInfo = std::move(nodeLayoutInfo);
if (counters) {
StoragePoolCounters = std::move(counters);
}

if (prevInfo && Info && prevInfo->GroupGeneration == Info->GroupGeneration) {
return; // group did not actually change
}

Send(MonActor, new TEvBlobStorage::TEvConfigureProxy(Info, nullptr));
if (Info) {
Y_ABORT_UNLESS(!EncryptionMode || *EncryptionMode == Info->GetEncryptionMode());
Y_ABORT_UNLESS(!LifeCyclePhase || *LifeCyclePhase == Info->GetLifeCyclePhase());
Expand All @@ -109,10 +117,6 @@ namespace NKikimr {
LifeCyclePhase = Info->GetLifeCyclePhase();
GroupKeyNonce = Info->GetGroupKeyNonce();
CypherKey = *Info->GetCypherKey();
Send(GetNameserviceActorId(), new TEvInterconnect::TEvListNodes(true));
}
if (counters) {
StoragePoolCounters = std::move(counters);
}
IsLimitedKeyless = false;
if (Info && Info->GetEncryptionMode() != TBlobStorageGroupInfo::EEM_NONE) {
Expand Down Expand Up @@ -240,22 +244,11 @@ namespace NKikimr {
new IEventHandle(SelfId(), SelfId(), new TEvStopBatchingPutRequests));
StopGetBatchingEvent = static_cast<TEventHandle<TEvStopBatchingGetRequests>*>(
new IEventHandle(SelfId(), SelfId(), new TEvStopBatchingGetRequests));
ApplyGroupInfo(std::exchange(Info, {}), std::exchange(StoragePoolCounters, {}));
ApplyGroupInfo(std::exchange(Info, {}), std::exchange(NodeLayoutInfo, {}), std::exchange(StoragePoolCounters, {}));
CheckDeadlines();
}
}

void TBlobStorageGroupProxy::Handle(TEvInterconnect::TEvNodesInfo::TPtr& ev) {
if (Info) {
std::unordered_map<ui32, TNodeLocation> map;
for (auto& info : ev->Get()->Nodes) {
map[info.NodeId] = std::move(info.Location);
}
NodeLayoutInfo = MakeIntrusive<TNodeLayoutInfo>(map[TlsActivationContext->ExecutorThread.ActorSystem->NodeId],
Info, map);
}
}

void TBlobStorageGroupProxy::PassAway() {
for (const auto& [actorId, _] : ActiveRequests) {
TActivationContext::Send(new IEventHandle(TEvents::TSystem::Poison, 0, actorId, {}, nullptr, 0));
Expand Down
2 changes: 1 addition & 1 deletion ydb/core/blobstorage/dsproxy/ut/dsproxy_env_mock_ut.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -81,7 +81,7 @@ struct TDSProxyEnv {
TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), true, nodeMon,
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), nullptr, true, nodeMon,
std::move(storagePoolCounters), TBlobStorageProxyParameters{
.Controls = TBlobStorageProxyControlWrappers{
.EnablePutBatching = enablePutBatching,
Expand Down
2 changes: 1 addition & 1 deletion ydb/core/blobstorage/dsproxy/ut_fat/dsproxy_ut.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4206,7 +4206,7 @@ class TBlobStorageProxyTest: public TTestBase {
TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
TControlWrapper enablePutBatching(args.EnablePutBatching, false, true);
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(bsInfo), false,
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(bsInfo), nullptr, false,
dsProxyNodeMon, TIntrusivePtr(storagePoolCounters),
TBlobStorageProxyParameters{
.Controls = TBlobStorageProxyControlWrappers{
Expand Down
2 changes: 1 addition & 1 deletion ydb/core/blobstorage/dsproxy/ut_ftol/dsproxy_fault_tolerance_ut_runtime.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -87,7 +87,7 @@ class TFaultToleranceTestRuntime {
TIntrusivePtr<TStoragePoolCounters> storagePoolCounters = perPoolCounters.GetPoolCounters("pool_name");
TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(GroupInfo), false, nodeMon,
IActor *dsproxy = CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(GroupInfo), nullptr, false, nodeMon,
std::move(storagePoolCounters), TBlobStorageProxyParameters{
.Controls = TBlobStorageProxyControlWrappers{
.EnablePutBatching = enablePutBatching,
Expand Down
9 changes: 7 additions & 2 deletions ydb/core/blobstorage/nodewarden/node_warden_group.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -188,15 +188,19 @@ namespace NKikimr::NStorage {
// we do not have relevant group configuration, but we know that there is one, so reset the configuration
// for group/proxy and ask BSC for group info
group.Info.Reset();
group.NodeLayoutInfo.Reset();
RequestGroupConfig(groupId, group);
if (group.ProxyId) {
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(nullptr));
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(nullptr, nullptr));
}
} else if (groupChanged) {
// group has changed; obtain main encryption key for this group and try to parse group info from the protobuf
auto& mainKey = GetGroupMainKey(groupId);
TStringStream err;
group.Info = TBlobStorageGroupInfo::Parse(*currentGroup, &mainKey, &err);
if (group.Info->Type.GetErasure() == TBlobStorageGroupType::ErasureMirror3dc) {
group.NodeLayoutInfo = MakeIntrusive<TNodeLayoutInfo>(NodeLocationMap[LocalNodeId], group.Info, NodeLocationMap);
}
Y_ABORT_UNLESS(group.EncryptionParams.HasEncryptionMode());
if (const TString& s = err.Str()) {
STLOG(PRI_ERROR, BS_NODE, NW19, "error while parsing group", (GroupId, groupId), (Err, s));
Expand All @@ -219,7 +223,8 @@ namespace NKikimr::NStorage {

// forward ConfigureProxy anyway, because when we switch to BlobDepot agent, we still need to update
// ds proxy configuration
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(std::move(info), std::move(counters)));
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(std::move(info), group.NodeLayoutInfo,
std::move(counters)));
}

if (const auto& info = group.Info) {
Expand Down
16 changes: 16 additions & 0 deletions ydb/core/blobstorage/nodewarden/node_warden_impl.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -263,6 +263,7 @@ void TNodeWarden::Bootstrap() {
EstablishPipe();

Send(GetNameserviceActorId(), new TEvInterconnect::TEvGetNode(LocalNodeId));
Send(GetNameserviceActorId(), new TEvInterconnect::TEvListNodes(true));

if (Cfg->IsCacheEnabled()) {
TActivationContext::Schedule(TDuration::Seconds(5), new IEventHandle(TEvPrivate::EvReadCache, 0, SelfId(), {}, nullptr, 0));
Expand Down Expand Up @@ -328,6 +329,21 @@ void TNodeWarden::Handle(TEvInterconnect::TEvNodeInfo::TPtr ev) {
}
}

void TNodeWarden::Handle(TEvInterconnect::TEvNodesInfo::TPtr ev) {
NodeLocationMap.clear();
for (const auto& info : ev->Get()->Nodes) {
NodeLocationMap.emplace(info.NodeId, std::move(info.Location));
}
for (auto& [groupId, group] : Groups) {
if (group.Info && group.Info->Type.GetErasure() == TBlobStorageGroupType::ErasureMirror3dc) {
group.NodeLayoutInfo = MakeIntrusive<TNodeLayoutInfo>(NodeLocationMap[LocalNodeId], group.Info, NodeLocationMap);
if (group.ProxyId) {
Send(group.ProxyId, new TEvBlobStorage::TEvConfigureProxy(group.Info, group.NodeLayoutInfo));
}
}
}
}

void TNodeWarden::Handle(NPDisk::TEvSlayResult::TPtr ev) {
const NPDisk::TEvSlayResult &msg = *ev->Get();
const TVSlotId vslotId(LocalNodeId, msg.PDiskId, msg.VSlotId);
Expand Down
4 changes: 4 additions & 0 deletions ydb/core/blobstorage/nodewarden/node_warden_impl.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -470,13 +470,15 @@ namespace NKikimr::NStorage {
bool ProposeRequestPending = false; // if true, then we have sent ProposeKey request and waiting for the group
TActorId GroupResolver; // resolver actor id
TIntrusiveList<TVDiskRecord, TGroupRelationTag> VDisksOfGroup;
TNodeLayoutInfoPtr NodeLayoutInfo;
};

std::unordered_map<ui32, TGroupRecord> Groups;
std::unordered_set<ui32> EjectedGroups;
using TGroupPendingQueue = THashMap<ui32, std::deque<std::tuple<TMonotonic, std::unique_ptr<IEventHandle>>>>;
TGroupPendingQueue GroupPendingQueue;
std::set<std::tuple<TMonotonic, TGroupPendingQueue::value_type*>> TimeoutToQueue;
THashMap<ui32, TNodeLocation> NodeLocationMap;

// this function returns group info if possible, or otherwise starts requesting group info and/or proposing key
// if needed
Expand Down Expand Up @@ -516,6 +518,7 @@ namespace NKikimr::NStorage {
void Bootstrap();
void HandleReadCache();
void Handle(TEvInterconnect::TEvNodeInfo::TPtr ev);
void Handle(TEvInterconnect::TEvNodesInfo::TPtr ev);
void Handle(NPDisk::TEvSlayResult::TPtr ev);
void Handle(TEvRegisterPDiskLoadActor::TPtr ev);
void Handle(TEvBlobStorage::TEvControllerNodeServiceSetUpdate::TPtr ev);
Expand Down Expand Up @@ -626,6 +629,7 @@ namespace NKikimr::NStorage {
hFunc(NIncrHuge::TEvIncrHugeInit, HandleIncrHugeInit);

hFunc(TEvInterconnect::TEvNodeInfo, Handle);
hFunc(TEvInterconnect::TEvNodesInfo, Handle);

hFunc(TEvTabletPipe::TEvClientConnected, Handle);
hFunc(TEvTabletPipe::TEvClientDestroyed, Handle);
Expand Down
8 changes: 4 additions & 4 deletions ydb/core/blobstorage/nodewarden/node_warden_proxy.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -40,8 +40,8 @@ void TNodeWarden::StartLocalProxy(ui32 groupId) {
case NKikimrBlobStorage::TGroupDecommitStatus::IN_PROGRESS:
// create proxy that will be used by blob depot agent to fetch underlying data
proxyActorId = as->Register(CreateBlobStorageGroupProxyConfigured(
TIntrusivePtr<TBlobStorageGroupInfo>(info), false, DsProxyNodeMon, getCounters(info),
TBlobStorageProxyParameters{
TIntrusivePtr<TBlobStorageGroupInfo>(info), group.NodeLayoutInfo, false, DsProxyNodeMon,
getCounters(info), TBlobStorageProxyParameters{
.UseActorSystemTimeInBSQueue = Cfg->UseActorSystemTimeInBSQueue,
.Controls = TBlobStorageProxyControlWrappers{
.EnablePutBatching = EnablePutBatching,
Expand All @@ -63,8 +63,8 @@ void TNodeWarden::StartLocalProxy(ui32 groupId) {
}
} else {
// create proxy with configuration
proxy.reset(CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>(info), false,
DsProxyNodeMon, getCounters(info), TBlobStorageProxyParameters{
proxy.reset(CreateBlobStorageGroupProxyConfigured(TIntrusivePtr<TBlobStorageGroupInfo>(info),
group.NodeLayoutInfo, false, DsProxyNodeMon, getCounters(info), TBlobStorageProxyParameters{
.UseActorSystemTimeInBSQueue = Cfg->UseActorSystemTimeInBSQueue,
.Controls = TBlobStorageProxyControlWrappers{
.EnablePutBatching = EnablePutBatching,
Expand Down
4 changes: 2 additions & 2 deletions ydb/core/blobstorage/ut_group/main.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -331,7 +331,7 @@ class TTestEnv {

// update group info for proxy
runtime.Send(new IEventHandle(MakeBlobStorageProxyID(Info->GroupID), TActorId(),
new TEvBlobStorage::TEvConfigureProxy(Info, StoragePoolCounters)), 1);
new TEvBlobStorage::TEvConfigureProxy(Info, nullptr, StoragePoolCounters)), 1);
}

void Slay(TTestActorSystem& runtime, TDiskRecord& disk) {
Expand Down Expand Up @@ -409,7 +409,7 @@ class TTestEnv {
StoragePoolCounters = MakeIntrusive<TStoragePoolCounters>(proxy, TString(), NPDisk::DEVICE_TYPE_SSD);
TControlWrapper enablePutBatching(DefaultEnablePutBatching, false, true);
TControlWrapper enableVPatch(DefaultEnableVPatch, false, true);
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), false, mon,
std::unique_ptr<IActor> proxyActor{CreateBlobStorageGroupProxyConfigured(TIntrusivePtr(Info), nullptr, false, mon,
TIntrusivePtr(StoragePoolCounters), TBlobStorageProxyParameters{
.Controls = TBlobStorageProxyControlWrappers{
.EnablePutBatching = enablePutBatching,
Expand Down
Loading
Loading