diff --git a/13174/flame-after.svg b/13174/flame-after.svg new file mode 100644 index 0000000..71ee8a0 --- /dev/null +++ b/13174/flame-after.svg @@ -0,0 +1,7890 @@ + + + + + + + + + + + + + + +Flame Graph + +Reset Zoom +Search +ic + + + +[[kernel.kallsyms]] (623,859,626 samples, 0.09%) + + + +NActors::TExecutorPoolBaseMailboxed::Send (377,445,364 samples, 0.05%) + + + +[[kernel.kallsyms]] (3,181,938,543 samples, 0.46%) + + + +NKikimr::NMetrics::TResourceMetricsSendState::TryUpdate (84,575,296 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TCell, std::__y1::allocator<NKikimr::TCell> >::__append_uninitialized (696,887,778 samples, 0.10%) + + + +[[kernel.kallsyms]] (1,014,102,337 samples, 0.15%) + + + +[ydbd] (80,654,405 samples, 0.01%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpSessionActor::ReplySuccess (159,867,719 samples, 0.02%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::FillSendingBuffer (537,497,796 samples, 0.08%) + + + +NActors::TReceiveContext::TPerChannelContext::TPendingEvent::~TPendingEvent (83,254,790 samples, 0.01%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +__GI___readv (1,097,778,758 samples, 0.16%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +[[kernel.kallsyms]] (963,214,665 samples, 0.14%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (132,630,881 samples, 0.02%) + + + +NKikimr::NMiniKQL::TNoopKeySampler::AddSample (297,617,950 samples, 0.04%) + + + +XXH_INLINE_XXH3_64bits_update (172,356,903 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (1,146,659,715 samples, 0.16%) + + + +NActors::TActivationContext::Send< (175,726,548 samples, 0.03%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::StateFuncWrapper (1,195,522,548 samples, 0.17%) + + + +gcm_ghash_avx (124,100,035 samples, 0.02%) + + + +google::protobuf::internal::ArenaStringPtr::Set (324,162,547 samples, 0.05%) + + + +NActors::TEventPBBase<NKikimr::TEvDataShard::TEvRead, NKikimrTxDataShard::TEvRead, 269553215u, NActors::TRecordHolder<NKikimrTxDataShard::TEvRead> >::Load (1,177,787,244 samples, 0.17%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::~TDirectArrayHolderInplace (120,429,134 samples, 0.02%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (810,787,787 samples, 0.12%) + + + +[[kernel.kallsyms]] (1,353,692,755 samples, 0.19%) + + + +NKikimrTxDataShard::TEvRead::~TEvRead (207,118,399 samples, 0.03%) + + + +TCMallocInternalNewArray (540,133,412 samples, 0.08%) + + + +NActors::UnlockFromExecution<NActors::TMailboxTable::THTSwapMailbox> (91,673,476 samples, 0.01%) + + + +NActors::TActivationContext::GetCurrentEventTicksAsSeconds (2,928,438,146 samples, 0.42%) + + + +NKikimr::NKqp::TKqpProtoBuilder::BuildYdbResultSet (61,361,009,819 samples, 8.80%) +NKikimr::NKq.. + + +NKikimr::TBlobStorageGroupProxy::Handle (492,749,273 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,101,448,353 samples, 0.16%) + + + +NActors::TInterconnectSessionTCP::Handle (554,481,937 samples, 0.08%) + + + +[[kernel.kallsyms]] (255,249,997 samples, 0.04%) + + + +[[kernel.kallsyms]] (164,712,850 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (81,612,161 samples, 0.01%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (1,832,682,794 samples, 0.26%) + + + +NYql::NDq::TDqDataSerializer::Deserialize (12,804,651,664 samples, 1.84%) +N.. + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (339,777,209 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (88,518,252 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (2,586,476,810 samples, 0.37%) + + + +NKikimr::NStorage::TDistributedConfigKeeper::StateFunc (222,136,740 samples, 0.03%) + + + +std::__y1::vector<NKikimr::NTable::TPartGroupRowIter, NPrivate::TStackBasedAllocator<NKikimr::NTable::TPartGroupRowIter, 16ul, true, std::__y1::allocator<NKikimr::NTable::TPartGroupRowIter> > >::reserve (208,168,676 samples, 0.03%) + + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (125,451,961 samples, 0.02%) + + + +NActors::TEventPBBase<NKikimr::TEvBlobStorage::TEvVPutResult, NKikimrBlobStorage::TEvVPutResult, 268633600u, NActors::TRecordHolder<NKikimrBlobStorage::TEvVPutResult> >::Load (328,316,224 samples, 0.05%) + + + +NKikimr::NKqp::TKqpStreamLookupWorker::GetKeyColumnTypes (86,534,694 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (171,363,433 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::Lookup (508,805,041 samples, 0.07%) + + + +NKikimr::CompareTypedCells (21,918,044,821 samples, 3.14%) +NKi.. + + +NActors::TInterconnectSessionTCP::Enqueue (4,060,900,222 samples, 0.58%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (202,553,401 samples, 0.03%) + + + +NKikimrBlobStorage::TMsgQoS::_InternalParse (161,671,972 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (410,955,347 samples, 0.06%) + + + +NActors::TActivationContext::Monotonic (341,603,949 samples, 0.05%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (290,414,050 samples, 0.04%) + + + +NActors::TActorIdentity::Send< (481,101,083 samples, 0.07%) + + + +_aesni_ctr32_ghash_6x (178,386,158 samples, 0.03%) + + + +clock_gettime@@GLIBC_2.17 (230,925,682 samples, 0.03%) + + + +ydbd.User (630,060,545,113 samples, 90.39%) +ydbd.User + + +TCMallocInternalNewArray (237,174,009 samples, 0.03%) + + + +NKikimr::NMiniKQL::TPagedBuffer::AsRope (84,164,125 samples, 0.01%) + + + +NKikimr::NTable::NPage::TFlatIndex::TFlatIndex (116,297,882 samples, 0.02%) + + + +NKikimr::TBlobStorageGroupPutRequest::ReplyAndDieWithLastResponse (1,684,104,418 samples, 0.24%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TryLoad (4,388,961,952 samples, 0.63%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::Execute (257,792,356 samples, 0.04%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (366,804,549 samples, 0.05%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::Seek (467,832,193 samples, 0.07%) + + + +TCMallocInternalAlignedAlloc (252,322,382 samples, 0.04%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::GetEndRowId (209,815,667 samples, 0.03%) + + + +NKikimr::NMiniKQL::MakeCell (77,833,973 samples, 0.01%) + + + +[[kernel.kallsyms]] (4,349,128,668 samples, 0.62%) + + + +NYql::NDq::TDqInputChannel::GetFreeSpace (256,245,061 samples, 0.04%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DoExecuteImpl (234,230,617,657 samples, 33.60%) +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqp.. + + +google::protobuf::internal::ArenaStringPtr::Set (85,209,304 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (167,966,011 samples, 0.02%) + + + +NKikimr::TEvDataShard::TEvReadResult::~TEvReadResult (516,789,049 samples, 0.07%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (759,663,396 samples, 0.11%) + + + +NActors::TActorIdentity::Send< (278,035,097 samples, 0.04%) + + + +NKikimr::NTable::NPage::TDataPageRecord<NKikimr::NTable::NPage::TDataPage::TRecord, NKikimr::NTable::NPage::TDataPage::TItem>::Cell (90,422,698 samples, 0.01%) + + + +[[kernel.kallsyms]] (61,410,754 samples, 0.01%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned int> (81,621,352 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (5,666,688,925 samples, 0.81%) + + + +[[kernel.kallsyms]] (778,756,703 samples, 0.11%) + + + +NKikimr::NTable::CreateIndexIter (769,998,903 samples, 0.11%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (180,458,988 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (82,802,900 samples, 0.01%) + + + +NKikimr::CompareTypedCells (167,148,713 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (3,533,588,662 samples, 0.51%) + + + +NKikimr::NTable::TTable::GetLevels (83,420,243 samples, 0.01%) + + + +syscall (441,317,676 samples, 0.06%) + + + +NActors::TBasicExecutorPool::GetReadyActivationCommon (5,091,016,298 samples, 0.73%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (25,402,718,132 samples, 3.64%) +old_.. + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (83,169,702 samples, 0.01%) + + + +std::__y1::vector<NKikimr::NScheme::TTypeInfo, NPrivate::TStackBasedAllocator<NKikimr::NScheme::TTypeInfo, 16ul, true, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> > >::__append (698,036,336 samples, 0.10%) + + + +non-virtual thunk to NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::GetInputChannelFreeSpace (175,053,448 samples, 0.03%) + + + +NInterconnect::TOutgoingStreamT<262144ul>::ScanLastBytes<TTcpPacketOutTask::Finish (380,506,771 samples, 0.05%) + + + +NKikimr::NKqp::TKqpExecuterBase<NKikimr::NKqp::(anonymous namespace)::TKqpDataExecuter, (61,809,188,494 samples, 8.87%) +NKikimr::NKq.. + + +[[kernel.kallsyms]] (369,021,474 samples, 0.05%) + + + +NKikimr::TOwnedCellVec::Allocate (464,324,597 samples, 0.07%) + + + +NActors::TGenericExecutorThread::Send< (83,194,686 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::GetChannelId (170,780,112 samples, 0.02%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::Finish (2,965,724,526 samples, 0.43%) + + + +__GI___writev (1,964,733,664 samples, 0.28%) + + + +[[kernel.kallsyms]] (229,332,065 samples, 0.03%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (859,531,755 samples, 0.12%) + + + +NKikimr::ComparePrefixBorders (82,937,043 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (499,528,299 samples, 0.07%) + + + +[[kernel.kallsyms]] (101,317,852 samples, 0.01%) + + + +std::__y1::vector<NActors::TExecutorThreadStats, std::__y1::allocator<NActors::TExecutorThreadStats> >::__append (988,081,821 samples, 0.14%) + + + +__memmove_avx_unaligned_erms (84,262,615 samples, 0.01%) + + + +NHPTimer::GetSeconds (723,023,271 samples, 0.10%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (78,755,067 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (138,397,739 samples, 0.02%) + + + +google::protobuf::internal::SerialArena::AllocateAlignedWithCleanupFallback (168,837,935 samples, 0.02%) + + + +NActors::TInputSessionTCP::Read (1,214,778,462 samples, 0.17%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (424,985,859 samples, 0.06%) + + + +[[kernel.kallsyms]] (457,419,484 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,913,007,406 samples, 0.27%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (566,235,540 samples, 0.08%) + + + +NKikimr::TSerializedCellVec::Serialize (1,970,930,855 samples, 0.28%) + + + +[[kernel.kallsyms]] (1,881,667,121 samples, 0.27%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (85,488,842 samples, 0.01%) + + + +NKikimr::TEvDataShard::TEvReadResult::~TEvReadResult (516,789,049 samples, 0.07%) + + + +NYql::NDq::TDqTaskRunner::BindAllocator (430,063,576 samples, 0.06%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +NKikimr::NMetrics::TResourceMetricsSendState::TryUpdate (460,293,047 samples, 0.07%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +NActors::TExecutorThreadCtx::WakeUp (91,311,083 samples, 0.01%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (85,151,004 samples, 0.01%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (82,354,643 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Span::FreelistPopBatchSized< (243,422,616 samples, 0.03%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (85,209,304 samples, 0.01%) + + + +NActors::TActivationContext::LoggerSettings (210,811,528 samples, 0.03%) + + + +NActors::TActorCallbackBehaviour::Receive (125,483,910 samples, 0.02%) + + + +[[kernel.kallsyms]] (81,973,943 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackData<false, unsigned int, NKikimr::NMiniKQL::TPagedBuffer> (74,006,312 samples, 0.01%) + + + +__memcmp_avx2_movbe (2,025,788,377 samples, 0.29%) + + + +NKikimr::NDataShard::TBuildAndWaitDependenciesUnit::BuildDependencies (164,233,038 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (85,833,046 samples, 0.01%) + + + +TCMallocInternalNewArray (220,068,331 samples, 0.03%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> (10,813,497,830 samples, 1.55%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper (652,183,594 samples, 0.09%) + + + +NKikimr::NDataShard::TLockInfo::AddPoint (456,518,438 samples, 0.07%) + + + +tcmalloc::tcmalloc_internal::Span::FreelistPopBatchSized< (119,521,618 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (130,494,694 samples, 0.02%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::TItem::TItem<NKikimr::TEvBlobStorage::TEvVPut> (86,917,712 samples, 0.01%) + + + +NKikimr::NMetrics::TResourceMetricsSendState::FillChanged (460,293,047 samples, 0.07%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NActors::TInterconnectSessionTCP::MakePacket (971,908,187 samples, 0.14%) + + + +NActors::IActor::Send (16,199,069,529 samples, 2.32%) +N.. + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (6,499,387,194 samples, 0.93%) + + + +NKikimr::NKqp::TKqpLookupRows::BuildRequests (77,710,388,011 samples, 11.15%) +NKikimr::NKqp::T.. + + +grpc_core::DoSslWrite (1,637,632,918 samples, 0.23%) + + + +NKikimr::NMiniKQL::GetCellValue (5,756,966,018 samples, 0.83%) + + + +bwrite_conv (254,803,128 samples, 0.04%) + + + +NActors::IActor::Register (71,249,701 samples, 0.01%) + + + +std::__y1::deque<std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (3,888,483,353 samples, 0.56%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (1,245,189,431 samples, 0.18%) + + + +[[kernel.kallsyms]] (382,380,239 samples, 0.05%) + + + +NActors::TActorIdentity::Send< (82,905,573 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (252,615,102 samples, 0.04%) + + + +[[kernel.kallsyms]] (65,023,167 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,097,773,483 samples, 0.16%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (511,524,168 samples, 0.07%) + + + +std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (219,896,389 samples, 0.03%) + + + +aes_gcm_cipher (294,690,975 samples, 0.04%) + + + +syscall (963,214,665 samples, 0.14%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Acquire (8,378,314,018 samples, 1.20%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (130,494,694 samples, 0.02%) + + + +[[kernel.kallsyms]] (256,058,981 samples, 0.04%) + + + +UdfAllocateWithSize (294,943,775 samples, 0.04%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::PrepareValidationInfo (5,930,651,595 samples, 0.85%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +NActors::TActivationContext::Send< (82,905,573 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (126,103,129 samples, 0.02%) + + + +pg_thread_init (168,705,856 samples, 0.02%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +[[kernel.kallsyms]] (101,317,852 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (79,914,196 samples, 0.01%) + + + +[[kernel.kallsyms]] (84,169,831 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::SendReply (1,684,104,418 samples, 0.24%) + + + +NInterconnect::TOutgoingStreamT<262144ul>::DropFront (514,146,023 samples, 0.07%) + + + +NYql::NDq::TDqTaskRunner::Run (94,479,768,993 samples, 13.55%) +NYql::NDq::TDqTaskRu.. + + +NKikimr::TTabletMon::RecalcAll (132,382,133 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (2,649,477,083 samples, 0.38%) + + + +TCMallocInternalAlignedAlloc (128,443,525 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (97,726,336 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackBlob<NKikimr::NMiniKQL::TPagedBuffer> (1,894,620,114 samples, 0.27%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +std::__y1::vector<NKikimr::NTable::TCellOp, NPrivate::TStackBasedAllocator<NKikimr::NTable::TCellOp, 64ul, true, std::__y1::allocator<NKikimr::NTable::TCellOp> > >::assign (168,382,786 samples, 0.02%) + + + +_nv041366rm (66,612,895 samples, 0.01%) + + + +[[vdso]] (121,011,846 samples, 0.02%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NKikimrTxDataShard::TEvRead::ByteSizeLong (341,786,716 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (60,053,689 samples, 0.01%) + + + +std::__y1::__tree<std::__y1::__value_type<NKikimr::TLogoBlobID, NKikimr::TBlobState>, std::__y1::__map_value_compare<NKikimr::TLogoBlobID, std::__y1::__value_type<NKikimr::TLogoBlobID, NKikimr::TBlobState>, TLess<NKikimr::TLogoBlobID>, true>, std::__y1::allocator<std::__y1::__value_type<NKikimr::TLogoBlobID, NKikimr::TBlobState> > >::__emplace_unique_key_args<NKikimr::TLogoBlobID, std::__y1::piecewise_construct_t const&, std::__y1::tuple<NKikimr::TLogoBlobID const&>, std::__y1::tuple<> > (615,432,745 samples, 0.09%) + + + +__memmove_avx_unaligned_erms (618,495,877 samples, 0.09%) + + + +NKikimr::NDataShard::(anonymous namespace)::TShortTableInfo::TShortTableInfo (296,021,055 samples, 0.04%) + + + +[[kernel.kallsyms]] (125,757,204 samples, 0.02%) + + + +[[kernel.kallsyms]] (121,648,285 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (366,044,114 samples, 0.05%) + + + +UdfAllocateWithSize (128,098,713 samples, 0.02%) + + + +google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::~RepeatedPtrField (122,780,035 samples, 0.02%) + + + +NKikimr::NTable::TPartScheme::MakePinout (36,427,399,516 samples, 5.23%) +NKikim.. + + +TCMallocInternalNewArray (99,858,162 samples, 0.01%) + + + +grpc_slice_buffer_move_first_no_ref (81,862,991 samples, 0.01%) + + + +TTcpPacketOutTask::Finish (434,410,391 samples, 0.06%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::TDirectArrayHolderInplace (85,005,673 samples, 0.01%) + + + +[[kernel.kallsyms]] (835,467,161 samples, 0.12%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +NKikimr::NKqp::TKqpProtoBuilder::~TKqpProtoBuilder (86,118,651 samples, 0.01%) + + + +[[kernel.kallsyms]] (110,235,896 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (89,357,680 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (88,310,300 samples, 0.01%) + + + +NKikimr::NCache::TSwitchableCache<NKikimr::NTabletFlatExecutor::TSharedPageCache::TPage, NKikimr::NTabletFlatExecutor::TSharedPageCache::TCompositeCachePageTraits>::TCacheHolder::ProcessEvictedList (289,010,849 samples, 0.04%) + + + +NKikimr::NDataShard::(anonymous namespace)::TCellBlockBuilder::AddRow (8,952,237,635 samples, 1.28%) + + + +__memmove_avx_unaligned_erms (169,263,454 samples, 0.02%) + + + +NActors::MeasureTaskDurationNs (77,031,183 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (128,096,556 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::TOutputChannelInfo::TDrainedChannelMessage::ReadData (896,499,387 samples, 0.13%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (1,678,976,848 samples, 0.24%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (2,356,592,460 samples, 0.34%) + + + +TBasicString<char, std::__y1::char_traits<char> >::assign (351,685,366 samples, 0.05%) + + + +[[kernel.kallsyms]] (874,605,419 samples, 0.13%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ProcessIoStats (673,738,746 samples, 0.10%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (1,450,630,798 samples, 0.21%) + + + +THashTable<std::__y1::pair<std::__y1::pair<unsigned char, unsigned int> const, unsigned int>, std::__y1::pair<unsigned char, unsigned int>, THash<std::__y1::pair<unsigned char, unsigned int> >, TSelect1st, TEqualTo<std::__y1::pair<unsigned char, unsigned int> >, std::__y1::allocator<std::__y1::pair<unsigned char, unsigned int> > >::insert_unique_noresize<std::__y1::pair<std::__y1::pair<unsigned char, unsigned int> const, unsigned int> > (460,293,047 samples, 0.07%) + + + +std::__y1::__murmur2_or_cityhash<unsigned long, 64ul>::operator (1,495,951,682 samples, 0.21%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (126,747,930 samples, 0.02%) + + + +THashMap<unsigned int, unsigned int, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::operator[]<unsigned int> (294,131,993 samples, 0.04%) + + + +NActors::TGenericExecutorThreadCtx::Sleep<NActors::TExecutorThreadCtx, NActors::EThreadState> (963,218,960 samples, 0.14%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackImpl<false, false, NKikimr::NMiniKQL::TPagedBuffer> (25,630,629,135 samples, 3.68%) +NKik.. + + +__memset_avx2_unaligned_erms (410,570,679 samples, 0.06%) + + + +__memmove_avx_unaligned_erms (166,027,535 samples, 0.02%) + + + +NKikimr::NTable::NPage::TLabelWrapper::Read (73,202,300 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (207,398,100 samples, 0.03%) + + + +NKikimr::NKqp::TKqpComputeActor::CheckRunStatus (128,945,155 samples, 0.02%) + + + +NKikimr::NTable::TPartIter::Apply (147,901,255 samples, 0.02%) + + + +THashTable<std::__y1::pair<NKikimr::TLogoBlobID const, THashMap<unsigned int, NActors::TSharedData, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> > >, NKikimr::TLogoBlobID, THash<NKikimr::TLogoBlobID>, TSelect1st, TEqualTo<NKikimr::TLogoBlobID>, std::__y1::allocator<NKikimr::TLogoBlobID> >::basic_clear (818,471,083 samples, 0.12%) + + + +NKikimr::TPathId::operator== (80,285,315 samples, 0.01%) + + + +__memcmp_avx2_movbe (175,984,765 samples, 0.03%) + + + +NKikimr::NKqp::TSchedulableComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::AccountActorSystemStats (128,655,337 samples, 0.02%) + + + +NKikimr::TPutImpl::RunStrategies (96,851,281 samples, 0.01%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned long> (366,116,498 samples, 0.05%) + + + +[[kernel.kallsyms]] (61,410,754 samples, 0.01%) + + + +NActors::TStatsCollectingActor::Wakeup (4,552,288,256 samples, 0.65%) + + + +[[kernel.kallsyms]] (1,577,958,669 samples, 0.23%) + + + +[[kernel.kallsyms]] (1,264,620,020 samples, 0.18%) + + + +_nv031607rm (66,612,895 samples, 0.01%) + + + +NActors::TGenericExecutorThreadCtx::Sleep<NActors::TExecutorThreadCtx, NActors::EThreadState> (6,274,788,637 samples, 0.90%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (159,404,146 samples, 0.02%) + + + +ssl3_write_pending (330,973,902 samples, 0.05%) + + + +google::protobuf::Arena::AllocateAlignedWithHook (239,858,466 samples, 0.03%) + + + +[[kernel.kallsyms]] (110,235,896 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (77,194,026 samples, 0.01%) + + + +grpc_slice_buffer_reset_and_unref (125,558,183 samples, 0.02%) + + + +[[kernel.kallsyms]] (6,892,013,205 samples, 0.99%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (151,589,430 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (83,342,033 samples, 0.01%) + + + +NKikimr::NTable::TDatabase::HasTxData (233,812,262 samples, 0.03%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (290,414,050 samples, 0.04%) + + + +[[kernel.kallsyms]] (419,945,968 samples, 0.06%) + + + +__memset_avx2_unaligned_erms (84,856,722 samples, 0.01%) + + + +NKikimrTxDataShard::TEvRead::_InternalParse (1,177,787,244 samples, 0.17%) + + + +NKikimr::NMiniKQL::GetCellValue (124,774,634 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::CheckRunStatus (3,648,038,038 samples, 0.52%) + + + +TRcBuf::TBackend::VisitRaw<TRcBuf::TBackend::TBackendHolder, TRcBuf::TBackend::Destroy<TRcBuf::TBackend::TBackendHolder> (84,875,105 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (1,691,893,070 samples, 0.24%) + + + +[[kernel.kallsyms]] (1,101,448,353 samples, 0.16%) + + + +do_ssl3_write (1,433,908,053 samples, 0.21%) + + + +[[kernel.kallsyms]] (572,886,195 samples, 0.08%) + + + +NKikimr::NTable::TRowState::Set (2,560,490,237 samples, 0.37%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (163,073,961 samples, 0.02%) + + + +NActors::TGenericExecutorThread::Send< (82,905,573 samples, 0.01%) + + + +SetParallelStartTimestamps (123,596,129 samples, 0.02%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::UnpackBatch (15,103,584,904 samples, 2.17%) +N.. + + +NKikimr::CreateBlobStorageGroupPutRequest (154,627,766 samples, 0.02%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::TryGetIndex (207,983,860 samples, 0.03%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (261,200,365 samples, 0.04%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +UdfAllocateWithSize (254,024,550 samples, 0.04%) + + + +[[kernel.kallsyms]] (211,424,172 samples, 0.03%) + + + +RandomNumber<unsigned long> (89,384,068 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::ExportValueToProtoImpl (41,833,376,969 samples, 6.00%) +NKikimr:.. + + +[[kernel.kallsyms]] (76,428,079 samples, 0.01%) + + + +NRopeDetails::TChunkList<TRcBuf>::Erase (301,100,104 samples, 0.04%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +NActors::TInputSessionTCP::Handle (2,382,669,109 samples, 0.34%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (168,837,935 samples, 0.02%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (3,329,582,509 samples, 0.48%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (1,605,538,350 samples, 0.23%) + + + +TCMallocInternalNewArray (93,532,440 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,843,346,737 samples, 0.26%) + + + +std::__y1::vector<NKikimr::TCell, std::__y1::allocator<NKikimr::TCell> >::__append_uninitialized (84,373,799 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::~TReadOperation (3,336,892,145 samples, 0.48%) + + + +NActors::TActivationContext::Monotonic (251,136,774 samples, 0.04%) + + + +NActors::TActivationContext::LoggerSettings (389,640,372 samples, 0.06%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (14,642,377,133 samples, 2.10%) +N.. + + +std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (87,008,677 samples, 0.01%) + + + +TGUCSettings::Get (5,369,805,806 samples, 0.77%) + + + +[[kernel.kallsyms]] (84,169,831 samples, 0.01%) + + + +std::__y1::vector<std::__y1::pair<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::NScheme::TTypeInfo>, std::__y1::allocator<std::__y1::pair<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::NScheme::TTypeInfo> > >::__emplace_back_slow_path<TBasicString<char, std::__y1::char_traits<char> > const&, NKikimr::NScheme::TTypeInfo const&> (127,864,096 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (602,035,175 samples, 0.09%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (5,551,322,313 samples, 0.80%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpSessionActor::ProcessExecuterResult (159,867,719 samples, 0.02%) + + + +NActors::THarmonizer::Harmonize (649,113,461 samples, 0.09%) + + + +NKikimr::NTable::TRemap::TRemap (29,168,259,764 samples, 4.18%) +NKik.. + + +NKikimr::NDataShard::(anonymous namespace)::TReader::Read (137,795,607,959 samples, 19.77%) +NKikimr::NDataShard::(anonymou.. + + +NKikimr::MainRun (74,793,962 samples, 0.01%) + + + +__memcmp_avx2_movbe (639,006,857 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (61,582,422 samples, 0.01%) + + + +NActors::TInputSessionTCP::WorkingStateImpl (2,409,824,184 samples, 0.35%) + + + +NKikimr::NTabletFlatExecutor::TSharedPageCache::Handle (2,684,257,755 samples, 0.39%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +[[kernel.kallsyms]] (382,380,239 samples, 0.05%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Turn (373,378,591 samples, 0.05%) + + + +google::protobuf::internal::InlineGreedyStringParser (394,082,320 samples, 0.06%) + + + +[[kernel.kallsyms]] (229,332,065 samples, 0.03%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::Destroy<google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::TypeHandler> (543,239,608 samples, 0.08%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +[[kernel.kallsyms]] (2,340,302,452 samples, 0.34%) + + + +[[kernel.kallsyms]] (3,264,544,875 samples, 0.47%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::New (84,544,199 samples, 0.01%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +__libc_sendmsg (3,264,544,875 samples, 0.47%) + + + +std::__y1::__upper_bound[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::NPage::TCompare<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, TArrayRef<NKikimr::TCell const>, std::__y1::__identity> (259,848,333 samples, 0.04%) + + + +[[kernel.kallsyms]] (1,727,420,134 samples, 0.25%) + + + +[[kernel.kallsyms]] (1,757,072,671 samples, 0.25%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::LockAndAlloc (88,518,252 samples, 0.01%) + + + +NDetail::TRcBufInternalBackend::Allocate (638,648,472 samples, 0.09%) + + + +NKikimr::TPutImpl::RunStrategies (546,456,179 samples, 0.08%) + + + +[[kernel.kallsyms]] (963,214,633 samples, 0.14%) + + + +[[kernel.kallsyms]] (742,147,468 samples, 0.11%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (2,210,443,640 samples, 0.32%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (82,802,900 samples, 0.01%) + + + +NActors::TExecutorThreadCtx::WakeUp (1,750,489,729 samples, 0.25%) + + + +[[kernel.kallsyms]] (256,058,981 samples, 0.04%) + + + +[[kernel.kallsyms]] (4,552,258,694 samples, 0.65%) + + + +std::__y1::vector<std::__y1::pair<unsigned long, NKikimr::TOwnedTableRange>, std::__y1::allocator<std::__y1::pair<unsigned long, NKikimr::TOwnedTableRange> > >::__emplace_back_slow_path<unsigned long const&, NKikimr::TOwnedTableRange const&> (338,223,936 samples, 0.05%) + + + +[[kernel.kallsyms]] (499,949,229 samples, 0.07%) + + + +__memcmp_avx2_movbe (85,196,405 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (87,746,011 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::ExportValueToProtoImpl (26,967,654,461 samples, 3.87%) +NKik.. + + +google::protobuf::Message::MaybeComputeUnknownFieldsSize (123,504,446 samples, 0.02%) + + + +endpoint_write (6,789,390,612 samples, 0.97%) + + + +NActors::TGenericExecutorThread::Send< (610,374,145 samples, 0.09%) + + + +NKikimr::NDataShard::TDataShard::TTxInitiateStatsUpdate::Execute (652,657,942 samples, 0.09%) + + + +[[kernel.kallsyms]] (187,092,026 samples, 0.03%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (21,303,383,351 samples, 3.06%) +NAc.. + + +NKikimr::GetServiceCounters (388,050,573 samples, 0.06%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (638,648,472 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (126,535,109 samples, 0.02%) + + + +[[kernel.kallsyms]] (874,605,419 samples, 0.13%) + + + +NYql::NDq::TDqInputChannel::Pop (15,145,872,864 samples, 2.17%) +N.. + + +NKikimr::NKqp::BuildLocks (114,039,714 samples, 0.02%) + + + +old_sort::__sort3[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (433,892,970 samples, 0.06%) + + + +NActors::IActor::Send (175,726,548 samples, 0.03%) + + + +[[kernel.kallsyms]] (1,287,249,751 samples, 0.18%) + + + +NKikimr::TPutImpl::~TPutImpl (571,871,071 samples, 0.08%) + + + +NActors::IActor::Send (481,101,083 samples, 0.07%) + + + +std::__y1::allocator<NKikimr::TSerializedCellVec>::construct[abi:v180000]<NKikimr::TSerializedCellVec, TBasicString<char, std::__y1::char_traits<char> > > (2,277,724,942 samples, 0.33%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (126,747,930 samples, 0.02%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (12,741,662,605 samples, 1.83%) +o.. + + +[[kernel.kallsyms]] (1,061,534,413 samples, 0.15%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (481,101,083 samples, 0.07%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (124,222,907 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (126,692,228 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (3,360,416,541 samples, 0.48%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (287,336,176 samples, 0.04%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +NActors::TEventSerializedData::~TEventSerializedData (301,100,104 samples, 0.04%) + + + +std::__y1::vector<NKikimr::NTable::TRemap::TPin, NPrivate::TStackBasedAllocator<NKikimr::NTable::TRemap::TPin, 16ul, true, std::__y1::allocator<NKikimr::NTable::TRemap::TPin> > >::reserve (92,629,361 samples, 0.01%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +__GI___writev (2,079,491,832 samples, 0.30%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::Enqueue<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPut>, TDelete> > (86,917,712 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (499,528,299 samples, 0.07%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +NKikimrBlobStorage::TEvVPutResult::_InternalParse (278,411,638 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (125,755,703 samples, 0.02%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (149,004,092 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (211,023,419 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (74,383,582 samples, 0.01%) + + + +[[kernel.kallsyms]] (2,392,931,675 samples, 0.34%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::WriteData (2,151,986,548 samples, 0.31%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +[[kernel.kallsyms]] (1,757,072,671 samples, 0.25%) + + + +EVP_CipherInit_ex (84,040,242 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (874,471,119 samples, 0.13%) + + + +Ydb::Query::ExecuteQueryResponsePart::_InternalSerialize (33,992,550,244 samples, 4.88%) +Ydb::Q.. + + +[[kernel.kallsyms]] (1,843,346,737 samples, 0.26%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::~TDirectArrayHolderInplace (2,326,981,114 samples, 0.33%) + + + +[[kernel.kallsyms]] (120,619,203 samples, 0.02%) + + + +[[kernel.kallsyms]] (681,074,371 samples, 0.10%) + + + +NActors::TMailboxHeader::FindActor (592,065,375 samples, 0.08%) + + + +MicroSeconds (9,817,194,156 samples, 1.41%) + + + +NActors::TInterconnectSessionTCP::Write (2,151,986,548 samples, 0.31%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (1,707,080,416 samples, 0.24%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::reserve (208,462,731 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::Populate (84,544,199 samples, 0.01%) + + + +[[kernel.kallsyms]] (206,176,033 samples, 0.03%) + + + +std::__y1::__murmur2_or_cityhash<unsigned long, 64ul>::operator (110,908,364 samples, 0.02%) + + + +THashMap<unsigned int, NKikimr::TTablet::TLogEntry*, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::operator[]<unsigned int> (511,524,168 samples, 0.07%) + + + +NYql::NDecimal::Serialize (602,066,908 samples, 0.09%) + + + +THashTable<TBasicString<char, std::__y1::char_traits<char> >, TBasicString<char, std::__y1::char_traits<char> >, THash<TBasicString<char, std::__y1::char_traits<char> > >, TIdentity, TEqualTo<TBasicString<char, std::__y1::char_traits<char> > >, std::__y1::allocator<TBasicString<char, std::__y1::char_traits<char> > > >::find<TBasicString<char, std::__y1::char_traits<char> > > (83,265,467 samples, 0.01%) + + + +[[kernel.kallsyms]] (336,511,962 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (84,544,199 samples, 0.01%) + + + +google::protobuf::internal::SerialArena::AllocateAlignedFallback (817,183,506 samples, 0.12%) + + + +NYql::NDq::TComputeActorAsyncInputHelperSync::GetFreeSpace (164,040,866 samples, 0.02%) + + + +std::__y1::vector<NKikimr::TCell, std::__y1::allocator<NKikimr::TCell> >::__append_uninitialized (124,222,907 samples, 0.02%) + + + +SaveRecordCacheState (122,005,246 samples, 0.02%) + + + +UdfFreeWithSize (506,721,434 samples, 0.07%) + + + +NKikimr::TEvDataShard::TEvReadResult::~TEvReadResult (895,548,352 samples, 0.13%) + + + +NActors::TActivationContextHolder::operator (126,375,107 samples, 0.02%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (460,420,010 samples, 0.07%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +[[kernel.kallsyms]] (5,415,972,786 samples, 0.78%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::Execute (145,949,479,464 samples, 20.94%) +NKikimr::NDataShard::TDataShard:.. + + +nvidia_isr (66,612,895 samples, 0.01%) + + + +[[kernel.kallsyms]] (126,962,069 samples, 0.02%) + + + +Ydb::Value::_InternalSerialize (27,454,379,482 samples, 3.94%) +Ydb:.. + + +NKikimr::TBlobState::~TBlobState (571,871,071 samples, 0.08%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +[[kernel.kallsyms]] (1,013,300,239 samples, 0.15%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (164,846,411 samples, 0.02%) + + + +NKikimr::ComparePointAndRange<std::__y1::vector<NKikimr::NScheme::TTypeInfo, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> > > (1,228,171,332 samples, 0.18%) + + + +NActors::IActor::Send (82,905,573 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (129,325,733 samples, 0.02%) + + + +TCMallocInternalAlignedAlloc (638,648,472 samples, 0.09%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (305,919,496 samples, 0.04%) + + + +NKikimr::NDataShard::TDataShard::CollectCpuUsage (84,575,296 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (5,344,971,997 samples, 0.77%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NYql::NDq::TDqComputeActorChannels::PollChannel (958,970,138 samples, 0.14%) + + + +NActors::TGenericExecutorThread::Send< (11,314,510,272 samples, 1.62%) + + + +[[kernel.kallsyms]] (18,844,113,633 samples, 2.70%) +[[.. + + +NActors::TInterconnectSessionTCP::DropConfirmed (554,481,937 samples, 0.08%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (82,227,880 samples, 0.01%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (84,373,799 samples, 0.01%) + + + +THashTable<std::__y1::pair<unsigned int const, NActors::TSharedData>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (163,396,452 samples, 0.02%) + + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +NKikimr::NMiniKQL::TBindTerminator::TBindTerminator (90,600,432 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorChannels::HandleWork (344,182,776 samples, 0.05%) + + + +SetParallelStartTimestamps (84,031,907 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (507,218,197 samples, 0.07%) + + + +NKikimrBlobStorage::TExecTimeStats::_InternalParse (133,305,569 samples, 0.02%) + + + +[[kernel.kallsyms]] (5,980,225,237 samples, 0.86%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (571,843,996 samples, 0.08%) + + + +[[kernel.kallsyms]] (4,685,302,395 samples, 0.67%) + + + +NActors::TGenericExecutorThread::DropUnregistered (1,186,519,330 samples, 0.17%) + + + +[[kernel.kallsyms]] (977,381,383 samples, 0.14%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NActors::IActor::Receive (514,051,929 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,399,510,428 samples, 0.20%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +[[kernel.kallsyms]] (1,014,102,401 samples, 0.15%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (91,311,083 samples, 0.01%) + + + +NKikimr::TPinnedPageRef::Drop (83,637,604 samples, 0.01%) + + + +NKikimr::NKqp::TKqpComputeActor::StateFunc (135,432,280 samples, 0.02%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +[ydbd] (83,964,660 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> >::__push_back_slow_path<NKikimr::TOwnedTableRange> (163,054,687 samples, 0.02%) + + + +clock_gettime@@GLIBC_2.17 (164,718,237 samples, 0.02%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::GetInputChannelFreeSpace (785,970,219 samples, 0.11%) + + + +[[kernel.kallsyms]] (88,262,375 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (2,457,674,102 samples, 0.35%) + + + +NKikimr::TCell::AsValue<unsigned long, unsigned long> (87,085,693 samples, 0.01%) + + + +NKikimr::TTabletCountersBase::MakeDiffForAggr (384,581,519 samples, 0.06%) + + + +google::protobuf::Arena::CreateMaybeMessage<Ydb::Value> (382,445,269 samples, 0.05%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +google::protobuf::Arena::AllocateAlignedWithCleanup (90,675,529 samples, 0.01%) + + + +NActors::TGenericExecutorThreadCtx::Spin<NActors::TExecutorThreadCtx, NActors::EThreadState> (3,317,331,156 samples, 0.48%) + + + +std::__y1::deque<NKikimr::NTable::TPartIter, std::__y1::allocator<NKikimr::NTable::TPartIter> >::emplace_back<NKikimr::NTable::TPart const*&, TArrayRef<unsigned int const>&, TIntrusiveConstPtr<NKikimr::NTable::TKeyCellDefaults, TDefaultIntrusivePtrOps<NKikimr::NTable::TKeyCellDefaults> > const&, NKikimr::NTable::IPages*&> (39,225,547,864 samples, 5.63%) +std::__.. + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (207,118,399 samples, 0.03%) + + + +google::protobuf::MessageLite::AppendPartialToString (60,621,883,131 samples, 8.70%) +google::prot.. + + +NKikimr::NBsQueue::TEventHolder::TEventHolder<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPut>, TDelete> > (86,917,712 samples, 0.01%) + + + +[[kernel.kallsyms]] (963,214,649 samples, 0.14%) + + + +[[vdso]] (7,983,159,136 samples, 1.15%) + + + +NActors::TExecutorPoolBaseMailboxed::Send (954,272,545 samples, 0.14%) + + + +[[kernel.kallsyms]] (3,264,544,875 samples, 0.47%) + + + +std::__y1::vector<unsigned int, NPrivate::TStackBasedAllocator<unsigned int, 16ul, true, std::__y1::allocator<unsigned int> > >::reserve (102,520,401 samples, 0.01%) + + + +NYql::NDq::TDqInputChannel::DeserializeAllData (543,084,142 samples, 0.08%) + + + +syscall (278,035,097 samples, 0.04%) + + + +[[kernel.kallsyms]] (264,837,209 samples, 0.04%) + + + +NActors::TEvFreeItems::~TEvFreeItems (548,297,138 samples, 0.08%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +NKikimr::NTable::TDatabase::Select (4,267,238,003 samples, 0.61%) + + + +ydbd.IC (21,859,763,120 samples, 3.14%) +ydb.. + + +NKikimr::NDataShard::TSysLocks::HasWriteLocks (426,942,218 samples, 0.06%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (125,451,961 samples, 0.02%) + + + +NKikimr::TBlackboard::RunStrategy (96,851,281 samples, 0.01%) + + + +[[kernel.kallsyms]] (3,264,544,875 samples, 0.47%) + + + +NKikimr::NTabletFlatExecutor::TExecutorGCLogic::OnCommitLog (365,799,612 samples, 0.05%) + + + +NKikimr::TOwnedCellVec::Allocate (799,390,542 samples, 0.11%) + + + +[[kernel.kallsyms]] (3,264,544,875 samples, 0.47%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (257,785,804 samples, 0.04%) + + + +[[kernel.kallsyms]] (1,964,733,664 samples, 0.28%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::PollAsyncInput (277,279,956 samples, 0.04%) + + + +HashBucketCountExt (234,221,013 samples, 0.03%) + + + +NActors::TInterconnectSessionTCP::WriteData (2,151,986,548 samples, 0.31%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +std::__y1::allocator<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey>::destroy[abi:v180000] (2,934,330,891 samples, 0.42%) + + + +grpc_core::SslProtectorProtect (2,649,634,302 samples, 0.38%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (83,108,014 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqInputUnionStreamValue<false>::Fetch (882,991,131 samples, 0.13%) + + + +NKikimr::TBlobStorageGroupType::CorrectLayout (61,001,121 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (171,363,433 samples, 0.02%) + + + +NYql::NDq::TDqTaskRunner::Run (540,429,765 samples, 0.08%) + + + +NKikimr::TBlobStorageGroupRequestActor<NKikimr::TBlobStorageGroupPutRequest>::SendResponse (618,721,915 samples, 0.09%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +[[kernel.kallsyms]] (565,334,822 samples, 0.08%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned int> (88,941,032 samples, 0.01%) + + + +NActors::TEventBase<NKikimr::TEvBlobStorage::TEvVPutResult, 268633600u>::Type (78,779,822 samples, 0.01%) + + + +NKikimr::TEvDataShard::TEvReadResult::CalculateSerializedSize (4,060,894,703 samples, 0.58%) + + + +[[kernel.kallsyms]] (65,023,167 samples, 0.01%) + + + +[[kernel.kallsyms]] (91,311,083 samples, 0.01%) + + + +__memcmp_avx2_movbe (2,369,483,652 samples, 0.34%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (82,905,573 samples, 0.01%) + + + +NKikimr::NMiniKQL::THolderFactory::CreateDirectArrayHolder (126,977,308 samples, 0.02%) + + + +NKikimr::NMiniKQL::NDetails::TChunkedInputBuffer::Next (84,875,105 samples, 0.01%) + + + +__memcmp_avx2_movbe (440,929,489 samples, 0.06%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpStreamLookupActor::StateFunc (4,655,087,107 samples, 0.67%) + + + +NKikimr::NTable::NPage::TDataPage::Set (122,106,768 samples, 0.02%) + + + +[[kernel.kallsyms]] (499,254,012 samples, 0.07%) + + + +[[kernel.kallsyms]] (211,424,172 samples, 0.03%) + + + +NKikimr::TTabletCountersAggregatorActor::StateWork (869,072,361 samples, 0.12%) + + + +tcmalloc::tcmalloc_internal::Span::BuildFreelist (520,705,422 samples, 0.07%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::HandleResponse<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPutResult>, TDelete> > (745,630,226 samples, 0.11%) + + + +[[kernel.kallsyms]] (497,632,703 samples, 0.07%) + + + +google::protobuf::internal::ArenaStringPtr::SetBytes (4,855,030,302 samples, 0.70%) + + + +std::__y1::__variant_detail::__visitation::__base::__dispatcher<0ul>::__dispatch[abi:v180000]<std::__y1::__variant_detail::__visitation::__variant::__value_visitor<NActors::TBasicExecutorPool::ScheduleActivationExCommon (458,707,041 samples, 0.07%) + + + +NKikimr::TTabletCountersBase::~TTabletCountersBase (85,912,623 samples, 0.01%) + + + +[[kernel.kallsyms]] (88,262,375 samples, 0.01%) + + + +NKikimr::NDataShard::TReadIteratorState::~TReadIteratorState (1,419,753,619 samples, 0.20%) + + + +grpc_core::ExecCtx::Flush (7,015,683,270 samples, 1.01%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::BuildMeta (282,304,225 samples, 0.04%) + + + +__GI___readv (109,016,354 samples, 0.02%) + + + +write_action_begin_locked (6,922,484,747 samples, 0.99%) + + + +nft_do_chain_ipv4 (84,666,566 samples, 0.01%) + + + +NYql::NDq::TDqInputChannel::PushImpl (15,103,584,904 samples, 2.17%) +N.. + + +NKikimrTabletBase::TTabletLogEntry::~TTabletLogEntry (89,096,262 samples, 0.01%) + + + +google::protobuf::internal::ArenaStringPtr::Set (651,486,588 samples, 0.09%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (414,798,554 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (77,478,446 samples, 0.01%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NActors::TExecutorPoolBaseMailboxed::Register (71,244,520 samples, 0.01%) + + + +NKikimr::TTabletReqWriteLog::~TTabletReqWriteLog (89,096,262 samples, 0.01%) + + + +NKikimr::NTable::NPage::TFlatIndex::LookupKey (259,848,333 samples, 0.04%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> (438,006,482,177 samples, 62.84%) +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> + + +NYql::NDq::(anonymous namespace)::EstimateSizeImpl (5,542,188,500 samples, 0.80%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (167,563,308 samples, 0.02%) + + + +NActors::TActivationContext::Send< (278,035,097 samples, 0.04%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (212,024,068 samples, 0.03%) + + + +[[kernel.kallsyms]] (3,530,588,761 samples, 0.51%) + + + +SaveRecordCacheState (153,938,222 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (206,312,006 samples, 0.03%) + + + +[[kernel.kallsyms]] (110,235,896 samples, 0.02%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (175,629,057 samples, 0.03%) + + + +[[kernel.kallsyms]] (83,641,703 samples, 0.01%) + + + +NKikimr::NTable::TPartIter::TPartIter (38,511,065,862 samples, 5.52%) +NKikimr.. + + +NYql::NDq::TDqMemoryQuota::TryShrinkMemory (810,609,916 samples, 0.12%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (84,764,630 samples, 0.01%) + + + +google::protobuf::internal::GenericSwap (166,976,232 samples, 0.02%) + + + +SaveRecordCacheState (88,603,539 samples, 0.01%) + + + +[[kernel.kallsyms]] (101,317,852 samples, 0.01%) + + + +std::__y1::vector<char, NPrivate::TStackBasedAllocator<char, 16ul, true, std::__y1::allocator<char> > >::__insert_with_size[abi:v180000]<char const*, char const*> (621,452,742 samples, 0.09%) + + + +NKikimr::TPutImpl::RunStrategy (96,851,281 samples, 0.01%) + + + +nf_nat_ipv4_local_fn (92,709,613 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::HandleRam (2,936,641,851 samples, 0.42%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (147,610,442 samples, 0.02%) + + + +NKikimr::Main (74,793,962 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (1,634,517,990 samples, 0.23%) + + + +grpc_core::promise_filter_detail::BaseCallData::Flusher::~Flusher (93,198,523 samples, 0.01%) + + + +NActors::TGenericExecutorThreadCtx::Spin<NActors::TExecutorThreadCtx, NActors::EThreadState> (4,003,486,544 samples, 0.57%) + + + +NYql::NDq::TDqComputeActorMetrics::ReportEvent (161,088,224 samples, 0.02%) + + + +NKikimr::TBlobStorageGroupProxy::Handle (180,070,083 samples, 0.03%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +std::__y1::vector<NKikimr::NDataShard::TPointKey, NPrivate::TStackBasedAllocator<NKikimr::NDataShard::TPointKey, 4ul, true, std::__y1::allocator<NKikimr::NDataShard::TPointKey> > >::__push_back_slow_path<NKikimr::NDataShard::TPointKey const&> (93,660,042 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::EnsureReadOnlyLease (82,905,573 samples, 0.01%) + + + +[[kernel.kallsyms]] (369,021,474 samples, 0.05%) + + + +NKikimr::NMiniKQL::TPagedBuffer::Advance (130,655,950 samples, 0.02%) + + + +[[kernel.kallsyms]] (83,452,743 samples, 0.01%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (123,408,441 samples, 0.02%) + + + +google::protobuf::internal::ArenaStringPtr::Set (14,515,945,770 samples, 2.08%) +g.. + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +google::protobuf::internal::EpsCopyInputStream::ReadStringFallback (788,847,138 samples, 0.11%) + + + +non-virtual thunk to NKikimr::NTabletFlatExecutor::TExecutor::Execute (164,857,541,721 samples, 23.65%) +non-virtual thunk to NKikimr::NTablet.. + + +NActors::TEventBase<NYql::NDq::TEvDqCompute::TEvResumeExecution, 271646922u>::Type (205,993,172 samples, 0.03%) + + + +[[kernel.kallsyms]] (2,041,843,708 samples, 0.29%) + + + +[[kernel.kallsyms]] (84,169,831 samples, 0.01%) + + + +flush_write_staging_buffer (81,748,626 samples, 0.01%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +start_thread (21,303,383,351 samples, 3.06%) +sta.. + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::DoInsert (2,973,052,638 samples, 0.43%) + + + +TTcpPacketOutTask::Finish (335,351,517 samples, 0.05%) + + + +NActors::TActivationContext::LoggerSettings (176,528,827 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (514,146,023 samples, 0.07%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (207,549,788 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::CommitTransactionLog (127,763,225 samples, 0.02%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +NKikimr::NDataShard::TDataShard::TTxReadContinue::Execute (6,255,113,062 samples, 0.90%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (1,216,287,582 samples, 0.17%) + + + +[[kernel.kallsyms]] (125,398,723 samples, 0.02%) + + + +std::__y1::vector<TStackVec<TRope, 6ul, true, std::__y1::allocator<TRope> >, NPrivate::TStackBasedAllocator<TStackVec<TRope, 6ul, true, std::__y1::allocator<TRope> >, 16ul, true, std::__y1::allocator<TStackVec<TRope, 6ul, true, std::__y1::allocator<TRope> > > > >::__destroy_vector::operator (75,229,839 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::Delete (60,053,689 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (252,615,102 samples, 0.04%) + + + +std::__y1::__tree_remove[abi:v180000]<std::__y1::__tree_node_base<void*>*> (330,371,335 samples, 0.05%) + + + +NActors::TExecutorThreadCtx::WakeUp (147,610,442 samples, 0.02%) + + + +[[vdso]] (62,030,725 samples, 0.01%) + + + +[[kernel.kallsyms]] (2,090,436,124 samples, 0.30%) + + + +[[kernel.kallsyms]] (91,311,083 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (129,792,237 samples, 0.02%) + + + +[[kernel.kallsyms]] (874,605,419 samples, 0.13%) + + + +NActors::TInterconnectSessionTCP::ProducePackets (971,908,187 samples, 0.14%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::~TPartGroupFlatIndexIter (215,267,082 samples, 0.03%) + + + +NKikimr::NTable::TPartIter::TPartIter (1,400,122,739 samples, 0.20%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::DoExecute (257,785,804 samples, 0.04%) + + + +NActors::NSchedulerQueue::TReader::Pop (955,809,878 samples, 0.14%) + + + +NActors::TActivationContextHolder::operator* (122,472,269 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (1,725,906,683 samples, 0.25%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +NYdbGrpc::TGRpcRequestImpl<Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, NKikimr::NGRpcService::TGRpcYdbQueryService, google::protobuf::TextFormat::Printer, google::protobuf::TextFormat::Printer>::WriteByteDataOk (7,102,244,152 samples, 1.02%) + + + +TCMallocInternalNewArray (82,338,763 samples, 0.01%) + + + +[ydbd] (163,630,442 samples, 0.02%) + + + +NYql::NDq::(anonymous namespace)::EstimateIntegralDataSize (88,546,268 samples, 0.01%) + + + +NYql::NDq::TDqDataSerializer::Deserialize (15,103,584,904 samples, 2.17%) +N.. + + +NActors::TEventPBBase<NKikimr::TEvDataShard::TEvReadResult, NKikimrTxDataShard::TEvReadResult, 269553216u, NActors::TRecordHolder<NKikimrTxDataShard::TEvReadResult> >::Load (2,212,713,632 samples, 0.32%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (112,430,987 samples, 0.02%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::TryGetIndex (2,354,142,657 samples, 0.34%) + + + +[[kernel.kallsyms]] (83,889,138 samples, 0.01%) + + + +grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus, grpc::internal::CallNoOp<4>, grpc::internal::CallNoOp<5>, grpc::internal::CallNoOp<6> >::ContinueFillOpsAfterInterception (7,015,683,270 samples, 1.01%) + + + +[[kernel.kallsyms]] (3,264,544,875 samples, 0.47%) + + + +[[kernel.kallsyms]] (825,750,067 samples, 0.12%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ConfirmReadOnlyLease (82,905,573 samples, 0.01%) + + + +[[kernel.kallsyms]] (81,900,914 samples, 0.01%) + + + +NActors::TInputSessionTCP::ReadMore (2,128,012,808 samples, 0.31%) + + + +[[kernel.kallsyms]] (646,118,832 samples, 0.09%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (900,024,717 samples, 0.13%) + + + +NHPTimer::GetSeconds (511,510,396 samples, 0.07%) + + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::FinishPackAndCheckSize (2,965,724,526 samples, 0.43%) + + + +NKikimr::NTable::TDatabaseImpl::Get (394,327,026 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::AllocSmall (88,518,252 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (125,294,305 samples, 0.02%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Snap (605,067,243 samples, 0.09%) + + + +NActors::TMailboxHeader::MarkForSchedule (4,262,935,611 samples, 0.61%) + + + +NActors::TActivationContext::LoggerSettings (77,846,121 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TCommitManager::SendCommitEv (82,905,573 samples, 0.01%) + + + +[[kernel.kallsyms]] (193,857,462 samples, 0.03%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (204,875,058 samples, 0.03%) + + + +[[kernel.kallsyms]] (18,186,621,217 samples, 2.61%) +[[.. + + +MicroSeconds (3,980,969,025 samples, 0.57%) + + + +TDefaultAllocator::Allocate (252,322,382 samples, 0.04%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (133,316,585 samples, 0.02%) + + + +NKikimr::TBlobStorageGroupPutRequest::Handle (1,837,832,861 samples, 0.26%) + + + +NActors::TEventOutputChannel::FeedBuf (537,497,796 samples, 0.08%) + + + +syscall (572,886,227 samples, 0.08%) + + + +NKikimr::TBlobStorageGroupPutRequest::StateWait (1,837,832,861 samples, 0.26%) + + + +NActors::TGenericExecutorThread::Send< (175,629,057 samples, 0.03%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::UnpackBatch (543,084,142 samples, 0.08%) + + + +nft_do_chain (84,666,566 samples, 0.01%) + + + +_nv031606rm (66,612,895 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::Action (629,614,097 samples, 0.09%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::Head (176,674,127 samples, 0.03%) + + + +NKikimr::NTable::NPage::TDataPage::LookupKey (7,030,862,190 samples, 1.01%) + + + +NKikimr::NMiniKQL::MakeStringNotFilled (961,681,781 samples, 0.14%) + + + +[[kernel.kallsyms]] (1,881,687,482 samples, 0.27%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::BaseStateFuncBody (763,613,068 samples, 0.11%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (324,021,766 samples, 0.05%) + + + +[[kernel.kallsyms]] (121,370,439 samples, 0.02%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (572,886,227 samples, 0.08%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +[[kernel.kallsyms]] (88,262,375 samples, 0.01%) + + + +std::__y1::vector<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey, std::__y1::allocator<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey> >::__emplace_back_slow_path<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey> (81,415,261 samples, 0.01%) + + + +NKikimr::TPathId::Hash (85,775,191 samples, 0.01%) + + + +std::__y1::__variant_detail::__visitation::__base::__dispatcher<0ul>::__dispatch[abi:v180000]<std::__y1::__variant_detail::__visitation::__variant::__value_visitor<NKikimr::TBlobStorageGroupPutRequest::UpdatePengingVDiskResponseCount (59,246,290 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (672,422,931 samples, 0.10%) + + + +TCMallocInternalNewArray (83,827,714 samples, 0.01%) + + + +NHPTimer::GetSeconds (80,681,548 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::Populate (126,535,109 samples, 0.02%) + + + +NKikimr::NGRpcService::(anonymous namespace)::TExecuteQueryRPC::StateWork (68,182,954,992 samples, 9.78%) +NKikimr::NGRpc.. + + +nft_do_chain (123,044,795 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (125,575,522 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,011,633,173 samples, 0.15%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (84,875,105 samples, 0.01%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> (10,912,278,743 samples, 1.57%) + + + +NActors::TInputSessionTCP::WorkingStateImpl (2,542,957,660 samples, 0.36%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (1,705,649,802 samples, 0.24%) + + + +[[kernel.kallsyms]] (1,264,620,020 samples, 0.18%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::Destroy<google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::TypeHandler> (122,780,035 samples, 0.02%) + + + +NActors::TActivationContextHolder::operator= (638,769,796 samples, 0.09%) + + + +Ydb::Value::ByteSizeLong (25,965,947,901 samples, 3.73%) +Ydb:.. + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (217,132,016 samples, 0.03%) + + + +google::protobuf::MessageLite::ParseFromZeroCopyStream (2,212,713,632 samples, 0.32%) + + + +std::__y1::deque<NKikimr::NKqp::TKqpStreamLookupWorker::TShardReadResult, std::__y1::allocator<NKikimr::NKqp::TKqpStreamLookupWorker::TShardReadResult> >::pop_front (1,196,648,456 samples, 0.17%) + + + +NKikimr::TTabletCountersBase::~TTabletCountersBase (85,912,623 samples, 0.01%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Release (1,032,228,829 samples, 0.15%) + + + +[[kernel.kallsyms]] (1,913,007,406 samples, 0.27%) + + + +[[kernel.kallsyms]] (1,994,540,472 samples, 0.29%) + + + +[[kernel.kallsyms]] (2,213,797,716 samples, 0.32%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (168,180,707 samples, 0.02%) + + + +NActors::IActor::Send (83,194,686 samples, 0.01%) + + + +NActors::TActivationContext::Send< (83,194,686 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (80,114,785 samples, 0.01%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (291,396,588 samples, 0.04%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::GetReadTxObserver (426,942,218 samples, 0.06%) + + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +[[kernel.kallsyms]] (81,973,943 samples, 0.01%) + + + +NActors::TActivationContext::LoggerSettings (125,570,441 samples, 0.02%) + + + +NKikimr::NTabletPipe::TClient::TEventParts::ToRemotePush (1,109,046,924 samples, 0.16%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (168,837,935 samples, 0.02%) + + + +NKikimr::TCountersArray<NKikimr::TTabletSimpleCounter>::Reset (80,306,780 samples, 0.01%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +NKikimr::NDataShard::TReadUnit::Execute (145,949,479,464 samples, 20.94%) +NKikimr::NDataShard::TReadUnit::.. + + +restore_stack_base (84,208,100 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper (781,656,567 samples, 0.11%) + + + +std::__y1::vector<char, NPrivate::TStackBasedAllocator<char, 16ul, true, std::__y1::allocator<char> > >::reserve (288,349,883 samples, 0.04%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +[[kernel.kallsyms]] (81,900,914 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (126,380,080 samples, 0.02%) + + + +NKikimr::TSerializedCellVec::DoTryParse (1,107,804,680 samples, 0.16%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::Populate (566,235,540 samples, 0.08%) + + + +[[kernel.kallsyms]] (164,712,850 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (160,705,898 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (149,004,092 samples, 0.02%) + + + +ITrampoLine::DoRunNaked (469,834,146 samples, 0.07%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::ReleaseToSpans (128,928,325 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (85,209,304 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (410,955,347 samples, 0.06%) + + + +NKikimr::NPrivate::TAggregatedCumulativeCounters::RecalcAll (87,314,782 samples, 0.01%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::ForEachRow<NYql::NDq::TDqInputImpl<NYql::NDq::TDqAsyncInputBuffer, NYql::NDq::IDqAsyncInputBuffer>::Pop (157,977,785 samples, 0.02%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackData<false, unsigned int, NKikimr::NMiniKQL::TPagedBuffer> (2,034,321,362 samples, 0.29%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (123,553,589 samples, 0.02%) + + + +NKikimr::NKqp::TSchedulableComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DoExecuteImpl (385,740,329 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (346,205,729 samples, 0.05%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (292,322,913 samples, 0.04%) + + + +[[kernel.kallsyms]] (83,452,743 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::UpdateCounters (747,945,457 samples, 0.11%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (82,227,880 samples, 0.01%) + + + +scsi_end_request (234,924,989 samples, 0.03%) + + + +ydbd.System (19,734,480,369 samples, 2.83%) +yd.. + + +non-virtual thunk to NKikimr::NTabletFlatExecutor::TExecutor::GetStats (82,446,675 samples, 0.01%) + + + +NActors::TInternalActorTypeGuard< (64,026,744 samples, 0.01%) + + + +NKikimrBlobStorage::TVDiskID::_InternalParse (69,573,829 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Span::BuildFreelist (499,528,299 samples, 0.07%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (278,035,097 samples, 0.04%) + + + +NKikimr::TSerializedCellVec::DoTryParse (2,277,724,942 samples, 0.33%) + + + +NActors::TCpuManager::GetPoolStats (3,445,502,862 samples, 0.49%) + + + +[[kernel.kallsyms]] (82,402,859 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (514,146,023 samples, 0.07%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +NKikimr::NDataShard::TSysLocks::EnsureCurrentLock (233,812,262 samples, 0.03%) + + + +NKikimr::NTable::TPartGroupKeyIter::Seek (26,847,234,695 samples, 3.85%) +NKik.. + + +[[kernel.kallsyms]] (960,832,146 samples, 0.14%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::Handle (167,550,032,735 samples, 24.04%) +NKikimr::NDataShard::TDataShard::Handle + + +[[kernel.kallsyms]] (1,016,242,782 samples, 0.15%) + + + +TRcBuf::GetDataMut (95,862,836 samples, 0.01%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +LoadRecordCacheState (420,840,089 samples, 0.06%) + + + +NKikimr::NTabletFlatExecutor::TCommitManager::SendCommitEv (218,907,888 samples, 0.03%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::DestroyProtos (85,193,901 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (77,478,446 samples, 0.01%) + + + +NActors::TExecutorThreadCtx::WakeUp (278,035,097 samples, 0.04%) + + + +NKikimr::NBsQueue::TEventHolder::SendToVDisk (291,687,365 samples, 0.04%) + + + +[[kernel.kallsyms]] (101,317,852 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (128,065,663 samples, 0.02%) + + + +NKikimr::ComparePrefixBorders (351,591,861 samples, 0.05%) + + + +NKikimrTxDataShard::TEvReadResult_TCellVecBatch::~TEvReadResult_TCellVecBatch (516,789,049 samples, 0.07%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NYql::NDq::TDqInputImpl<NYql::NDq::TDqInputChannelImpl, NYql::NDq::IDqInputChannel>::Pop (127,656,603 samples, 0.02%) + + + +Ydb::Value::MergeFrom (166,976,232 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::TTxReadViaPipeline::Execute (155,971,360,485 samples, 22.38%) +NKikimr::NDataShard::TDataShard::TT.. + + +NYql::NDq::(anonymous namespace)::EstimateSizeImpl (18,550,955,146 samples, 2.66%) +NY.. + + +TRope::Insert (74,756,164 samples, 0.01%) + + + +[[kernel.kallsyms]] (212,881,315 samples, 0.03%) + + + +NActors::TInputSessionTCP::WorkingState (2,584,914,867 samples, 0.37%) + + + +_aesni_ctr32_ghash_6x (3,545,650,800 samples, 0.51%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::DestroyProtos (89,096,262 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (344,582,087 samples, 0.05%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (84,649,076 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (286,585,098 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (2,252,128,104 samples, 0.32%) + + + +[[kernel.kallsyms]] (18,844,113,633 samples, 2.70%) +[[.. + + +NKikimr::TBlobStorageGroupPutRequest::~TBlobStorageGroupPutRequest (686,467,721 samples, 0.10%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::HandleRequest<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPut>, TDelete>, NKikimr::TEvBlobStorage::TEvVPut, NKikimr::TEvBlobStorage::TEvVPutResult> (407,349,928 samples, 0.06%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpDataExecuter::CheckExecutionComplete (156,310,219 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::AttachLeaseCommit (194,213,545 samples, 0.03%) + + + +NKikimr::NTable::NPage::TDataPageRecord<NKikimr::NTable::NPage::TDataPage::TRecord, NKikimr::NTable::NPage::TDataPage::TItem>::Cell (82,656,261 samples, 0.01%) + + + +[[kernel.kallsyms]] (109,011,146 samples, 0.02%) + + + +NActors::THarmonizer::Harmonize (230,014,505 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (413,505,876 samples, 0.06%) + + + +TCMallocInternalNewArray (167,132,001 samples, 0.02%) + + + +__memcmp_avx2_movbe (249,383,529 samples, 0.04%) + + + +std::__y1::vector<NKikimr::NDataShard::TPointKey, NPrivate::TStackBasedAllocator<NKikimr::NDataShard::TPointKey, 4ul, true, std::__y1::allocator<NKikimr::NDataShard::TPointKey> > >::__destroy_vector::operator (84,782,721 samples, 0.01%) + + + +NActors::TGenericExecutorThreadCtx::Spin<NActors::TExecutorThreadCtx, NActors::EThreadState> (3,191,158,182 samples, 0.46%) + + + +NActors::TActorSystem::Send< (1,245,189,431 samples, 0.18%) + + + +NKikimr::NKqp::TKqpLookupRows::ReplyResult (22,045,690,090 samples, 3.16%) +NKi.. + + +[[kernel.kallsyms]] (874,605,419 samples, 0.13%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (667,345,723 samples, 0.10%) + + + +NYql::NDq::TDqComputeActorChannels::OutCh (78,612,380 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::InternalExtend (84,654,447 samples, 0.01%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Next (1,166,334,906 samples, 0.17%) + + + +[[kernel.kallsyms]] (1,013,285,200 samples, 0.15%) + + + +NActors::TActivationContext::Send< (481,101,083 samples, 0.07%) + + + +NKikimr::NSharedCache::TEvTouch::~TEvTouch (818,471,083 samples, 0.12%) + + + +NKikimr::TEvDataShard::TEvRead::Load (2,285,591,924 samples, 0.33%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (566,235,540 samples, 0.08%) + + + +NKikimr::TBlobStorageGroupPutRequest::TBlobStorageGroupPutRequest (154,627,766 samples, 0.02%) + + + +NKikimr::NDataShard::TPipeline::RunExecutionPlan (152,548,478,848 samples, 21.89%) +NKikimr::NDataShard::TPipeline::Ru.. + + +old_sort::__sort3[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (202,708,638 samples, 0.03%) + + + +[[kernel.kallsyms]] (123,307,135 samples, 0.02%) + + + +NActors::TActorIdentity::Send< (84,788,746 samples, 0.01%) + + + +NKikimr::TOwnedCellVec::Allocate (213,276,590 samples, 0.03%) + + + +[[kernel.kallsyms]] (62,966,222 samples, 0.01%) + + + +NKikimr::NMiniKQL::TPagedBuffer::Advance (85,943,020 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (410,955,347 samples, 0.06%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +NKikimr::TBlobStorageGroupProxy::StateCommon (492,749,273 samples, 0.07%) + + + +NActors::TExecutorThreadStats::Aggregate (1,829,338,714 samples, 0.26%) + + + +__memmove_avx_unaligned_erms (584,198,556 samples, 0.08%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (16,269,370,405 samples, 2.33%) +N.. + + +std::__y1::deque<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> >::emplace_back<std::__y1::vector<NKikimr::TCell, std::__y1::allocator<NKikimr::TCell> > > (592,601,795 samples, 0.09%) + + + +NYql::NUdf::TUnboxedValuePod::AsStringRef (365,161,568 samples, 0.05%) + + + +[[kernel.kallsyms]] (466,691,733 samples, 0.07%) + + + +NYql::NDecimal::Deserialize (451,568,551 samples, 0.06%) + + + +std::__y1::vector<unsigned int, NPrivate::TStackBasedAllocator<unsigned int, 16ul, true, std::__y1::allocator<unsigned int> > >::__insert_with_size[abi:v180000]<unsigned int const*, unsigned int const*> (303,429,606 samples, 0.04%) + + + +[[kernel.kallsyms]] (155,950,608 samples, 0.02%) + + + +NActors::TActivationContextHolder::operator* (92,156,495 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::TComputationGraph::GetTerminator (236,760,938 samples, 0.03%) + + + +google::protobuf::internal::IsStructurallyValidUTF8 (6,003,913,247 samples, 0.86%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::Read (139,144,726,665 samples, 19.96%) +NKikimr::NDataShard::TDataShard.. + + +Ydb::ResultSet::~ResultSet (85,193,901 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (243,422,616 samples, 0.03%) + + + +NKikimr::TBlobStorageGroupPutRequest::Bootstrap (2,019,184,919 samples, 0.29%) + + + +[ydbd] (203,261,526 samples, 0.03%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +Ydb::Value::_InternalSerialize (33,577,573,503 samples, 4.82%) +Ydb::V.. + + +[[kernel.kallsyms]] (256,058,981 samples, 0.04%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (61,582,422 samples, 0.01%) + + + +[[kernel.kallsyms]] (565,334,822 samples, 0.08%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<__int128> (502,411,437 samples, 0.07%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +[[kernel.kallsyms]] (109,011,146 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (916,489,530 samples, 0.13%) + + + +NActors::TInputSessionTCP::ProcessEvents (736,010,651 samples, 0.11%) + + + +grpc_client (193,572,176 samples, 0.03%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::EraseItem (74,855,855 samples, 0.01%) + + + +[[kernel.kallsyms]] (762,367,241 samples, 0.11%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::AddRange (3,277,585,467 samples, 0.47%) + + + +TRcBuf::TBackend::VisitRaw<TRcBuf::TBackend::TBackendHolder, TRcBuf::TBackend::Destroy<TRcBuf::TBackend::TBackendHolder> (173,598,261 samples, 0.02%) + + + +NKikimr::TBlobStorageGroupPutRequest::Action (1,780,955,699 samples, 0.26%) + + + +NKikimr::NDataShard::(anonymous namespace)::CreateBlockBuilder (465,639,528 samples, 0.07%) + + + +NActors::TActivationContextHolder::operator= (84,420,458 samples, 0.01%) + + + +[[kernel.kallsyms]] (83,452,743 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (2,599,256,176 samples, 0.37%) + + + +[[kernel.kallsyms]] (666,947,710 samples, 0.10%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +NKikimr::TKeyDesc::TKeyDesc<TVector<NKikimr::NScheme::TTypeInfo, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> >, TVector<NKikimr::TKeyDesc::TColumnOp, std::__y1::allocator<NKikimr::TKeyDesc::TColumnOp> > > (2,222,699,785 samples, 0.32%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (123,408,441 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::GetKeyAccessSampler (123,373,456 samples, 0.02%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +NKikimr::NTabletFlatExecutor::TExecutorGCLogic::IntrospectStateSize (191,701,483 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (83,223,479 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,011,633,173 samples, 0.15%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (83,744,859 samples, 0.01%) + + + +[[kernel.kallsyms]] (122,839,171 samples, 0.02%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::TReadAsFilledMailbox> (3,649,095,613 samples, 0.52%) + + + +MicroSeconds (8,450,066,075 samples, 1.21%) + + + +NKikimr::NMiniKQL::TBindTerminator::~TBindTerminator (157,558,897 samples, 0.02%) + + + +[[kernel.kallsyms]] (829,745,630 samples, 0.12%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DrainOutputChannel (4,126,786,218 samples, 0.59%) + + + +[[kernel.kallsyms]] (369,021,474 samples, 0.05%) + + + +NKikimr::NCache::TSwitchableCache<NKikimr::NTabletFlatExecutor::TSharedPageCache::TPage, NKikimr::NTabletFlatExecutor::TSharedPageCache::TCompositeCachePageTraits>::Touch (371,526,785 samples, 0.05%) + + + +NKikimr::NDataShard::TSysLocks::ApplyLocks (3,905,382,762 samples, 0.56%) + + + +__memmove_avx_unaligned_erms (254,803,128 samples, 0.04%) + + + +NKikimr::TKikimrRunner::BusyLoop (70,068,510 samples, 0.01%) + + + +[[kernel.kallsyms]] (101,317,852 samples, 0.01%) + + + +NYql::(anonymous namespace)::TContigousChunkOverBuf::~TContigousChunkOverBuf (344,182,776 samples, 0.05%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::__unordered_map_hasher<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::hash<unsigned long>, std::__y1::equal_to<unsigned long>, true>, std::__y1::__unordered_map_equal<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::equal_to<unsigned long>, std::__y1::hash<unsigned long>, true>, std::__y1::allocator<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > > > >::erase (511,471,547 samples, 0.07%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (166,976,232 samples, 0.02%) + + + +NMonitoring::TDynamicCounters::EnumerateSubgroups (179,313,243 samples, 0.03%) + + + +[[kernel.kallsyms]] (88,262,375 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (82,026,403 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (151,589,430 samples, 0.02%) + + + +[[kernel.kallsyms]] (89,877,450 samples, 0.01%) + + + +google::protobuf::Arena::CreateMaybeMessage<Ydb::Value> (3,904,716,065 samples, 0.56%) + + + +NKikimr::NTable::TPartGroupKeyIter::Seek (1,595,922,341 samples, 0.23%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +ssl_protector_protect (3,148,394,698 samples, 0.45%) + + + +[[kernel.kallsyms]] (1,964,733,664 samples, 0.28%) + + + +__memmove_avx_unaligned_erms (84,869,700 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (241,526,097 samples, 0.03%) + + + +[[kernel.kallsyms]] (716,672,479 samples, 0.10%) + + + +all (697,043,771,444 samples, 100%) + + + +NKikimr::NTable::TDatabaseImpl::Get (233,812,262 samples, 0.03%) + + + +NKikimr::TTablet::HandleNext (612,944,723 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (1,736,136,545 samples, 0.25%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +[[kernel.kallsyms]] (82,402,859 samples, 0.01%) + + + +NYql::NDq::TDqInputImpl<NYql::NDq::TDqAsyncInputBuffer, NYql::NDq::IDqAsyncInputBuffer>::Pop (157,977,785 samples, 0.02%) + + + +NActors::TActorIdentity::Send< (83,194,686 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::__append (120,834,312 samples, 0.02%) + + + +TCMallocInternalNewArray (167,717,117 samples, 0.02%) + + + +[ydbd] (85,060,480 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::(anonymous namespace)::do_free_pages (79,691,930 samples, 0.01%) + + + +NKikimr::NMiniKQL::GetUnboxedValueSize (2,217,415,115 samples, 0.32%) + + + +NKikimr::NDataShard::TTableLocks::AddPointLock (3,360,711,467 samples, 0.48%) + + + +BIO_write (330,973,902 samples, 0.05%) + + + +NKikimrTxDataShard::TEvReadResult::_InternalParse (2,212,713,632 samples, 0.32%) + + + +std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >::reserve (167,457,566 samples, 0.02%) + + + +[[kernel.kallsyms]] (572,886,179 samples, 0.08%) + + + +[[kernel.kallsyms]] (605,971,687 samples, 0.09%) + + + +clock_nanosleep@GLIBC_2.2.5 (66,549,211 samples, 0.01%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (167,389,202 samples, 0.02%) + + + +google::protobuf::Arena::CreateMaybeMessage<Ydb::Value> (85,390,392 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::ReportStats (327,770,974 samples, 0.05%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::ReadRange (1,266,372,339 samples, 0.18%) + + + +[[kernel.kallsyms]] (1,843,346,737 samples, 0.26%) + + + +NKikimr::NDataShard::TDataShard::DeleteReadIterator (1,419,753,619 samples, 0.20%) + + + +google::protobuf::internal::WireFormatLite::InternalWriteMessage (246,768,344 samples, 0.04%) + + + +NYql::NDq::TDqComputeActorChannels::OutCh (1,488,504,569 samples, 0.21%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::Populate (88,518,252 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (126,692,228 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (243,422,616 samples, 0.03%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (84,782,227 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::~TBlobStorageGroupPutRequest (686,467,721 samples, 0.10%) + + + +[[kernel.kallsyms]] (5,583,359,584 samples, 0.80%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (123,408,441 samples, 0.02%) + + + +NKikimr::NKqp::TKqpLookupRows::FillReadRequest (1,337,399,539 samples, 0.19%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::TReadAsFilledMailbox> (176,827,526,795 samples, 25.37%) +NActors::TGenericExecutorThread::Execute.. + + +TCMallocInternalNewArray (127,084,128 samples, 0.02%) + + + +NKikimr::NDataShard::TDependencyTracker::TMvccDependencyTrackingLogic::AddOperation (122,597,968 samples, 0.02%) + + + +NActors::TInterconnectSessionTCP::HandleRam (2,227,271,884 samples, 0.32%) + + + +ydbd (83,479,841 samples, 0.01%) + + + +rm_isr (66,612,895 samples, 0.01%) + + + +std::__y1::vector<NKikimr::NDataShard::TPointKey, std::__y1::allocator<NKikimr::NDataShard::TPointKey> >::__emplace_back_slow_path<NKikimr::NDataShard::TPointKey const&> (81,938,085 samples, 0.01%) + + + +[[kernel.kallsyms]] (79,633,415 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (168,180,707 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,013,285,200 samples, 0.15%) + + + +[[kernel.kallsyms]] (81,130,538 samples, 0.01%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::UnpackBatch (12,804,651,664 samples, 1.84%) +N.. + + +[[kernel.kallsyms]] (81,900,914 samples, 0.01%) + + + +NYql::(anonymous namespace)::TContigousChunkOverBuf::~TContigousChunkOverBuf (84,875,105 samples, 0.01%) + + + +NActors::TStatsCollectingActor::SetAggregatedCounters (1,069,206,767 samples, 0.15%) + + + +NKikimr::NTable::TPartIter::Apply (12,482,395,876 samples, 1.79%) + + + +std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >::__resize_default_init[abi:v180000] (295,912,577 samples, 0.04%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::GetReadTxMap (604,699,036 samples, 0.09%) + + + +google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::~RepeatedPtrField (85,488,842 samples, 0.01%) + + + +google::protobuf::io::EpsCopyOutputStream::WriteStringMaybeAliasedOutline (126,564,087 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::PollAsyncInput (125,713,288,212 samples, 18.04%) +NYql::NDq::TDqComputeActorBa.. + + +NKikimr::NTable::TRemap::TRemap (564,454,178 samples, 0.08%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (156,480,588 samples, 0.02%) + + + +NActors::TInputSessionTCP::Handle (2,542,957,660 samples, 0.36%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::ProcessOutputsImpl (12,378,442,062 samples, 1.78%) + + + +NActors::IEventHandle::Get<NKikimr::TEvDataShard::TEvReadResult> (4,613,218,609 samples, 0.66%) + + + +NActors::TBasicExecutorPool::GetCurrentStats (3,445,502,862 samples, 0.49%) + + + +[[kernel.kallsyms]] (91,311,083 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (348,666,442 samples, 0.05%) + + + +[[vdso]] (228,911,025 samples, 0.03%) + + + +TCMallocInternalAlignedAlloc (254,340,725 samples, 0.04%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (91,624,269 samples, 0.01%) + + + +NKikimr::NTable::TBounds::CompareLastKeySearchKey (386,767,831 samples, 0.06%) + + + +[[kernel.kallsyms]] (278,035,097 samples, 0.04%) + + + +NYql::NDq::TDqComputeActorChannels::SendChannelData (237,187,595 samples, 0.03%) + + + +syscall (1,750,489,729 samples, 0.25%) + + + +NKikimr::NTable::TRemap::~TRemap (8,907,285,288 samples, 1.28%) + + + +NYql::NDq::(anonymous namespace)::EstimateIntegralDataSize (360,947,425 samples, 0.05%) + + + +[[kernel.kallsyms]] (382,380,239 samples, 0.05%) + + + +[[kernel.kallsyms]] (82,402,859 samples, 0.01%) + + + +NKikimr::NTable::TTable::Select (4,141,251,973 samples, 0.59%) + + + +NKikimr::NDriverClient::NewClient (74,793,962 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (128,228,010 samples, 0.02%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +NYql::NDq::TDqComputeActorChannels::CanSendChannelData (1,572,244,756 samples, 0.23%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::Finish (896,499,387 samples, 0.13%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (608,114,450 samples, 0.09%) + + + +[[kernel.kallsyms]] (544,380,745 samples, 0.08%) + + + +[[kernel.kallsyms]] (1,101,448,353 samples, 0.16%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (85,390,392 samples, 0.01%) + + + +NKikimr::NTable::TDatabase::Select (124,370,796,735 samples, 17.84%) +NKikimr::NTable::TDatabase:.. + + +__memmove_avx_unaligned_erms (331,916,979 samples, 0.05%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::ForEachRow<NYql::NDq::TDqInputImpl<NYql::NDq::TDqInputChannelImpl, NYql::NDq::IDqInputChannel>::Pop (127,656,603 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::HasSchemaChanges (606,466,744 samples, 0.09%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (82,227,880 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (288,814,487 samples, 0.04%) + + + +NKikimr::NKqp::TKqpLookupRows::AddInputRow (1,085,772,953 samples, 0.16%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (84,196,936 samples, 0.01%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum>, std::__y1::__unordered_map_hasher<std::__y1::pair<unsigned char, unsigned int>, std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum>, std::__y1::hash<std::__y1::pair<unsigned char, unsigned int> >, std::__y1::equal_to<std::__y1::pair<unsigned char, unsigned int> >, true>, std::__y1::__unordered_map_equal<std::__y1::pair<unsigned char, unsigned int>, std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum>, std::__y1::equal_to<std::__y1::pair<unsigned char, unsigned int> >, std::__y1::hash<std::__y1::pair<unsigned char, unsigned int> >, true>, std::__y1::allocator<std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum> > >::__emplace_unique_key_args<std::__y1::pair<unsigned char, unsigned int>, std::__y1::piecewise_construct_t const&, std::__y1::tuple<std::__y1::pair<unsigned char, unsigned int> const&>, std::__y1::tuple<> > (124,112,106 samples, 0.02%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +[[kernel.kallsyms]] (81,973,943 samples, 0.01%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +NKikimrTxDataShard::TEvReadResult::~TEvReadResult (516,789,049 samples, 0.07%) + + + +_nv041477rm (66,612,895 samples, 0.01%) + + + +NActors::TThreadParkPad::Park (83,259,855 samples, 0.01%) + + + +NKikimr::TOwnedCellVecBatch::Append (5,428,190,652 samples, 0.78%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::CheckRequestAndInit (6,230,565,948 samples, 0.89%) + + + +ydbd.Batch (79,908,360 samples, 0.01%) + + + +[[kernel.kallsyms]] (83,452,743 samples, 0.01%) + + + +NActors::TExecutorThread::ThreadProc (19,734,480,369 samples, 2.83%) +NA.. + + +[[kernel.kallsyms]] (1,011,633,173 samples, 0.15%) + + + +ParameterizedMain (74,793,962 samples, 0.01%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +TCMallocInternalAlignedAlloc (168,749,494 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (60,940,182 samples, 0.01%) + + + +NKikimr::NTable::TPartIter::Apply (14,410,544,882 samples, 2.07%) +N.. + + +NKikimr::NMetrics::TResourceMetricsSendState::FillChanged (84,575,296 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (243,422,616 samples, 0.03%) + + + +start_thread (79,908,360 samples, 0.01%) + + + +[[kernel.kallsyms]] (376,955,197 samples, 0.05%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +NActors::UnlockFromExecution<NActors::TMailboxTable::THTSwapMailbox> (79,582,020 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (1,636,719,191 samples, 0.23%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +[[kernel.kallsyms]] (84,169,831 samples, 0.01%) + + + +[[kernel.kallsyms]] (3,264,544,875 samples, 0.47%) + + + +NActors::TActorIdentity::Send< (14,728,932,584 samples, 2.11%) +N.. + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (10,105,817,775 samples, 1.45%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (124,550,696 samples, 0.02%) + + + +NYql::NDq::TDqInputImpl<NYql::NDq::TDqInputChannelImpl, NYql::NDq::IDqInputChannel>::Pop (123,553,589 samples, 0.02%) + + + +NKikimr::NMiniKQL::NDetails::PackDecimal<NKikimr::NMiniKQL::TPagedBuffer> (688,009,928 samples, 0.10%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (8,135,346,302 samples, 1.17%) + + + +[[kernel.kallsyms]] (109,011,146 samples, 0.02%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::OnResponse (309,780,844 samples, 0.04%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +std::__y1::vector<NKikimr::NTable::TCellOp, NPrivate::TStackBasedAllocator<NKikimr::NTable::TCellOp, 64ul, true, std::__y1::allocator<NKikimr::NTable::TCellOp> > >::assign (368,634,933 samples, 0.05%) + + + +[[kernel.kallsyms]] (187,092,026 samples, 0.03%) + + + +google::protobuf::internal::ArenaStringPtr::Set (1,427,555,871 samples, 0.20%) + + + +[[kernel.kallsyms]] (84,169,831 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::DoExecute (251,205,976,993 samples, 36.04%) +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeA.. + + +NKikimr::ComparePrefixBorders (1,225,002,420 samples, 0.18%) + + + +NKikimr::NTabletPipe::TClient::Push (1,422,125,148 samples, 0.20%) + + + +tcmalloc::tcmalloc_internal::HugePageFiller<tcmalloc::tcmalloc_internal::PageTracker<&tcmalloc::tcmalloc_internal::SystemRelease> >::Put (79,691,930 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (615,432,745 samples, 0.09%) + + + +[[kernel.kallsyms]] (84,169,831 samples, 0.01%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (79,908,360 samples, 0.01%) + + + +[[kernel.kallsyms]] (81,900,914 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (125,575,522 samples, 0.02%) + + + +NKikimr::TBlackboard::RunStrategy (546,456,179 samples, 0.08%) + + + +NKikimrTxDataShard::TEvRead::~TEvRead (543,239,608 samples, 0.08%) + + + +[[kernel.kallsyms]] (466,691,733 samples, 0.07%) + + + +NActors::TGenericExecutorThread::Send< (481,101,083 samples, 0.07%) + + + +NKikimr::NTable::TPartIter::~TPartIter (800,743,440 samples, 0.11%) + + + +NActors::TInputSessionTCP::PreallocateBuffers (696,459,195 samples, 0.10%) + + + +_nv031605rm (66,612,895 samples, 0.01%) + + + +NKikimr::NDataShard::(anonymous namespace)::TShortTableInfo::TShortTableInfo (253,801,504 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (343,689,318 samples, 0.05%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::BuildMeta (127,027,127 samples, 0.02%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (2,192,512,973 samples, 0.31%) + + + +google::protobuf::internal::ThreadSafeArena::~ThreadSafeArena (28,062,948,429 samples, 4.03%) +goog.. + + +NActors::TGenericExecutorThread::RegisterActor< (71,244,520 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (61,582,422 samples, 0.01%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (81,645,185 samples, 0.01%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (83,194,686 samples, 0.01%) + + + +NKikimr::NDataShard::(anonymous namespace)::TCellBlockBuilder::AddRow (254,086,439 samples, 0.04%) + + + +[[kernel.kallsyms]] (2,762,912,901 samples, 0.40%) + + + +[[kernel.kallsyms]] (1,950,499,736 samples, 0.28%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +NYql::NDq::(anonymous namespace)::TDqInputUnionStreamValue<false>::Fetch (36,722,904,327 samples, 5.27%) +NYql::.. + + +NYql::NDq::TDqComputeActorChannels::OutCh (1,238,162,901 samples, 0.18%) + + + +[[kernel.kallsyms]] (963,214,537 samples, 0.14%) + + + +[[kernel.kallsyms]] (5,542,877,237 samples, 0.80%) + + + +UdfFreeWithSize (80,971,150 samples, 0.01%) + + + +[[kernel.kallsyms]] (565,334,822 samples, 0.08%) + + + +[[kernel.kallsyms]] (1,922,291,711 samples, 0.28%) + + + +NKikimr::NKqp::TEvKqpExecuter::TEvStreamData::~TEvStreamData (28,480,969,937 samples, 4.09%) +NKik.. + + +NKikimr::NTable::TPartScheme::MakePinout (1,400,122,739 samples, 0.20%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (132,170,799 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::EnsureReadOnlyLease (579,008,709 samples, 0.08%) + + + +google::protobuf::internal::ParseContext::ParseMessage (278,411,638 samples, 0.04%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (167,457,566 samples, 0.02%) + + + +[[kernel.kallsyms]] (283,337,448 samples, 0.04%) + + + +NKikimr::TOwnedCellVecBatch::Append (88,058,904 samples, 0.01%) + + + +[[kernel.kallsyms]] (942,313,498 samples, 0.14%) + + + +NKikimrTxDataShard::TEvReadResult_TCellVecBatch::~TEvReadResult_TCellVecBatch (122,780,035 samples, 0.02%) + + + +scsi_io_completion (234,924,989 samples, 0.03%) + + + +NActors::IEventHandle::Get<NKikimr::TEvDataShard::TEvRead> (2,285,591,924 samples, 0.33%) + + + +grpc_core::promise_filter_detail::ServerCallData::StartBatch (93,198,523 samples, 0.01%) + + + +google::protobuf::Arena::AllocateAlignedWithCleanup (716,396,247 samples, 0.10%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (566,235,540 samples, 0.08%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (257,149,115 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::ReleaseToSpans (724,142,193 samples, 0.10%) + + + +NActors::TInputSessionTCP::ReceiveData (2,348,842,733 samples, 0.34%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (83,342,033 samples, 0.01%) + + + +[[kernel.kallsyms]] (18,137,560,365 samples, 2.60%) +[[.. + + +bread_conv (964,309,806 samples, 0.14%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +TCMallocInternalNewArray (84,788,191 samples, 0.01%) + + + +NKikimr::NMemory::TMemoryTrackerActor::UpdateDynamicCounters (388,050,573 samples, 0.06%) + + + +[unknown] (472,388,579 samples, 0.07%) + + + +grpc_event_engine::experimental::MemoryAllocator::MakeSlice (81,748,626 samples, 0.01%) + + + +set_stack_base (78,571,986 samples, 0.01%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,087,369,554 samples, 0.16%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpStreamLookupActor::ProcessInputRows (77,710,388,011 samples, 11.15%) +NKikimr::NKqp::(.. + + +nft_do_chain_ipv4 (123,044,795 samples, 0.02%) + + + +NKikimr::TBlackboard::RegisterBlobForPut (1,190,058,724 samples, 0.17%) + + + +NYql::NDq::(anonymous namespace)::EstimateSizeImpl (1,947,420,887 samples, 0.28%) + + + +NKikimr::TOwnedTableRange::TOwnedTableRange (1,131,307,521 samples, 0.16%) + + + +NKikimr::NMemory::TMemoryTrackerActor::Collect (477,852,176 samples, 0.07%) + + + +NKikimrTxDataShard::TEvReadResult_TCellVecBatch::_InternalParse (2,212,713,632 samples, 0.32%) + + + +NYql::NDq::TComputeActorAsyncInputHelper::PollAsyncInput (104,004,126,830 samples, 14.92%) +NYql::NDq::TComputeAct.. + + +std::__y1::__shared_ptr_pointer<NKikimr::TTabletPercentileCounter*, void (85,912,623 samples, 0.01%) + + + +NKikimr::TEvDataShard::TEvRead::FillRecord (434,982,382 samples, 0.06%) + + + +NKikimr::TQuorumCheckerOrdinary::GetBlobState (369,021,474 samples, 0.05%) + + + +NKikimr::NTable::TRemap::~TRemap (217,971,605 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (164,772,688,172 samples, 23.64%) +NKikimr::NTabletFlatExecutor::TExecut.. + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::LockAndAlloc (84,544,199 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (696,628,680 samples, 0.10%) + + + +__memset_avx2_unaligned_erms (149,752,075 samples, 0.02%) + + + +[[kernel.kallsyms]] (419,945,968 samples, 0.06%) + + + +__memset_avx2_unaligned_erms (430,288,978 samples, 0.06%) + + + +std::__y1::deque<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> >::__add_back_capacity (124,758,998 samples, 0.02%) + + + +[[kernel.kallsyms]] (572,886,227 samples, 0.08%) + + + +NRopeDetails::TChunkList<TRcBuf>::Erase (344,182,776 samples, 0.05%) + + + +[[kernel.kallsyms]] (870,105,719 samples, 0.12%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (2,238,811,896 samples, 0.32%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::StateWork (2,834,037,615 samples, 0.41%) + + + +TEventHolder::Fill (4,060,894,703 samples, 0.58%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +syscall (571,843,996 samples, 0.08%) + + + +SSL_write (1,600,459,836 samples, 0.23%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (85,159,770 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (168,837,935 samples, 0.02%) + + + +NActors::TMailboxTable::SendTo (115,079,469 samples, 0.02%) + + + +bio_write_intern (288,073,191 samples, 0.04%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (900,028,587 samples, 0.13%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TryUnload (2,463,154,033 samples, 0.35%) + + + +[[kernel.kallsyms]] (91,311,083 samples, 0.01%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::AllocSmall (126,535,109 samples, 0.02%) + + + +std::__y1::__shared_ptr_emplace<NKikimr::NMiniKQL::TPagedBuffer, std::__y1::allocator<NKikimr::NMiniKQL::TPagedBuffer> >::__on_zero_shared (344,182,776 samples, 0.05%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +start_thread (626,428,887,408 samples, 89.87%) +start_thread + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (990,086,239 samples, 0.14%) + + + +[[kernel.kallsyms]] (109,011,146 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (89,357,680 samples, 0.01%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::ForEachRow<NYql::NDq::TDqInputImpl<NYql::NDq::TDqInputChannelImpl, NYql::NDq::IDqInputChannel>::Pop (123,553,589 samples, 0.02%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +[ydbd] (597,650,045 samples, 0.09%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (12,681,594,409 samples, 1.82%) +N.. + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (1,944,525,719 samples, 0.28%) + + + +NKikimrTxDataShard::TEvReadResult::ByteSizeLong (71,095,781 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::RemoveRange (162,215,380 samples, 0.02%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::insert_unique<std::__y1::pair<unsigned int const, unsigned int> > (87,797,349 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (217,132,016 samples, 0.03%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +Ydb::Value::~Value (85,193,901 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (128,228,010 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (1,169,827,248 samples, 0.17%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (82,905,573 samples, 0.01%) + + + +[[kernel.kallsyms]] (60,067,796 samples, 0.01%) + + + +NKikimr::NDataShard::TSysLocks::HasCurrentWriteLock (417,360,550 samples, 0.06%) + + + +[[kernel.kallsyms]] (466,691,733 samples, 0.07%) + + + +NKikimr::SkipLabels (352,523,804 samples, 0.05%) + + + +NActors::TExecutorThread::ThreadProc (21,303,383,351 samples, 3.06%) +NAc.. + + +NActors::TInterconnectSessionTCP::WriteData (1,964,733,664 samples, 0.28%) + + + +[[kernel.kallsyms]] (19,193,553,230 samples, 2.75%) +[[.. + + +NKikimr::NMiniKQL::(anonymous namespace)::PackBlob<NKikimr::NMiniKQL::TPagedBuffer> (166,908,010 samples, 0.02%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::Head (169,756,472 samples, 0.02%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::GetRowId (118,459,157 samples, 0.02%) + + + +[[kernel.kallsyms]] (5,746,173,558 samples, 0.82%) + + + +NYql::NDq::TDqInputChannel::PushImpl (543,084,142 samples, 0.08%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (85,159,770 samples, 0.01%) + + + +[[kernel.kallsyms]] (18,844,113,617 samples, 2.70%) +[[.. + + +grpc_combiner_continue_exec_ctx (6,922,484,747 samples, 0.99%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (251,597,217 samples, 0.04%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (5,190,963,101 samples, 0.74%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +google::protobuf::internal::GenericSwap (128,228,010 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (514,146,023 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +__memmove_avx_unaligned_erms (281,366,265 samples, 0.04%) + + + +[[kernel.kallsyms]] (4,976,575,662 samples, 0.71%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned int> (381,345,643 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (124,043,736 samples, 0.02%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackImpl<false, false, NKikimr::NMiniKQL::TPagedBuffer> (5,010,829,685 samples, 0.72%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::ExtendRightKey (351,591,861 samples, 0.05%) + + + +[[kernel.kallsyms]] (605,971,687 samples, 0.09%) + + + +NActors::TActivationContext::LoggerSettings (167,403,043 samples, 0.02%) + + + +NKikimr::NTable::NPage::TDataPage::LookupKey (619,285,107 samples, 0.09%) + + + +[[kernel.kallsyms]] (572,886,211 samples, 0.08%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +[[kernel.kallsyms]] (120,574,966 samples, 0.02%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Apply (141,610,115 samples, 0.02%) + + + +TMemoryPool::AddChunk (1,138,981,760 samples, 0.16%) + + + +[[kernel.kallsyms]] (109,011,146 samples, 0.02%) + + + +google::protobuf::MessageLite::ParseFromZeroCopyStream (328,316,224 samples, 0.05%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +[[kernel.kallsyms]] (948,147,285 samples, 0.14%) + + + +[[kernel.kallsyms]] (3,208,854,386 samples, 0.46%) + + + +tcmalloc::tcmalloc_internal::Span::BuildFreelist (124,043,736 samples, 0.02%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (175,629,057 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::HugePageFiller<tcmalloc::tcmalloc_internal::PageTracker<&tcmalloc::tcmalloc_internal::SystemRelease> >::Put (60,053,689 samples, 0.01%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::~TDirectArrayHolderInplace (3,178,453,457 samples, 0.46%) + + + +[[kernel.kallsyms]] (646,118,832 samples, 0.09%) + + + +NKikimr::NDataShard::TCheckReadUnit::Execute (6,230,565,948 samples, 0.89%) + + + +[[kernel.kallsyms]] (742,147,468 samples, 0.11%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (205,371,497 samples, 0.03%) + + + +NKikimr::TEvDataShard::TEvReadResult::Load (4,613,218,609 samples, 0.66%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (2,128,366,254 samples, 0.31%) + + + +NActors::TGenericExecutorThreadCtx::Sleep<NActors::TExecutorThreadCtx, NActors::EThreadState> (1,066,080,955 samples, 0.15%) + + + +[[kernel.kallsyms]] (1,441,139,804 samples, 0.21%) + + + +[[kernel.kallsyms]] (2,079,491,832 samples, 0.30%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (376,138,798 samples, 0.05%) + + + +tcp_flush (168,156,481 samples, 0.02%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (278,035,097 samples, 0.04%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, std::__y1::__less<void, void>&, unsigned int*> (251,145,983 samples, 0.04%) + + + +NActors::TBasicExecutorPool::GetReadyActivationCommon (5,032,541,909 samples, 0.72%) + + + +google::protobuf::Arena::AllocateAlignedWithHook (786,391,835 samples, 0.11%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned int> (334,698,558 samples, 0.05%) + + + +google::protobuf::MessageLite::SerializePartialToZeroCopyStream (469,834,146 samples, 0.07%) + + + +nf_nat_inet_fn (92,709,613 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (83,194,686 samples, 0.01%) + + + +NKikimr::NTable::TCelled::TCelled (120,549,834 samples, 0.02%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (616,301,416,185 samples, 88.42%) +NActors::TGenericExecutorThread::ProcessExecutorPool + + +operator==<unsigned int, unsigned int, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> > (97,476,575 samples, 0.01%) + + + +google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::~RepeatedPtrField (516,789,049 samples, 0.07%) + + + +NKikimr::NKqp::TKqpComputeActor::StateFunc (257,894,349,173 samples, 37.00%) +NKikimr::NKqp::TKqpComputeActor::StateFunc + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (86,201,275 samples, 0.01%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned long> (382,716,931 samples, 0.05%) + + + +NKikimr::TTablet::Handle (357,564,177 samples, 0.05%) + + + +[[kernel.kallsyms]] (572,886,179 samples, 0.08%) + + + +google::protobuf::internal::ParseContext::ParseMessage (133,305,569 samples, 0.02%) + + + +NHPTimer::GetSeconds (303,582,630 samples, 0.04%) + + + +[[kernel.kallsyms]] (1,101,448,353 samples, 0.16%) + + + +NKikimr::NTable::TBounds::CompareSearchKeyFirstKey (373,560,213 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (1,302,085,466 samples, 0.19%) + + + +[[kernel.kallsyms]] (3,264,544,875 samples, 0.47%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::Populate (499,528,299 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,758,139,553 samples, 0.25%) + + + +[[kernel.kallsyms]] (126,991,987 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (343,689,318 samples, 0.05%) + + + +old_sort::__sort3[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (604,268,003 samples, 0.09%) + + + +grpc_chttp2_begin_write (133,094,135 samples, 0.02%) + + + +std::__y1::deque<NKikimr::NTable::TPartIter, std::__y1::allocator<NKikimr::NTable::TPartIter> >::emplace_back<NKikimr::NTable::TPart const*&, TArrayRef<unsigned int const>&, TIntrusiveConstPtr<NKikimr::NTable::TKeyCellDefaults, TDefaultIntrusivePtrOps<NKikimr::NTable::TKeyCellDefaults> > const&, NKikimr::NTable::IPages*&> (1,443,260,671 samples, 0.21%) + + + +NKikimr::NMiniKQL::MakeStringNotFilled (879,296,506 samples, 0.13%) + + + +non-virtual thunk to NKikimr::NTabletFlatExecutor::TExecutor::Execute (696,628,680 samples, 0.10%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (545,150,100 samples, 0.08%) + + + +[[kernel.kallsyms]] (963,210,538 samples, 0.14%) + + + +syscall (147,610,442 samples, 0.02%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::StateFunc (1,195,522,548 samples, 0.17%) + + + +[[kernel.kallsyms]] (867,960,648 samples, 0.12%) + + + +[[kernel.kallsyms]] (212,881,315 samples, 0.03%) + + + +[[kernel.kallsyms]] (81,973,943 samples, 0.01%) + + + +google::protobuf::internal::InlineGreedyStringParser (1,423,866,494 samples, 0.20%) + + + +NThreading::TLegacyFuture<void, false>::DoExecute (24,887,865,221 samples, 3.57%) +NTh.. + + +[[kernel.kallsyms]] (733,078,110 samples, 0.11%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NActors::TActivationContextHolder::operator (170,333,349 samples, 0.02%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +__memset_avx2_unaligned_erms (163,669,092 samples, 0.02%) + + + +[[kernel.kallsyms]] (81,973,943 samples, 0.01%) + + + +google::protobuf::internal::ParseContext::ParseMessage (2,212,713,632 samples, 0.32%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (10,155,278,920 samples, 1.46%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (130,494,694 samples, 0.02%) + + + +evp_EncryptDecryptUpdate (337,069,428 samples, 0.05%) + + + +__memmove_avx_unaligned_erms (878,716,394 samples, 0.13%) + + + +[[kernel.kallsyms]] (120,574,966 samples, 0.02%) + + + +__GI___pthread_disable_asynccancel (512,195,295 samples, 0.07%) + + + +[[kernel.kallsyms]] (120,574,966 samples, 0.02%) + + + +MicroSeconds (228,911,025 samples, 0.03%) + + + +syscall (91,311,083 samples, 0.01%) + + + +[[kernel.kallsyms]] (81,900,914 samples, 0.01%) + + + +[[kernel.kallsyms]] (467,863,379 samples, 0.07%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::TReadAsFilledMailbox> (5,316,463,420 samples, 0.76%) + + + +NActors::TActivationContext::Send< (11,656,351,442 samples, 1.67%) + + + +WPACKET_put_bytes__ (86,418,905 samples, 0.01%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Release (177,547,315 samples, 0.03%) + + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +[[kernel.kallsyms]] (110,235,896 samples, 0.02%) + + + +NActors::TInputSessionTCP::WorkingState (2,409,824,184 samples, 0.35%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (602,035,175 samples, 0.09%) + + + +NKikimr::NTable::NBloom::TPrefix::TPrefix (909,802,625 samples, 0.13%) + + + +[[kernel.kallsyms]] (961,387,976 samples, 0.14%) + + + +tls13_enc (631,425,040 samples, 0.09%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (278,035,097 samples, 0.04%) + + + +NActors::TRopeStream::Next (214,579,809 samples, 0.03%) + + + +_nv041459rm (66,612,895 samples, 0.01%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (127,656,603 samples, 0.02%) + + + +NYql::NDq::TComputeActorAsyncInputHelperSync::GetFreeSpace (552,005,503 samples, 0.08%) + + + +[[kernel.kallsyms]] (110,235,896 samples, 0.02%) + + + +NKikimr::NKqp::TKqpReadActor::GetAsyncInputData (400,291,743 samples, 0.06%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (1,211,227,213 samples, 0.17%) + + + +[[kernel.kallsyms]] (211,424,172 samples, 0.03%) + + + +grpc_call_start_batch (7,015,683,270 samples, 1.01%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::AddItem (28,685,845,072 samples, 4.12%) +NKik.. + + +TRcBuf::TBackend::VisitRaw<TRcBuf::TBackend::TBackendHolder, TRcBuf::TBackend::Destroy<TRcBuf::TBackend::TBackendHolder> (344,182,776 samples, 0.05%) + + + +NKikimr::TTabletMon::TTabletCountersForTabletType::TSolomonCounters::Apply (736,690,228 samples, 0.11%) + + + +[[kernel.kallsyms]] (155,950,608 samples, 0.02%) + + + +NKikimr::NKqp::TQueryData::ExtractTrailingTxResult (128,228,010 samples, 0.02%) + + + +std::__y1::__function::__func<NKikimr::SkipLabels (83,265,467 samples, 0.01%) + + + +[[kernel.kallsyms]] (229,332,065 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::Span::FreelistPopBatchSized< (1,650,608,579 samples, 0.24%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (128,928,325 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (1,990,881,895 samples, 0.29%) + + + +[[kernel.kallsyms]] (13,680,390,046 samples, 1.96%) +[.. + + +NActors::TExecutorThreadCtx::WakeUp (572,886,227 samples, 0.08%) + + + +NYql::NDq::TDqComputeActorChannels::OutCh (84,688,777 samples, 0.01%) + + + +[[kernel.kallsyms]] (572,886,227 samples, 0.08%) + + + +NActors::TPoolInfo::PullStats (230,014,505 samples, 0.03%) + + + +Ydb::Query::ExecuteQueryResponsePart::~ExecuteQueryResponsePart (85,193,901 samples, 0.01%) + + + +THashTable<NKikimr::TPathId, NKikimr::TPathId, THash<NKikimr::TPathId>, TIdentity, TEqualTo<NKikimr::TPathId>, std::__y1::allocator<NKikimr::TPathId> >::insert_unique_noresize<NKikimr::TPathId> (205,792,078 samples, 0.03%) + + + +NKikimr::TEvDataShard::TEvReadResult::~TEvReadResult (895,548,352 samples, 0.13%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,013,311,083 samples, 0.15%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::Pop (84,970,809 samples, 0.01%) + + + +NRopeDetails::TChunkList<TRcBuf>::Pop (127,501,843 samples, 0.02%) + + + +[[kernel.kallsyms]] (83,902,018 samples, 0.01%) + + + +Ydb::Value::MergeFrom (128,228,010 samples, 0.02%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpDataExecuter::ExecuteState (61,847,421,627 samples, 8.87%) +NKikimr::NKq.. + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +NActors::TCoroutineChunkSerializer::DoRun (469,834,146 samples, 0.07%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +NActors::IActor::Send (278,035,097 samples, 0.04%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (2,565,163,257 samples, 0.37%) + + + +NActors::TExecutorThread::ThreadProc (79,908,360 samples, 0.01%) + + + +NKikimr::NDataShard::TBuildAndWaitDependenciesUnit::Execute (164,233,038 samples, 0.02%) + + + +NKikimr::IsSystemColumn (6,000,819,639 samples, 0.86%) + + + +NKikimr::CompareTypedCells (144,505,099 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (131,521,330 samples, 0.02%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (19,734,480,369 samples, 2.83%) +NA.. + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TInfo::EnsurePage (314,617,827 samples, 0.05%) + + + +start_thread (19,734,480,369 samples, 2.83%) +st.. + + +Ydb::ResultSet::MergeFrom (128,228,010 samples, 0.02%) + + + +[[kernel.kallsyms]] (886,659,378 samples, 0.13%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<__int128> (451,568,551 samples, 0.06%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (132,630,881 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (119,521,618 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (84,795,491 samples, 0.01%) + + + +start_thread (24,887,865,221 samples, 3.57%) +sta.. + + +[[kernel.kallsyms]] (942,313,498 samples, 0.14%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::SendToVDisk (291,687,365 samples, 0.04%) + + + +[[kernel.kallsyms]] (419,842,363 samples, 0.06%) + + + +NKikimrTxDataShard::TEvReadResult_TCellVecBatch::_InternalSerialize (469,834,146 samples, 0.07%) + + + +NKikimr::NMiniKQL::THolderFactory::CreateDirectArrayHolder (258,027,295 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::Delete (79,691,930 samples, 0.01%) + + + +NYql::NDq::TDqDataSerializer::Deserialize (543,084,142 samples, 0.08%) + + + +google::protobuf::internal::AllocateMemory (168,837,935 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (165,042,353 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,016,912,246 samples, 0.15%) + + + +std::__y1::vector<NKikimr::NTable::TRemap::TPin, NPrivate::TStackBasedAllocator<NKikimr::NTable::TRemap::TPin, 16ul, true, std::__y1::allocator<NKikimr::NTable::TRemap::TPin> > >::reserve (118,695,180 samples, 0.02%) + + + +NActors::TActivationContext::Monotonic (134,410,243 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::LockAndAlloc (126,535,109 samples, 0.02%) + + + +std::__y1::vector<NKikimr::TSerializedCellVec, std::__y1::allocator<NKikimr::TSerializedCellVec> >::__destroy_vector::operator (834,379,500 samples, 0.12%) + + + +NKikimr::CompareTypedCells (501,872,037 samples, 0.07%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (85,209,304 samples, 0.01%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Start (78,154,069 samples, 0.01%) + + + +[[kernel.kallsyms]] (250,494,357 samples, 0.04%) + + + +NKikimr::ComparePointAndRange<std::__y1::vector<NKikimr::NScheme::TTypeInfo, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> > > (62,034,136,604 samples, 8.90%) +NKikimr::Com.. + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::TOutputChannelInfo::DrainChannel (944,761,540 samples, 0.14%) + + + +NYql::NDq::TDqComputeActorMetrics::ReportEvent (264,330,800 samples, 0.04%) + + + +NKikimr::NDataShard::TLocksDataShardAdapter<NKikimr::NDataShard::TDataShard>::IncCounter (88,152,857 samples, 0.01%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (207,118,399 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::Lookup (1,375,817,536 samples, 0.20%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (335,247,052 samples, 0.05%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +NActors::TExecutorThreadStats::Aggregate (1,047,074,639 samples, 0.15%) + + + +[[kernel.kallsyms]] (1,146,134,197 samples, 0.16%) + + + +[[kernel.kallsyms]] (499,949,229 samples, 0.07%) + + + +NKikimr::NDataShard::(anonymous namespace)::ToRawTypeValue (580,756,155 samples, 0.08%) + + + +[[kernel.kallsyms]] (326,242,673 samples, 0.05%) + + + +std::__y1::allocator<NKikimr::TSerializedCellVec>::construct[abi:v180000]<NKikimr::TSerializedCellVec, TBasicString<char, std::__y1::char_traits<char> > const&> (1,107,804,680 samples, 0.16%) + + + +grpc_chttp2_encode_data (81,862,991 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (60,053,689 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (84,758,862 samples, 0.01%) + + + +Ydb::ResultSet::MergeFrom (166,976,232 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::insert_unique<std::__y1::pair<unsigned int const, unsigned int> > (12,345,673,516 samples, 1.77%) + + + +[[kernel.kallsyms]] (206,176,033 samples, 0.03%) + + + +[[kernel.kallsyms]] (572,886,227 samples, 0.08%) + + + +ssl3_write_bytes (1,557,847,658 samples, 0.22%) + + + +[[vdso]] (3,684,175,559 samples, 0.53%) + + + +__memset_avx2_unaligned_erms (988,081,821 samples, 0.14%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpStreamLookupActor::GetAsyncInputData (102,312,539,270 samples, 14.68%) +NKikimr::NKqp::(anonym.. + + +__memcmp_avx2_movbe (26,959,273,367 samples, 3.87%) +__me.. + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (127,050,204 samples, 0.02%) + + + +[[kernel.kallsyms]] (212,881,315 samples, 0.03%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (1,490,618,607 samples, 0.21%) + + + +[[kernel.kallsyms]] (1,549,844,932 samples, 0.22%) + + + +TRcBuf::Uninitialized (696,459,195 samples, 0.10%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +NMonitoring::TExplicitHistogramCollector::Collect (122,603,445 samples, 0.02%) + + + +NActors::TActivationContext::Send< (88,282,852 samples, 0.01%) + + + +google::protobuf::MessageLite::SerializePartialToZeroCopyStream (553,203,006 samples, 0.08%) + + + +NActors::TDestructActor::WorkingState (548,297,138 samples, 0.08%) + + + +[[kernel.kallsyms]] (758,188,869 samples, 0.11%) + + + +NKikimr::NMiniKQL::PgReleaseThreadContext (83,254,276 samples, 0.01%) + + + +[[kernel.kallsyms]] (83,889,138 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (78,139,727 samples, 0.01%) + + + +NKikimr::NTable::TRowState::TRowState (217,516,226 samples, 0.03%) + + + +NActors::TActivationContext::LoggerSettings (214,527,418 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TCompactionLogic::GetBackingSize (88,186,616 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,061,534,413 samples, 0.15%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (508,721,395 samples, 0.07%) + + + +aesni_gcm_init_key (84,040,242 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,013,311,531 samples, 0.15%) + + + +[[kernel.kallsyms]] (499,254,012 samples, 0.07%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (5,164,950,933 samples, 0.74%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (4,015,283,525 samples, 0.58%) + + + +NActors::TInputSessionTCP::ReadMore (363,569,350 samples, 0.05%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::DoExecute (164,857,541,721 samples, 23.65%) +NKikimr::NTabletFlatExecutor::TExecut.. + + +TBasicString<char, std::__y1::char_traits<char> >::Clone (243,422,616 samples, 0.03%) + + + +[[kernel.kallsyms]] (126,991,987 samples, 0.02%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +[[kernel.kallsyms]] (82,402,859 samples, 0.01%) + + + +[[kernel.kallsyms]] (520,705,422 samples, 0.07%) + + + +google::protobuf::internal::ThreadSafeArena::Free (1,974,693,204 samples, 0.28%) + + + +NActors::TGenericExecutorThread::Send< (175,726,548 samples, 0.03%) + + + +ydbd.Scheduler (24,887,865,221 samples, 3.57%) +ydb.. + + +[[kernel.kallsyms]] (371,988,124 samples, 0.05%) + + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +NKikimr::TOwnedCellVecBatch::TOwnedCellVecBatch (252,615,102 samples, 0.04%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::~TReadOperation (3,259,725,836 samples, 0.47%) + + + +NActors::TExecutorThread::ThreadProc (626,428,885,511 samples, 89.87%) +NActors::TExecutorThread::ThreadProc + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (171,171,103 samples, 0.02%) + + + +NKikimr::NMiniKQL::THolderFactory::CreateDirectArrayHolder (85,236,023 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::Populate (124,043,736 samples, 0.02%) + + + +[[kernel.kallsyms]] (256,058,981 samples, 0.04%) + + + +[[kernel.kallsyms]] (212,881,315 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (81,835,718 samples, 0.01%) + + + +[[kernel.kallsyms]] (187,092,026 samples, 0.03%) + + + +TBasicString<char, std::__y1::char_traits<char> >::assign (545,150,100 samples, 0.08%) + + + +NKikimr::NTable::NPage::TFlatIndex::TFlatIndex (129,719,778 samples, 0.02%) + + + +[[kernel.kallsyms]] (457,419,484 samples, 0.07%) + + + +NKikimr::TEvDataShard::TEvReadResult::FillRecord (3,989,798,922 samples, 0.57%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (173,985,916 samples, 0.02%) + + + +[[kernel.kallsyms]] (164,712,850 samples, 0.02%) + + + +NKikimrTxDataShard::TEvRead::ByteSizeLong (83,413,783 samples, 0.01%) + + + +NYql::NUdf::TUnboxedValuePod::AsStringRef (514,976,528 samples, 0.07%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (166,976,232 samples, 0.02%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (466,382,465 samples, 0.07%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (381,075,895 samples, 0.05%) + + + +NKikimr::NDataShard::TDataShard::DoPeriodicTasks (999,433,375 samples, 0.14%) + + + +NKikimr::NCache::TSwitchableCache<NKikimr::NTabletFlatExecutor::TSharedPageCache::TPage, NKikimr::NTabletFlatExecutor::TSharedPageCache::TCompositeCachePageTraits>::TCacheHolder::Touch (331,394,749 samples, 0.05%) + + + +[[kernel.kallsyms]] (212,881,315 samples, 0.03%) + + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +NKikimr::NMiniKQL::MakeStringNotFilled (81,577,469 samples, 0.01%) + + + +std::__y1::__variant_detail::__visitation::__base::__dispatcher<0ul>::__dispatch[abi:v180000]<std::__y1::__variant_detail::__visitation::__variant::__value_visitor<NActors::TBasicExecutorPool::GetReadyActivationCommon (256,139,586 samples, 0.04%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (6,795,967,535 samples, 0.97%) + + + +google::protobuf::Message::MaybeComputeUnknownFieldsSize (495,752,368 samples, 0.07%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (84,875,105 samples, 0.01%) + + + +[[kernel.kallsyms]] (2,340,302,452 samples, 0.34%) + + + +google::protobuf::internal::UTF8GenericScan (3,002,609,827 samples, 0.43%) + + + +NKikimr::TTabletMon::Apply (736,690,228 samples, 0.11%) + + + +std::__y1::vector<TRope, std::__y1::allocator<TRope> >::__push_back_slow_path<TRope> (67,650,749 samples, 0.01%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::Read (6,169,624,220 samples, 0.89%) + + + +[[kernel.kallsyms]] (943,417,243 samples, 0.14%) + + + +NKikimr::TTabletCountersBase::operator= (343,864,348 samples, 0.05%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (82,802,900 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (920,693,026 samples, 0.13%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (125,451,961 samples, 0.02%) + + + +NKikimr::NMiniKQL::PgReleaseThreadContext (651,500,288 samples, 0.09%) + + + +NKikimr::NTable::TRowState::Set (84,432,265 samples, 0.01%) + + + +NKikimrTxDataShard::TEvRead::~TEvRead (85,488,842 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::New (88,518,252 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (4,836,690,857 samples, 0.69%) + + + +clock_nanosleep@GLIBC_2.2.5 (19,193,556,967 samples, 2.75%) +cl.. + + +__memmove_avx_unaligned_erms (126,316,786 samples, 0.02%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::__unordered_map_hasher<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::hash<unsigned long>, std::__y1::equal_to<unsigned long>, true>, std::__y1::__unordered_map_equal<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::equal_to<unsigned long>, std::__y1::hash<unsigned long>, true>, std::__y1::allocator<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > > > >::__emplace_unique_key_args<unsigned long, std::__y1::piecewise_construct_t const&, std::__y1::tuple<unsigned long const&>, std::__y1::tuple<> > (84,928,489 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShardLocksDb::MayAddLock (233,812,262 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (424,985,859 samples, 0.06%) + + + +[[kernel.kallsyms]] (646,118,832 samples, 0.09%) + + + +__memmove_avx_unaligned_erms (769,472,260 samples, 0.11%) + + + +[[kernel.kallsyms]] (83,889,138 samples, 0.01%) + + + +Ydb::ResultSet::~ResultSet (85,193,901 samples, 0.01%) + + + +[[kernel.kallsyms]] (290,167,391 samples, 0.04%) + + + +NKikimr::NMiniKQL::TPagedBuffer::Advance (125,439,480 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (1,375,817,536 samples, 0.20%) + + + +NKikimr::TTablet::CheckEntry (278,035,097 samples, 0.04%) + + + +NActors::TExecutorThreadCtx::WakeUp (571,843,996 samples, 0.08%) + + + +NYql::NDq::TDqInputChannel::Pop (543,084,142 samples, 0.08%) + + + +[[kernel.kallsyms]] (466,691,733 samples, 0.07%) + + + +NKikimr::NTable::TPartIter::~TPartIter (83,116,509 samples, 0.01%) + + + +google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::~RepeatedPtrField (543,239,608 samples, 0.08%) + + + +[[kernel.kallsyms]] (126,991,987 samples, 0.02%) + + + +NActors::TInputSessionTCP::ReceiveData (2,542,953,819 samples, 0.36%) + + + +[[kernel.kallsyms]] (326,242,673 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (124,598,623 samples, 0.02%) + + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (171,363,433 samples, 0.02%) + + + +NKikimr::NStorage::TDistributedConfigKeeper::ApplyStorageConfig (222,136,740 samples, 0.03%) + + + +[[kernel.kallsyms]] (419,842,363 samples, 0.06%) + + + +NKikimr::TTablet::MakeLogEntry (511,533,466 samples, 0.07%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (226,854,329 samples, 0.03%) + + + +[[kernel.kallsyms]] (499,254,012 samples, 0.07%) + + + +[[kernel.kallsyms]] (65,023,167 samples, 0.01%) + + + +[[kernel.kallsyms]] (84,291,998 samples, 0.01%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +NKikimr::TBlobState::Init (91,769,934 samples, 0.01%) + + + +std::__y1::__upper_bound[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::NPage::TCompare<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, TArrayRef<NKikimr::TCell const>, std::__y1::__identity> (10,836,782,022 samples, 1.55%) + + + +NKikimr::NTabletFlatExecutor::TTabletExecutedFlat::Execute (326,531,788 samples, 0.05%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (508,805,041 samples, 0.07%) + + + +NKikimr::NDataShard::TDataShard::SendImmediateReadResult (82,905,573 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::DoExecute (696,628,680 samples, 0.10%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::ReleaseToSpans (134,700,278 samples, 0.02%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::Destroy<google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::TypeHandler> (207,118,399 samples, 0.03%) + + + +NActors::TEvFreeItems::~TEvFreeItems (548,297,138 samples, 0.08%) + + + +NKikimr::ComparePrefixBorders (84,245,646 samples, 0.01%) + + + +NKikimr::TRestoreStrategy::EvaluateRestoreLayout (82,563,464 samples, 0.01%) + + + +NKikimr::NTable::TTable::Select (122,881,020,234 samples, 17.63%) +NKikimr::NTable::TTable::Se.. + + +NKikimr::NMiniKQL::(anonymous namespace)::PackImpl<false, false, NKikimr::NMiniKQL::TPagedBuffer> (16,097,168,200 samples, 2.31%) +N.. + + +[[kernel.kallsyms]] (80,319,683 samples, 0.01%) + + + +[[kernel.kallsyms]] (457,419,484 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,759,245,782 samples, 0.25%) + + + +NKikimr::NDataShard::TSysLocks::SetLock (1,035,576,004 samples, 0.15%) + + + +__memmove_avx_unaligned_erms (379,117,497 samples, 0.05%) + + + +[[kernel.kallsyms]] (369,021,474 samples, 0.05%) + + + +[[kernel.kallsyms]] (81,973,943 samples, 0.01%) + + + +[ydbd] (368,095,237 samples, 0.05%) + + + +google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::~RepeatedPtrField (207,118,399 samples, 0.03%) + + + +std::__y1::vector<NKikimr::NTable::TPartGroupRowIter, NPrivate::TStackBasedAllocator<NKikimr::NTable::TPartGroupRowIter, 16ul, true, std::__y1::allocator<NKikimr::NTable::TPartGroupRowIter> > >::__destroy_vector::operator (131,870,794 samples, 0.02%) + + + +NKikimr::NDataShard::TReadIteratorState::~TReadIteratorState (85,488,842 samples, 0.01%) + + + +Ydb::Query::ExecuteQueryResponsePart::ByteSizeLong (26,586,836,278 samples, 3.81%) +Ydb:.. + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::__assign_with_size[abi:v180000]<NKikimr::TCell const*, NKikimr::TCell const*> (82,600,376 samples, 0.01%) + + + +NKikimr::TAlignedPagePoolImpl<NKikimr::TSystemMmap>::~TAlignedPagePoolImpl (86,118,651 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::WriteData (1,964,733,664 samples, 0.28%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (89,357,680 samples, 0.01%) + + + +NActors::TActivationContextHolder::operator* (480,255,248 samples, 0.07%) + + + +[[kernel.kallsyms]] (211,424,172 samples, 0.03%) + + + +__libc_start_call_main (74,793,962 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::IsFull (804,129,245 samples, 0.12%) + + + +NActors::(anonymous namespace)::TSelfPingActor::RunningState (77,035,190 samples, 0.01%) + + + +NKikimr::TBlackboard::RunStrategies (546,456,179 samples, 0.08%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (124,043,736 samples, 0.02%) + + + +[[vdso]] (164,712,850 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (385,369,215 samples, 0.06%) + + + +NActors::TBasicSchedulerThread::CycleFunc (24,887,865,221 samples, 3.57%) +NAc.. + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (257,489,927 samples, 0.04%) + + + +TCMallocInternalNewArray (160,763,549 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::SendPeriodicTableStats (88,166,492 samples, 0.01%) + + + +NActors::TBasicExecutorPool::GetReadyActivationCommon (10,082,829,042 samples, 1.45%) + + + +NKikimr::NMiniKQL::TPagedBuffer::Advance (495,559,605 samples, 0.07%) + + + +NKikimr::TPutImpl::GenerateInitialRequests (1,190,058,724 samples, 0.17%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (83,887,100 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (499,528,299 samples, 0.07%) + + + +NYql::NDq::TDqComputeActorChannels::HasFreeMemoryInChannel (1,487,406,947 samples, 0.21%) + + + +[[kernel.kallsyms]] (369,021,474 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (305,919,496 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (171,363,433 samples, 0.02%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::__unordered_map_hasher<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::hash<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::equal_to<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, true>, std::__y1::__unordered_map_equal<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::equal_to<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::hash<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, true>, std::__y1::allocator<std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > > > >::find<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > > (4,790,588,459 samples, 0.69%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::Destroy<google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::TypeHandler> (85,488,842 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::ResumeBootstrap (1,971,824,736 samples, 0.28%) + + + +NKikimrTxDataShard::TEvReadResult::_InternalSerialize (469,834,146 samples, 0.07%) + + + +google::protobuf::internal::arena_destruct_object<TBasicString<char, std::__y1::char_traits<char> > > (21,673,955,998 samples, 3.11%) +goo.. + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::Lookup (5,344,971,997 samples, 0.77%) + + + +NKikimr::NGRpcService::TGRpcRequestWrapperImpl<273219757u, Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, false, NKikimr::NGRpcService::TGrpcRequestCall<Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, false> >::SendSerializedResult (7,228,884,164 samples, 1.04%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpSessionActor::ExecuteState (159,867,719 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,101,448,353 samples, 0.16%) + + + +[[kernel.kallsyms]] (499,528,299 samples, 0.07%) + + + +[[kernel.kallsyms]] (602,035,175 samples, 0.09%) + + + +NKikimr::TPutImpl::RunStrategy (546,456,179 samples, 0.08%) + + + +[[kernel.kallsyms]] (164,712,850 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (323,644,087 samples, 0.05%) + + + +NActors::TGenericExecutorThread::GetCurrentStats (2,173,920,801 samples, 0.31%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::AcquireLock (4,940,958,766 samples, 0.71%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +[[kernel.kallsyms]] (499,949,229 samples, 0.07%) + + + +[[kernel.kallsyms]] (77,276,068 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::IsFull (293,740,853 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (96,668,257 samples, 0.01%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +[[kernel.kallsyms]] (121,648,285 samples, 0.02%) + + + +[[kernel.kallsyms]] (572,886,227 samples, 0.08%) + + + +NActors::TActivationContext::Send< (610,374,145 samples, 0.09%) + + + +NKikimrTabletBase::TTabletLogEntry::~TTabletLogEntry (89,096,262 samples, 0.01%) + + + +google::protobuf::MessageLite::ParseFromZeroCopyStream (1,177,787,244 samples, 0.17%) + + + +std::__y1::__shared_ptr_emplace<NKikimr::NMiniKQL::TPagedBuffer, std::__y1::allocator<NKikimr::NMiniKQL::TPagedBuffer> >::__on_zero_shared (84,875,105 samples, 0.01%) + + + +NKikimr::NKqp::TKqpReadActor::PackCells (307,151,997 samples, 0.04%) + + + +NKikimr::NDataShard::TDataShard::SendWithConfirmedReadOnlyLease (82,905,573 samples, 0.01%) + + + +[[kernel.kallsyms]] (164,712,850 samples, 0.02%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::DoPush (34,639,011,702 samples, 4.97%) +NYql::.. + + +NActors::TInputSessionTCP::Read (109,016,354 samples, 0.02%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +std::__y1::__tree<std::__y1::__value_type<NKikimr::TLogoBlobID, NKikimr::TBlobState>, std::__y1::__map_value_compare<NKikimr::TLogoBlobID, std::__y1::__value_type<NKikimr::TLogoBlobID, NKikimr::TBlobState>, TLess<NKikimr::TLogoBlobID>, true>, std::__y1::allocator<std::__y1::__value_type<NKikimr::TLogoBlobID, NKikimr::TBlobState> > >::destroy (571,871,071 samples, 0.08%) + + + +[[kernel.kallsyms]] (499,949,229 samples, 0.07%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper (127,649,607 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TCommitManager::Commit (165,883,950 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TryLoad (508,805,041 samples, 0.07%) + + + +google::protobuf::MessageLite::AppendPartialToString (89,399,688 samples, 0.01%) + + + +std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >::__resize_default_init[abi:v180000] (212,476,744 samples, 0.03%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (123,408,441 samples, 0.02%) + + + +NKikimr::TEvDataShard::TEvRead::SerializeToArcadiaStream (434,982,382 samples, 0.06%) + + + +NActors::IActor::Send (84,788,746 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (121,853,362 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,013,310,571 samples, 0.15%) + + + +Ydb::ResultSet::_InternalSerialize (33,992,550,244 samples, 4.88%) +Ydb::R.. + + +NKikimr::NTable::NPage::TDataPageRecord<NKikimr::NTable::NPage::TDataPage::TRecord, NKikimr::NTable::NPage::TDataPage::TItem>::Cell (3,735,089,193 samples, 0.54%) + + + +NKikimr::TRestoreStrategy::Process (177,434,705 samples, 0.03%) + + + +google::protobuf::internal::AllocateMemory (772,281,093 samples, 0.11%) + + + +[[kernel.kallsyms]] (65,023,167 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (1,439,262,676 samples, 0.21%) + + + +[[kernel.kallsyms]] (110,235,896 samples, 0.02%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +[[kernel.kallsyms]] (1,507,933,667 samples, 0.22%) + + + +NKikimr::NStorage::TDistributedConfigKeeper::Handle (222,136,740 samples, 0.03%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Acquire (204,251,839 samples, 0.03%) + + + +__memmove_avx_unaligned_erms (2,720,237,172 samples, 0.39%) + + + +[[kernel.kallsyms]] (1,852,368,426 samples, 0.27%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (90,155,638 samples, 0.01%) + + + +NKikimr::NDataShard::TLocksUpdate::AddPointLock (223,039,561 samples, 0.03%) + + + +[[kernel.kallsyms]] (121,648,285 samples, 0.02%) + + + +TCMallocInternalNewArray (711,138,396 samples, 0.10%) + + + +__memmove_avx_unaligned_erms (1,673,232,303 samples, 0.24%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (77,113,178 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (253,708,726 samples, 0.04%) + + + +NKikimr::NKqp::TSchedulableComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DoExecuteImpl (284,644,847 samples, 0.04%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::Pop (896,499,387 samples, 0.13%) + + + +[[kernel.kallsyms]] (121,648,285 samples, 0.02%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (610,374,145 samples, 0.09%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (1,015,342,808 samples, 0.15%) + + + +syscall (1,016,242,782 samples, 0.15%) + + + +NKikimr::TCountersArray<NKikimr::TTabletPercentileCounter>::Reset (221,163,966 samples, 0.03%) + + + +__memmove_avx_unaligned_erms (458,399,349 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,548,391,550 samples, 0.22%) + + + +Ydb::Value::clear_value (931,955,394 samples, 0.13%) + + + +[[kernel.kallsyms]] (83,641,703 samples, 0.01%) + + + +NActors::TInternalActorTypeGuard< (113,003,511 samples, 0.02%) + + + +[[kernel.kallsyms]] (5,197,401,763 samples, 0.75%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (299,876,241 samples, 0.04%) + + + +NActors::TInputSessionTCP::ProcessPayload (1,383,109,280 samples, 0.20%) + + + +[[kernel.kallsyms]] (124,043,736 samples, 0.02%) + + + +NYql::NDq::TDqInputChannel::DeserializeAllData (15,145,872,864 samples, 2.17%) +N.. + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::reserve (216,691,399 samples, 0.03%) + + + +std::__y1::__tree<std::__y1::__value_type<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::TSystemColumnInfo>, std::__y1::__map_value_compare<TBasicString<char, std::__y1::char_traits<char> >, std::__y1::__value_type<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::TSystemColumnInfo>, TLess<TBasicString<char, std::__y1::char_traits<char> > >, true>, std::__y1::allocator<std::__y1::__value_type<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::TSystemColumnInfo> > >::find<TBasicStringBuf<char, std::__y1::char_traits<char> > > (2,879,509,512 samples, 0.41%) + + + +[[kernel.kallsyms]] (65,023,167 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (2,586,476,810 samples, 0.37%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::New (126,535,109 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (126,747,930 samples, 0.02%) + + + +google::protobuf::internal::arena_destruct_object<TBasicString<char, std::__y1::char_traits<char> > > (375,934,791 samples, 0.05%) + + + +NActors::TInterconnectSessionTCP::GenerateTraffic (2,936,641,851 samples, 0.42%) + + + +NActors::TEventPBBase<NKikimr::TEvDataShard::TEvRead, NKikimrTxDataShard::TEvRead, 269553215u, NActors::TRecordHolder<NKikimrTxDataShard::TEvRead> >::CreateSerializationInfo (83,413,783 samples, 0.01%) + + + +_nv031577rm (66,612,895 samples, 0.01%) + + + +NKikimr::NDataShard::TPipeline::MoveToNextUnit (80,893,824 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputMapConsumer::IsFull (292,975,128 samples, 0.04%) + + + +[[kernel.kallsyms]] (1,013,300,031 samples, 0.15%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +[[kernel.kallsyms]] (963,214,649 samples, 0.14%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (85,488,842 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (375,055,630 samples, 0.05%) + + + +bio_read_intern (964,309,806 samples, 0.14%) + + + +[[kernel.kallsyms]] (419,945,968 samples, 0.06%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (124,758,998 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (2,056,061,303 samples, 0.29%) + + + +NActors::TExecutorThreadCtx::WakeUp (441,317,676 samples, 0.06%) + + + +grpc::ServerAsyncWriter<NYdbGrpc::TUniversalResponse<Ydb::Query::ExecuteQueryResponsePart> >::Write (7,060,026,535 samples, 1.01%) + + + +Ydb::Value::MergeFrom (81,585,840 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (2,252,128,104 samples, 0.32%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (610,374,145 samples, 0.09%) + + + +UdfFreeWithSize (290,077,741 samples, 0.04%) + + + +[[kernel.kallsyms]] (899,749,482 samples, 0.13%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (132,632,860 samples, 0.02%) + + + +[[kernel.kallsyms]] (646,118,832 samples, 0.09%) + + + +NActors::TActorIdentity::Send< (175,726,548 samples, 0.03%) + + + +NYql::NDecimal::Deserialize (502,411,437 samples, 0.07%) + + + +NThreading::NReadAsFilledPrivate::TReadBucket<NThreading::NReadAsFilledPrivate::TWriteBucket<251u, NThreading::NReadAsFilledPrivate::TEmpty, NThreading::NReadAsFilledPrivate::TEmptyAux>, NThreading::TReadAsFilledQueue<NActors::IEventHandle>::TContainer>::PopAux (124,552,644 samples, 0.02%) + + + +NActors::TGenericExecutorThread::Send< (278,035,097 samples, 0.04%) + + + +NActors::THarmonizer::PullStats (230,014,505 samples, 0.03%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (128,443,525 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (432,739,615 samples, 0.06%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (14,803,066,624 samples, 2.12%) +N.. + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +NKikimr::NDataShard::TLocksUpdate::~TLocksUpdate (127,322,579 samples, 0.02%) + + + +[[kernel.kallsyms]] (457,345,329 samples, 0.07%) + + + +[[kernel.kallsyms]] (681,074,371 samples, 0.10%) + + + +[[kernel.kallsyms]] (2,079,491,832 samples, 0.30%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (511,524,168 samples, 0.07%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (301,665,797 samples, 0.04%) + + + +NActors::TInterconnectSessionTCP::Write (1,964,733,664 samples, 0.28%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (209,780,364 samples, 0.03%) + + + +NActors::IEventHandle::Get<NKikimr::TEvBlobStorage::TEvVPutResult> (328,316,224 samples, 0.05%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (502,799,550 samples, 0.07%) + + + +NKikimr::NPrivate::TAggregatedHistogramCounters::SetValue (349,597,327 samples, 0.05%) + + + +[[kernel.kallsyms]] (1,060,492,331 samples, 0.15%) + + + +NKikimr::NDataShard::TDataShard::StateWork (168,964,027,369 samples, 24.24%) +NKikimr::NDataShard::TDataShard::State.. + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DrainOutputChannel (87,387,400 samples, 0.01%) + + + +std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (3,814,866,174 samples, 0.55%) + + + +tcp_write (3,432,701,356 samples, 0.49%) + + + +__memmove_avx_unaligned_erms (176,781,294 samples, 0.03%) + + + +[[kernel.kallsyms]] (646,118,832 samples, 0.09%) + + + +NKikimr::NDataShard::TDataShard::DeleteReadIterator (85,488,842 samples, 0.01%) + + + +NKikimr::NMiniKQL::MakeString (2,395,059,809 samples, 0.34%) + + + +NYql::NDq::TDqComputeActorChannels::InCh (372,929,857 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (96,668,257 samples, 0.01%) + + + +NYql::NDq::TDqTaskRunner::FetchAndDispatch (82,148,314,820 samples, 11.79%) +NYql::NDq::TDqTas.. + + +NKikimr::IsSystemColumn (84,473,739 samples, 0.01%) + + + +__dynamic_cast (173,204,840 samples, 0.02%) + + + +google::protobuf::internal::ArenaStringPtr::Set (7,822,475,288 samples, 1.12%) + + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::FinishPackAndCheckSize (896,499,387 samples, 0.13%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (481,101,083 samples, 0.07%) + + + +_nv014101rm (66,612,895 samples, 0.01%) + + + +[[kernel.kallsyms]] (84,291,998 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (169,737,975 samples, 0.02%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (512,467,783 samples, 0.07%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (626,428,885,511 samples, 89.87%) +NActors::TGenericExecutorThread::ProcessExecutorPool + + +NKikimr::NDataShard::TDataShard::TReadOperation::SendResult (82,905,573 samples, 0.01%) + + + +google::protobuf::internal::EpsCopyInputStream::Next (297,786,146 samples, 0.04%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +std::__y1::vector<NKikimr::TReorderablePartLayout::TVDiskParts, NPrivate::TStackBasedAllocator<NKikimr::TReorderablePartLayout::TVDiskParts, 8ul, true, std::__y1::allocator<NKikimr::TReorderablePartLayout::TVDiskParts> > >::reserve (61,001,121 samples, 0.01%) + + + +NYql::NDq::TDqTaskRunner::BindAllocator (132,639,097 samples, 0.02%) + + + +NActors::IEventHandle::ReleaseChainBuffer (86,917,712 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::UpdateTableStats (696,633,758 samples, 0.10%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::Destroy<google::protobuf::RepeatedPtrField<TBasicString<char, std::__y1::char_traits<char> > >::TypeHandler> (438,649,322 samples, 0.06%) + + + +NKikimr::CompareTypedCells (85,548,793 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,964,733,664 samples, 0.28%) + + + +[[kernel.kallsyms]] (5,866,262,184 samples, 0.84%) + + + +std::__y1::__lower_bound[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TDataPage::TRecord>, TArrayRef<NKikimr::TCell const>, std::__y1::__identity, NKikimr::NTable::NPage::TCompare<NKikimr::NTable::NPage::TDataPage::TRecord> > (5,060,454,557 samples, 0.73%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (128,232,660 samples, 0.02%) + + + +[[kernel.kallsyms]] (120,319,151 samples, 0.02%) + + + +Ydb::Value::~Value (85,193,901 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::GenerateTraffic (2,227,271,884 samples, 0.32%) + + + +syscall (5,980,225,285 samples, 0.86%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::ResetTouchesAndToLoad (2,504,340,554 samples, 0.36%) + + + +std::__y1::vector<NKikimr::TSerializedCellVec, std::__y1::allocator<NKikimr::TSerializedCellVec> >::__destroy_vector::operator (816,205,631 samples, 0.12%) + + + +[[kernel.kallsyms]] (2,041,843,708 samples, 0.29%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackData<false, unsigned long, NKikimr::NMiniKQL::TPagedBuffer> (425,545,993 samples, 0.06%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (116,711,020 samples, 0.02%) + + + +NYdbGrpc::TGRpcRequestImpl<Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, NKikimr::NGRpcService::TGRpcYdbQueryService, google::protobuf::TextFormat::Printer, google::protobuf::TextFormat::Printer>::WriteByteDataOk (7,102,244,152 samples, 1.02%) + + + +[[kernel.kallsyms]] (17,008,120,970 samples, 2.44%) +[[.. + + +NKikimr::NTabletPipe::TClient::HandleSend (1,422,125,148 samples, 0.20%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (90,063,651 samples, 0.01%) + + + +Ydb::ResultSet::ByteSizeLong (26,586,836,278 samples, 3.81%) +Ydb:.. + + +NKikimr::NMiniKQL::MakeCellImpl<NKikimr::NMiniKQL::TStringProviderBackend> (77,833,973 samples, 0.01%) + + + +google::protobuf::internal::WireFormatLite::VerifyUtf8String (6,252,150,213 samples, 0.90%) + + + +NKikimr::NKqp::(anonymous namespace)::GetRangePartitioning (73,843,726,146 samples, 10.59%) +NKikimr::NKqp::.. + + +[[kernel.kallsyms]] (605,971,687 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (207,398,100 samples, 0.03%) + + + +NKikimr::NMiniKQL::MakeString (129,070,597 samples, 0.02%) + + + +NKikimr::NTable::NPage::TFlatIndex::LookupKey (11,301,415,516 samples, 1.62%) + + + +[[kernel.kallsyms]] (1,532,350,864 samples, 0.22%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (209,615,206 samples, 0.03%) + + + +[[kernel.kallsyms]] (369,021,474 samples, 0.05%) + + + +[[kernel.kallsyms]] (1,913,007,406 samples, 0.27%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (90,472,277 samples, 0.01%) + + + +[[kernel.kallsyms]] (18,233,714,661 samples, 2.62%) +[[.. + + +[[vdso]] (8,752,985,860 samples, 1.26%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (1,419,753,619 samples, 0.20%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (125,451,961 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (1,095,381,217 samples, 0.16%) + + + +[[kernel.kallsyms]] (147,610,442 samples, 0.02%) + + + +[[kernel.kallsyms]] (78,260,393 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (81,067,648 samples, 0.01%) + + + +LoadRecordCacheState (82,032,807 samples, 0.01%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +NKikimr::NDriverClient::TClientCommandServer::Run (74,793,962 samples, 0.01%) + + + +NKikimr::TSerializedCellVec::TSerializedCellVec (1,125,421,645 samples, 0.16%) + + + +BIO_read (964,309,806 samples, 0.14%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::ExtendMaxRightKey (128,257,902 samples, 0.02%) + + + +NKikimr::TKeyDesc::~TKeyDesc (2,850,969,089 samples, 0.41%) + + + +NActors::TActivationContextHolder::operator* (167,976,987 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (124,043,736 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TInfo::EnsurePage (914,365,257 samples, 0.13%) + + + +NKikimr::TPinnedPageRef::TPinnedPageRef (1,911,014,769 samples, 0.27%) + + + +std::__y1::__lower_bound[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TDataPage::TRecord>, TArrayRef<NKikimr::TCell const>, std::__y1::__identity, NKikimr::NTable::NPage::TCompare<NKikimr::NTable::NPage::TDataPage::TRecord> > (576,692,480 samples, 0.08%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::HasSchemaChanges (606,466,744 samples, 0.09%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (1,419,753,619 samples, 0.20%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (11,133,790,326 samples, 1.60%) + + + +google::protobuf::internal::WireFormatLite::InternalWriteMessage (1,346,813,615 samples, 0.19%) + + + +NKikimr::ComparePrefixBorders (85,868,391 samples, 0.01%) + + + +NKikimr::NMiniKQL::PgAcquireThreadContext (7,667,310,625 samples, 1.10%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (85,280,994 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupProxy::ProcessBatchedPutRequests (180,070,083 samples, 0.03%) + + + +[[kernel.kallsyms]] (571,843,996 samples, 0.08%) + + + +[[kernel.kallsyms]] (82,582,886 samples, 0.01%) + + + +NKikimr::NMiniKQL::GetCellValue (92,877,313 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::assign (1,078,216,439 samples, 0.15%) + + + +NKikimr::TEvTabletCounters::TEvTabletAddCounters::~TEvTabletAddCounters (85,912,623 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::Complete (1,502,659,192 samples, 0.22%) + + + +[[kernel.kallsyms]] (121,648,285 samples, 0.02%) + + + +Ydb::Value::ByteSizeLong (24,344,142,679 samples, 3.49%) +Ydb.. + + +NKikimr::CompareTypedCells (1,096,185,722 samples, 0.16%) + + + +__memmove_avx_unaligned_erms (1,153,015,804 samples, 0.17%) + + + +NActors::TExecutorThreadStats::Aggregate (133,748,165 samples, 0.02%) + + + +NKikimr::NMiniKQL::GetUnboxedValueSize (123,845,305 samples, 0.02%) + + + +NKikimr::NTable::TPartIter::Apply (147,901,255 samples, 0.02%) + + + +NActors::TStatsCollectingActor::StateWork (4,552,288,256 samples, 0.65%) + + + +[[kernel.kallsyms]] (369,021,474 samples, 0.05%) + + + +[[kernel.kallsyms]] (298,450,750 samples, 0.04%) + + + +NKikimr::NTable::TRowState::Set (97,735,082 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (470,068,374 samples, 0.07%) + + + +std::__y1::__destroy_at[abi:v180000]<std::__y1::pair<unsigned long const, NYql::NDq::TDqComputeActorChannels::TOutputChannelState::TInFlightMessage>, 0> (344,182,776 samples, 0.05%) + + + +main (74,793,962 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (299,876,241 samples, 0.04%) + + + +[[kernel.kallsyms]] (18,820,566,967 samples, 2.70%) +[[.. + + +[[kernel.kallsyms]] (1,047,974,488 samples, 0.15%) + + + +[[kernel.kallsyms]] (82,402,859 samples, 0.01%) + + + +NActors::TBasicExecutorPool::GetThreadCpuConsumption (186,444,785 samples, 0.03%) + + + +THashMap<unsigned int, NActors::TSharedData, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::operator[]<unsigned int> (492,965,285 samples, 0.07%) + + + +Ydb::Value::MergeFrom (128,228,010 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::TTxReadContinue::SendResult (85,488,842 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (498,760,396 samples, 0.07%) + + + +NKikimr::NTabletPipe::TClient::StateWork (1,422,125,148 samples, 0.20%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (125,255,889 samples, 0.02%) + + + +NMonitoring::TExplicitHistogramCollector::Collect (561,087,883 samples, 0.08%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::Handle (1,420,639,294 samples, 0.20%) + + + +NActors::TEventOutputChannel::Push (4,060,894,703 samples, 0.58%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (243,422,616 samples, 0.03%) + + + +[[kernel.kallsyms]] (83,636,508 samples, 0.01%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::~TDirectArrayHolderInplace (73,617,179 samples, 0.01%) + + + +[[vdso]] (197,145,734 samples, 0.03%) + + + +[[kernel.kallsyms]] (1,013,296,063 samples, 0.15%) + + + +[[kernel.kallsyms]] (1,595,587,901 samples, 0.23%) + + + +[[kernel.kallsyms]] (326,476,050 samples, 0.05%) + + + +[[kernel.kallsyms]] (234,924,989 samples, 0.03%) + + + +[[kernel.kallsyms]] (84,169,831 samples, 0.01%) + + + +wpacket_intern_init_len (86,733,704 samples, 0.01%) + + + +NActors::(anonymous namespace)::TSelfPingActor::RunningState (83,077,902 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TryLoad (341,474,315 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (126,692,228 samples, 0.02%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::Seek (13,915,843,291 samples, 2.00%) +N.. + + +__memcmp_avx2_movbe (2,740,981,053 samples, 0.39%) + + + +NActors::TInputSessionTCP::ProcessPayload (341,911,783 samples, 0.05%) + + + +NYql::NDq::TEvDqCompute::TEvResumeExecution::~TEvResumeExecution (500,167,397 samples, 0.07%) + + + +NKikimr::TPutImpl::TPutImpl (78,250,057 samples, 0.01%) + + + +[[kernel.kallsyms]] (403,085,143 samples, 0.06%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (84,725,299 samples, 0.01%) + + + + diff --git a/13174/flame-before.svg b/13174/flame-before.svg new file mode 100644 index 0000000..c8fe47e --- /dev/null +++ b/13174/flame-before.svg @@ -0,0 +1,6830 @@ + + + + + + + + + + + + + + +Flame Graph + +Reset Zoom +Search +ic + + + +NActors::TEventBase<NYql::NDq::TEvDqCompute::TEvResumeExecution, 271646922u>::Type (512,363,802 samples, 0.05%) + + + +TRcBuf::TBackend::VisitRaw<TRcBuf::TBackend::TBackendHolder, TRcBuf::TBackend::Destroy<TRcBuf::TBackend::TBackendHolder> (382,853,727 samples, 0.04%) + + + +NYql::NDq::TDqInputImpl<NYql::NDq::TDqAsyncInputBuffer, NYql::NDq::IDqAsyncInputBuffer>::Pop (257,625,358 samples, 0.03%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Acquire (17,512,637,030 samples, 1.82%) +N.. + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Apply (245,720,931 samples, 0.03%) + + + +std::__y1::vector<std::__y1::pair<unsigned long, NKikimr::TOwnedTableRange>, std::__y1::allocator<std::__y1::pair<unsigned long, NKikimr::TOwnedTableRange> > >::__emplace_back_slow_path<unsigned long const&, NKikimr::TOwnedTableRange const&> (208,189,736 samples, 0.02%) + + + +[[kernel.kallsyms]] (3,565,993,399 samples, 0.37%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (83,995,941 samples, 0.01%) + + + +NActors::TExecutorThreadCtx::WakeUp (171,908,642 samples, 0.02%) + + + +NKikimr::NTable::TRemap::~TRemap (110,514,887 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (208,317,136 samples, 0.02%) + + + +Ydb::Query::ExecuteQueryResponsePart::_InternalSerialize (59,334,184,819 samples, 6.16%) +Ydb::Que.. + + +NActors::TThreadParkPad::Park (131,537,999 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (1,009,026,738 samples, 0.10%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackBlob<NKikimr::NMiniKQL::TPagedBuffer> (1,776,848,322 samples, 0.18%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (1,652,016,330 samples, 0.17%) + + + +NKikimrExecutorFlat::TLeaseInfoMetadata::ByteSizeLong (83,931,643 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (9,571,788,937 samples, 0.99%) + + + +NKikimr::NTable::NPage::TDataPageWriter::Add (169,494,191 samples, 0.02%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (533,363,495 samples, 0.06%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (332,728,522 samples, 0.03%) + + + +NKikimr::NMemory::TMemoryTrackerActor::Collect (466,243,696 samples, 0.05%) + + + +[[kernel.kallsyms]] (2,630,643,134 samples, 0.27%) + + + +[[kernel.kallsyms]] (82,185,134 samples, 0.01%) + + + +google::protobuf::MessageLite::SerializePartialToZeroCopyStream (99,216,647 samples, 0.01%) + + + +syscall (82,649,394 samples, 0.01%) + + + +NYql::NDq::TEvDqCompute::TEvResumeExecution::~TEvResumeExecution (1,030,452,243 samples, 0.11%) + + + +google::protobuf::internal::ArenaStringPtr::Destroy (82,819,531 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (83,863,538 samples, 0.01%) + + + +NActors::TGenericExecutorThread::Send< (111,967,540 samples, 0.01%) + + + +NActors::TMailboxHeader::MarkForSchedule (12,297,719,449 samples, 1.28%) + + + +NActors::TActivationContextHolder::operator= (272,876,755 samples, 0.03%) + + + +NKikimr::ErasureSplit (217,608,346 samples, 0.02%) + + + +NKikimr::NTable::TBounds::CompareSearchKeyFirstKey (409,302,948 samples, 0.04%) + + + +NActors::TMailboxHeader::FindActor (1,122,831,032 samples, 0.12%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::AcquireLock (4,171,867,026 samples, 0.43%) + + + +non-virtual thunk to NKikimr::NTabletFlatExecutor::TExecutor::Execute (921,942,876 samples, 0.10%) + + + +[[kernel.kallsyms]] (673,115,605 samples, 0.07%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (6,888,589,336 samples, 0.72%) + + + +NYql::NDq::(anonymous namespace)::EstimateSizeImpl (1,341,187,585 samples, 0.14%) + + + +NKikimr::NMiniKQL::TPagedBuffer::Advance (174,222,869 samples, 0.02%) + + + +[[kernel.kallsyms]] (169,863,817 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (292,681,086 samples, 0.03%) + + + +[[kernel.kallsyms]] (9,969,755,358 samples, 1.04%) + + + +NKikimr::NTable::TPartIter::Apply (8,918,180,122 samples, 0.93%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (147,851,292 samples, 0.02%) + + + +google::protobuf::Message::MaybeComputeUnknownFieldsSize (295,556,115 samples, 0.03%) + + + +Ydb::ResultSet::~ResultSet (93,558,951,001 samples, 9.72%) +Ydb::ResultSet.. + + +NActors::TInterconnectProxyTCP::StateWork (298,909,034 samples, 0.03%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (13,638,730,336 samples, 1.42%) + + + +NActors::TActivationContext::Send< (82,185,134 samples, 0.01%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Start (84,703,903 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (165,933,198 samples, 0.02%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Release (1,706,815,094 samples, 0.18%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (794,540,576 samples, 0.08%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (86,452,982 samples, 0.01%) + + + +NYql::(anonymous namespace)::TContigousChunkOverBuf::~TContigousChunkOverBuf (370,076,089 samples, 0.04%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::ProcessOutputsImpl (27,275,535,894 samples, 2.83%) +NY.. + + +[[kernel.kallsyms]] (1,025,030,326 samples, 0.11%) + + + +NActors::TExecutorThread::ThreadProc (907,346,793,356 samples, 94.24%) +NActors::TExecutorThread::ThreadProc + + +bread_conv (1,325,762,882 samples, 0.14%) + + + +NKikimr::NMiniKQL::GetUnboxedValueSize (2,129,794,676 samples, 0.22%) + + + +__memcmp_avx2_movbe (255,545,463 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (413,142,304 samples, 0.04%) + + + +__memset_avx2_unaligned_erms (138,269,546 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,538,324 samples, 0.01%) + + + +NKikimr::TTabletReqWriteLog::Handle (96,905,368 samples, 0.01%) + + + +NActors::TActivationContextHolder::operator (373,703,521 samples, 0.04%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::SendResult (207,534,782 samples, 0.02%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::Pop (162,747,209 samples, 0.02%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (11,173,415,206 samples, 1.16%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (98,815,592 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,538,324 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::EstimateSizeImpl (18,348,401,197 samples, 1.91%) +N.. + + +[[kernel.kallsyms]] (86,907,510 samples, 0.01%) + + + +NKikimr::NDataShard::TLocksUpdate::AddPointLock (87,433,103 samples, 0.01%) + + + +NKikimr::TRestoreStrategy::Process (189,117,480 samples, 0.02%) + + + +std::__y1::__split_buffer<NKikimr::NTable::TPartIter*, std::__y1::allocator<NKikimr::NTable::TPartIter*> >::push_back (83,837,978 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (5,152,951,482 samples, 0.54%) + + + +[[kernel.kallsyms]] (1,747,447,476 samples, 0.18%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::PollAsyncInput (210,201,116 samples, 0.02%) + + + +NActors::TActivationContext::LoggerSettings (573,500,308 samples, 0.06%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::UnpackBatch (13,720,941,785 samples, 1.43%) + + + +NKikimr::NTable::TFeed::Process (169,494,191 samples, 0.02%) + + + +[[kernel.kallsyms]] (169,863,817 samples, 0.02%) + + + +NActors::(anonymous namespace)::TSelfPingActor::RunningState (85,063,425 samples, 0.01%) + + + +NYql::NDq::TDqTaskRunner::GetTypeEnv (304,182,338 samples, 0.03%) + + + +[[kernel.kallsyms]] (130,232,041 samples, 0.01%) + + + +NActors::TActivationContext::Monotonic (285,465,974 samples, 0.03%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (8,152,422,388 samples, 0.85%) + + + +Ydb::Value::MergeFrom (308,808,427 samples, 0.03%) + + + +NActors::IActor::Receive (1,573,965,523 samples, 0.16%) + + + +[[kernel.kallsyms]] (1,140,168,997 samples, 0.12%) + + + +[[kernel.kallsyms]] (741,894,030 samples, 0.08%) + + + +std::__y1::__murmur2_or_cityhash<unsigned long, 64ul>::operator (3,818,395,994 samples, 0.40%) + + + +[[kernel.kallsyms]] (392,946,265 samples, 0.04%) + + + +std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (124,589,274 samples, 0.01%) + + + +NKikimr::CompareTypedCells (20,895,068,034 samples, 2.17%) +N.. + + +TCMallocInternalDeleteArrayAligned_nothrow (413,142,304 samples, 0.04%) + + + +ydbd.User (911,178,579,069 samples, 94.64%) +ydbd.User + + +NYql::NDq::TComputeActorAsyncInputHelperSync::GetFreeSpace (1,295,775,957 samples, 0.13%) + + + +[[kernel.kallsyms]] (171,908,642 samples, 0.02%) + + + +NYql::NDq::TDqDataSerializer::Deserialize (287,441,170 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::HasSchemaChanges (797,246,171 samples, 0.08%) + + + +std::__y1::vector<NKikimr::NScheme::TTypeInfo, NPrivate::TStackBasedAllocator<NKikimr::NScheme::TTypeInfo, 16ul, true, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> > >::__append (991,652,978 samples, 0.10%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::AddItem (29,805,015,245 samples, 3.10%) +NKi.. + + +[[kernel.kallsyms]] (1,096,683,000 samples, 0.11%) + + + +[ydbd] (173,651,619 samples, 0.02%) + + + +NActors::TExecutorThreadCtx::WakeUp (82,649,394 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::TTxCleanupTransaction::Execute (138,568,855 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::FinishPackAndCheckSize (2,324,888,505 samples, 0.24%) + + + +[[kernel.kallsyms]] (351,938,243 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (6,805,041,114 samples, 0.71%) + + + +__memmove_avx_unaligned_erms (2,229,245,681 samples, 0.23%) + + + +[[kernel.kallsyms]] (169,863,817 samples, 0.02%) + + + +NKikimr::TOwnedTableRange::TOwnedTableRange (1,447,340,630 samples, 0.15%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::Read (105,722,736,878 samples, 10.98%) +NKikimr::NDataSh.. + + +NYql::NDq::(anonymous namespace)::TDqInputUnionStreamValue<false>::Fetch (534,576,309 samples, 0.06%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (462,767,657 samples, 0.05%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::BaseStateFuncBody (125,306,714 samples, 0.01%) + + + +[[vdso]] (158,689,506 samples, 0.02%) + + + +NActors::TInputSessionTCP::ProcessPayload (228,985,610 samples, 0.02%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::insert_unique<std::__y1::pair<unsigned int const, unsigned int> > (207,288,290 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TCompactionLogic::GetBackingSize (169,280,640 samples, 0.02%) + + + +[[kernel.kallsyms]] (125,763,990 samples, 0.01%) + + + +NKikimr::NSharedCache::TEvTouch::~TEvTouch (293,934,747 samples, 0.03%) + + + +NKikimr::TTablet::HandleNext (751,887,744 samples, 0.08%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::GetRowId (84,314,241 samples, 0.01%) + + + +NActors::TActorIdentity::Send< (540,276,772 samples, 0.06%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TryLoad (5,244,068,851 samples, 0.54%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (85,957,878 samples, 0.01%) + + + +std::__y1::__floyd_sift_down[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::TComparator&, NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::TElement*> (472,995,326 samples, 0.05%) + + + +Ydb::Value::MergeFrom (85,957,878 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (16,324,920,438 samples, 1.70%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::~TReadOperation (2,048,507,637 samples, 0.21%) + + + +NActors::TInputSessionTCP::ReceiveData (1,130,847,170 samples, 0.12%) + + + +ssl_protector_protect (2,996,439,059 samples, 0.31%) + + + +start_thread (1,044,193,941 samples, 0.11%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (952,121,328 samples, 0.10%) + + + +[[kernel.kallsyms]] (92,918,078 samples, 0.01%) + + + +Ydb::Value::_InternalSerialize (58,535,444,095 samples, 6.08%) +Ydb::Val.. + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (337,370,322 samples, 0.04%) + + + +start_thread (18,917,047,828 samples, 1.96%) +s.. + + +start_thread (9,790,139,722 samples, 1.02%) + + + +MicroSeconds (27,002,755,430 samples, 2.80%) +Mi.. + + +NKikimr::NTable::TCelled::TCelled (170,950,901 samples, 0.02%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::DoRemove (397,561,550 samples, 0.04%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (293,934,747 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::UnbackWithoutLock (206,510,236 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::SendImmediateReadResult (165,542,720 samples, 0.02%) + + + +Ydb::Column::~Column (83,633,501 samples, 0.01%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (257,625,358 samples, 0.03%) + + + +TGUCSettings::Get (175,834,123 samples, 0.02%) + + + +syscall (1,226,796,312 samples, 0.13%) + + + +[[vdso]] (26,152,471,222 samples, 2.72%) +[[.. + + +NKikimr::NTable::NPage::TFlatIndex::LookupKey (9,423,710,311 samples, 0.98%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (366,001,159 samples, 0.04%) + + + +NKikimr::NTable::TDatabase::Subset (82,328,418 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (6,930,650,643 samples, 0.72%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (11,165,759,058 samples, 1.16%) + + + +[[kernel.kallsyms]] (250,110,888 samples, 0.03%) + + + +[[kernel.kallsyms]] (83,480,588 samples, 0.01%) + + + +[[kernel.kallsyms]] (4,419,749,114 samples, 0.46%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::DoPush (35,475,253,235 samples, 3.68%) +NYql.. + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (13,446,515,101 samples, 1.40%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::ReleaseToSpans (2,862,166,005 samples, 0.30%) + + + +[[kernel.kallsyms]] (1,166,213,935 samples, 0.12%) + + + +[[kernel.kallsyms]] (84,580,412 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::WriteData (1,259,427,497 samples, 0.13%) + + + +NActors::TExecutorPoolBaseMailboxed::Register (88,691,416 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::GetKeyAccessSampler (84,773,001 samples, 0.01%) + + + +NActors::IActor::Send (540,276,772 samples, 0.06%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::GetReadTxObserver (295,723,257 samples, 0.03%) + + + +NYql::NDq::TDqMemoryQuota::TryShrinkMemory (211,693,831 samples, 0.02%) + + + +NKikimr::NDataShard::TPipeline::RunExecutionPlan (115,390,347,961 samples, 11.99%) +NKikimr::NDataSha.. + + +NActors::TActorIdentity::Send< (456,271,707 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (923,989,885 samples, 0.10%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (111,967,540 samples, 0.01%) + + + +[[kernel.kallsyms]] (416,482,480 samples, 0.04%) + + + +NKikimr::TBlobStorageGroupPutRequest::Action (484,725,804 samples, 0.05%) + + + +[[kernel.kallsyms]] (416,482,480 samples, 0.04%) + + + +NKikimr::TPutImpl::ProcessResponseBlob<NKikimrBlobStorage::TEvVPutResult> (109,850,856 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorChannels::InCh (1,566,765,493 samples, 0.16%) + + + +[[kernel.kallsyms]] (2,181,525,091 samples, 0.23%) + + + +std::__y1::__variant_detail::__visitation::__base::__dispatcher<0ul>::__dispatch[abi:v180000]<std::__y1::__variant_detail::__visitation::__variant::__value_visitor<NActors::TBasicExecutorPool::GetReadyActivationCommon (110,292,253 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (195,882,525 samples, 0.02%) + + + +NYql::NDq::(anonymous namespace)::TDqInputUnionStreamValue<false>::Fetch (35,517,739,651 samples, 3.69%) +NYql.. + + +nf_conntrack_in (178,504,593 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::TOutputChannelInfo::TDrainedChannelMessage::ReadData (1,838,077,772 samples, 0.19%) + + + +bio_write_intern (248,363,091 samples, 0.03%) + + + +NKikimr::NMiniKQL::NDetails::TChunkedInputBuffer::Next (370,076,089 samples, 0.04%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::UnpackBatch (14,050,181,435 samples, 1.46%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::DoExecute (359,680,913,470 samples, 37.36%) +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeAct.. + + +NKikimr::NTable::TPartIter::Apply (9,690,795,457 samples, 1.01%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::WriteData (1,259,427,497 samples, 0.13%) + + + +NKikimr::CompareTypedCells (203,884,869 samples, 0.02%) + + + +NKikimr::NMiniKQL::TNoopKeySampler::AddSample (82,754,105 samples, 0.01%) + + + +[[kernel.kallsyms]] (3,958,523,037 samples, 0.41%) + + + +NKikimr::NTable::TRemap::TRemap (21,252,748,274 samples, 2.21%) +N.. + + +google::protobuf::io::EpsCopyOutputStream::WriteStringMaybeAliasedOutline (159,129,523 samples, 0.02%) + + + +std::__y1::vector<NKikimr::TSerializedCellVec, std::__y1::allocator<NKikimr::TSerializedCellVec> >::__destroy_vector::operator (794,540,576 samples, 0.08%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (457,437,968 samples, 0.05%) + + + +std::__y1::vector<NActors::TExecutorThreadStats, std::__y1::allocator<NActors::TExecutorThreadStats> >::__append (89,279,582 samples, 0.01%) + + + +[[kernel.kallsyms]] (82,185,134 samples, 0.01%) + + + +NActors::IActor::Send (125,290,263 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (3,999,822,839 samples, 0.42%) + + + +NKikimr::NDataShard::TLocksDataShardAdapter<NKikimr::NDataShard::TDataShard>::IsUserTable (128,575,013 samples, 0.01%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (246,229,063 samples, 0.03%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (3,611,857,589 samples, 0.38%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (88,555,462 samples, 0.01%) + + + +[[kernel.kallsyms]] (84,406,825 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TLogicRedo::CommitROTransaction (81,798,626 samples, 0.01%) + + + +Ydb::Value::~Value (92,586,237,183 samples, 9.62%) +Ydb::Value::~V.. + + +NActors::TActivationContext::Monotonic (1,320,607,401 samples, 0.14%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (128,405,022 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (106,273,929 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (152,172,403 samples, 0.02%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackData<false, unsigned long, NKikimr::NMiniKQL::TPagedBuffer> (588,928,363 samples, 0.06%) + + + +NKikimr::TBlackboard::RunStrategy (91,546,294 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (620,238,183 samples, 0.06%) + + + +NActors::IActor::Register (88,691,416 samples, 0.01%) + + + +std::__y1::allocator<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey>::destroy[abi:v180000] (1,588,552,200 samples, 0.16%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NTable::NPage::TDataPageRecord<NKikimr::NTable::NPage::TDataPage::TRecord, NKikimr::NTable::NPage::TDataPage::TItem>::Cell (125,760,171 samples, 0.01%) + + + +set_stack_base (226,844,967 samples, 0.02%) + + + +do_ssl3_write (1,004,894,797 samples, 0.10%) + + + +[[kernel.kallsyms]] (82,649,394 samples, 0.01%) + + + +Ydb::Value::Clear (91,898,409 samples, 0.01%) + + + +NActors::TGenericExecutorThread::Send< (125,290,263 samples, 0.01%) + + + +NActors::TActivationContext::LoggerSettings (127,129,789 samples, 0.01%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::Pop (83,473,513 samples, 0.01%) + + + +NKikimr::NMiniKQL::MakeStringNotFilled (84,896,314 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (318,942,844 samples, 0.03%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (284,142,554 samples, 0.03%) + + + +NKikimr::TBlobStorageGroupPutRequest::~TBlobStorageGroupPutRequest (318,944,039 samples, 0.03%) + + + +SaveRecordCacheState (297,393,770 samples, 0.03%) + + + +[[kernel.kallsyms]] (1,903,325,375 samples, 0.20%) + + + +NActors::TActivationContext::Send< (456,271,707 samples, 0.05%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (185,856,294 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (209,597,182 samples, 0.02%) + + + +NActors::TActivationContext::Send< (498,069,950 samples, 0.05%) + + + +[[kernel.kallsyms]] (809,991,734 samples, 0.08%) + + + +NActors::TMailboxHeader::FindActor (121,152,420 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (620,238,183 samples, 0.06%) + + + +NYql::NDq::TDqTaskRunner::Run (134,076,005,988 samples, 13.93%) +NYql::NDq::TDqTaskRun.. + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +grpc::ServerAsyncWriter<NYdbGrpc::TUniversalResponse<Ydb::Query::ExecuteQueryResponsePart> >::Write (8,176,005,700 samples, 0.85%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (86,127,647 samples, 0.01%) + + + +grpc_event_engine::experimental::MemoryAllocator::MakeSlice (84,951,095 samples, 0.01%) + + + +NActors::IActor::InvokeOtherActor<NActors::TInterconnectSessionTCP, void (298,892,903 samples, 0.03%) + + + +[[kernel.kallsyms]] (82,855,316 samples, 0.01%) + + + +NKikimr::NDataShard::TSysLocks::ApplyLocks (841,220,649 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (337,370,322 samples, 0.04%) + + + +NKikimr::NDataShard::TDataShard::TTxReadViaPipeline::Execute (117,438,855,598 samples, 12.20%) +NKikimr::NDataShar.. + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (1,180,151,387 samples, 0.12%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::TRevolvingMailbox> (517,936,920 samples, 0.05%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (114,140,445 samples, 0.01%) + + + +NKikimr::NMiniKQL::PgReleaseThreadContext (1,038,786,277 samples, 0.11%) + + + +[[kernel.kallsyms]] (1,096,683,000 samples, 0.11%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (1,044,193,941 samples, 0.11%) + + + +NKikimr::NKqp::TKqpQueryState::PrepareNextStatementPart (82,002,112 samples, 0.01%) + + + +[[vdso]] (325,750,139 samples, 0.03%) + + + +restore_stack_base (257,364,697 samples, 0.03%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (209,376,655 samples, 0.02%) + + + +NActors::TInterconnectSessionTCP::ProducePackets (122,147,110 samples, 0.01%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +NKikimr::CompareTypedCells (151,639,501 samples, 0.02%) + + + +[[kernel.kallsyms]] (169,863,817 samples, 0.02%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (3,192,468,046 samples, 0.33%) + + + +[[kernel.kallsyms]] (16,151,012,738 samples, 1.68%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (210,409,443 samples, 0.02%) + + + +NYql::NDq::TDqDataSerializer::Deserialize (14,050,181,435 samples, 1.46%) + + + +TCMallocInternalNewArray (417,471,186 samples, 0.04%) + + + +__memcmp_avx2_movbe (24,226,949,613 samples, 2.52%) +__.. + + +endpoint_write (7,983,236,687 samples, 0.83%) + + + +ydbd.Scheduler (21,532,183,247 samples, 2.24%) +y.. + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (4,172,216,762 samples, 0.43%) + + + +[[kernel.kallsyms]] (1,204,719,283 samples, 0.13%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +NActors::TInputSessionTCP::Read (511,318,861 samples, 0.05%) + + + +NKikimr::NTabletFlatExecutor::TOpsCompact::Handle (216,387,955 samples, 0.02%) + + + +NKikimr::TTabletCountersAggregatorActor::StateWork (787,755,724 samples, 0.08%) + + + +NKikimr::NTable::NPage::TDataPageRecord<NKikimr::NTable::NPage::TDataPage::TRecord, NKikimr::NTable::NPage::TDataPage::TItem>::Cell (84,549,780 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (812,598,534 samples, 0.08%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (609,221,253 samples, 0.06%) + + + +_nv041459rm (84,406,825 samples, 0.01%) + + + +nft_do_chain (167,005,411 samples, 0.02%) + + + +NActors::TInputSessionTCP::WorkingStateImpl (1,169,305,976 samples, 0.12%) + + + +NActors::TGenericExecutorThread::Send< (498,069,950 samples, 0.05%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::Seek (902,049,317 samples, 0.09%) + + + +NKikimr::SendToBSProxy (111,583,922 samples, 0.01%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (331,576,959 samples, 0.03%) + + + +Ydb::Value::~Value (92,586,237,183 samples, 9.62%) +Ydb::Value::~V.. + + +google::protobuf::internal::WireFormatLite::InternalWriteMessage (10,666,116,853 samples, 1.11%) + + + +NKikimr::NDataShard::TPipeline::Cleanup (85,679,513 samples, 0.01%) + + + +[[kernel.kallsyms]] (392,946,265 samples, 0.04%) + + + +NKikimr::NCache::TSwitchableCache<NKikimr::NTabletFlatExecutor::TSharedPageCache::TPage, NKikimr::NTabletFlatExecutor::TSharedPageCache::TCompositeCachePageTraits>::Touch (208,137,561 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::TTxProposeTransactionBase::Execute (917,198,670 samples, 0.10%) + + + +NActors::TPoolInfo::PullStats (82,103,849 samples, 0.01%) + + + +[[kernel.kallsyms]] (667,636,148 samples, 0.07%) + + + +NKikimr::CompareTypedCells (1,078,490,395 samples, 0.11%) + + + +[[kernel.kallsyms]] (2,104,411,203 samples, 0.22%) + + + +NKikimr::NGRpcService::TGRpcRequestWrapperImpl<273219757u, Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, false, NKikimr::NGRpcService::TGrpcRequestCall<Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, false> >::SendSerializedResult (8,347,831,431 samples, 0.87%) + + + +[[kernel.kallsyms]] (741,890,261 samples, 0.08%) + + + +ydbd.IC (9,874,720,134 samples, 1.03%) + + + +NYql::NDecimal::Deserialize (508,468,016 samples, 0.05%) + + + +[[kernel.kallsyms]] (1,226,796,248 samples, 0.13%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (125,555,878 samples, 0.01%) + + + +NActors::TInputSessionTCP::Handle (1,130,847,170 samples, 0.12%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +[[kernel.kallsyms]] (16,435,201,897 samples, 1.71%) + + + +old_sort::__sort<std::__y1::__less<void, void>&, unsigned int*> (165,185,583 samples, 0.02%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (86,127,647 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::DestroyProtos (93,558,951,001 samples, 9.72%) +google::protob.. + + +NKikimr::NDataShard::TDataShard::DoPeriodicTasks (1,292,594,229 samples, 0.13%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (85,711,468 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TCommitManager::SendCommitEv (624,407,660 samples, 0.06%) + + + +NActors::TStatsCollectingActor::SetAggregatedCounters (957,838,333 samples, 0.10%) + + + +NActors::TActivationContext::Send< (121,924,875 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::CompleteRoTransaction (81,798,626 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NActors::SerializeToArcadiaStreamImpl (111,061,393 samples, 0.01%) + + + +ydbd.Batch (1,044,193,941 samples, 0.11%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (203,993,874 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::ReleaseToSpans (883,803,361 samples, 0.09%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (125,290,263 samples, 0.01%) + + + +Ydb::Value::~Value (41,796,466,470 samples, 4.34%) +Ydb::.. + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (111,583,922 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (121,163,066 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (157,889,874 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (1,193,611,911 samples, 0.12%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::~TDirectArrayHolderInplace (3,688,872,429 samples, 0.38%) + + + +NKikimr::NMetrics::TResourceMetricsSendState::TryUpdate (154,211,905 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::RemoveRange (255,868,392 samples, 0.03%) + + + +NKikimr::TEvBlobStorage::TEvPut::~TEvPut (93,718,742 samples, 0.01%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (84,148,687 samples, 0.01%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (4,406,564,741 samples, 0.46%) + + + +NActors::TInterconnectSessionTCP::GenerateTraffic (1,443,563,208 samples, 0.15%) + + + +[[kernel.kallsyms]] (385,522,544 samples, 0.04%) + + + +[[kernel.kallsyms]] (642,076,287 samples, 0.07%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (119,835,510 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,322,536,412 samples, 0.14%) + + + +[[kernel.kallsyms]] (83,480,588 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (84,665,452 samples, 0.01%) + + + +LoadRecordCacheState (253,535,104 samples, 0.03%) + + + +NYql::NDq::TDqTaskRunner::BindAllocator (842,896,091 samples, 0.09%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (339,753,178 samples, 0.04%) + + + +NActors::TMailboxHeader::UnlockFromExecution2 (115,144,163 samples, 0.01%) + + + +NKikimr::CompareTypedCells (115,789,588 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (2,586,651,501 samples, 0.27%) + + + +__GI___writev (85,550,519 samples, 0.01%) + + + +NActors::TGenericExecutorThreadCtx::Sleep<NActors::TExecutorThreadCtx, NActors::EThreadState> (1,396,226,772 samples, 0.15%) + + + +NKikimr::TOwnedCellVecBatch::Append (3,524,659,325 samples, 0.37%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (901,577,888 samples, 0.09%) + + + +[[kernel.kallsyms]] (124,533,476 samples, 0.01%) + + + +MicroSeconds (12,364,674,535 samples, 1.28%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NTable::TBounds::CompareLastKeySearchKey (401,057,182 samples, 0.04%) + + + +std::__y1::deque<std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (4,232,578,979 samples, 0.44%) + + + +old_sort::__sort3[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (496,121,461 samples, 0.05%) + + + +[[kernel.kallsyms]] (123,909,880 samples, 0.01%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +NActors::TGenericExecutorThread::DropUnregistered (384,502,381 samples, 0.04%) + + + +[[kernel.kallsyms]] (98,815,592 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (84,316,981 samples, 0.01%) + + + +[[kernel.kallsyms]] (84,580,412 samples, 0.01%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::RemoveRanges (439,492,109 samples, 0.05%) + + + +NKikimr::NCache::TSwitchableCache<NKikimr::NTabletFlatExecutor::TSharedPageCache::TPage, NKikimr::NTabletFlatExecutor::TSharedPageCache::TCompositeCachePageTraits>::TCacheHolder::ProcessEvictedList (127,263,067 samples, 0.01%) + + + +google::protobuf::internal::ArenaStringPtr::Set (19,801,985,126 samples, 2.06%) +g.. + + +NKikimr::NMiniKQL::PgAcquireThreadContext (15,447,434,752 samples, 1.60%) + + + +NKikimr::TOwnedCellVec::Allocate (285,084,619 samples, 0.03%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (208,189,736 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (1,848,859,303 samples, 0.19%) + + + +[[kernel.kallsyms]] (82,855,316 samples, 0.01%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (85,704,996 samples, 0.01%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> (742,909,669,914 samples, 77.16%) +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> + + +[[kernel.kallsyms]] (124,533,476 samples, 0.01%) + + + +NKikimr::TPutImpl::RunStrategies (129,287,687 samples, 0.01%) + + + +NKikimr::NDataShard::TSysLocks::SetLock (628,923,744 samples, 0.07%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (645,153,651 samples, 0.07%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +[[kernel.kallsyms]] (1,226,796,296 samples, 0.13%) + + + +NActors::IEventHandle::Get<NKikimr::TEvBlobStorage::TEvVPutResult> (110,211,870 samples, 0.01%) + + + +NKikimr::NMetrics::TResourceMetricsSendState::FillChanged (154,211,905 samples, 0.02%) + + + +[[kernel.kallsyms]] (351,938,243 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (220,147,211 samples, 0.02%) + + + +[[kernel.kallsyms]] (854,257,698 samples, 0.09%) + + + +NKikimr::NMiniKQL::GetCellValue (207,277,675 samples, 0.02%) + + + +NActors::TGenericExecutorThread::Send< (111,583,922 samples, 0.01%) + + + +NActors::TExecutorPoolBaseMailboxed::Send (943,392,932 samples, 0.10%) + + + +NActors::TStatsCollectingActor::StateWork (3,207,663,319 samples, 0.33%) + + + +NKikimr::NDataShard::TDataShard::StateWork (127,987,747,753 samples, 13.29%) +NKikimr::NDataShard:.. + + +__memmove_avx_unaligned_erms (207,430,674 samples, 0.02%) + + + +[[kernel.kallsyms]] (300,501,700 samples, 0.03%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (5,956,466,708 samples, 0.62%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +_nv033886rm (86,001,079 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (84,577,193 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::Write (1,259,427,497 samples, 0.13%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::~TDirectArrayHolderInplace (2,916,327,890 samples, 0.30%) + + + +Ydb::Value::~Value (1,515,341,893 samples, 0.16%) + + + +NKikimr::ComparePointAndRange<std::__y1::vector<NKikimr::NScheme::TTypeInfo, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> > > (56,490,754,737 samples, 5.87%) +NKikimr.. + + +THashTable<std::__y1::pair<unsigned int const, NActors::TSharedData>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (316,566,058 samples, 0.03%) + + + +[[kernel.kallsyms]] (3,958,523,037 samples, 0.41%) + + + +[[kernel.kallsyms]] (3,312,419,457 samples, 0.34%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::ReplyAndDieWithLastResponse (328,338,930 samples, 0.03%) + + + +[[kernel.kallsyms]] (98,815,592 samples, 0.01%) + + + +Ydb::Query::ExecuteQueryResponsePart::~ExecuteQueryResponsePart (93,558,951,001 samples, 9.72%) +Ydb::Query::Ex.. + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +NKikimr::NDataShard::TSysLocks::ApplyLocks (3,461,645,436 samples, 0.36%) + + + +NKikimr::TTabletReqWriteLog::StateWait (96,905,368 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TTabletExecutedFlat::Execute (1,216,249,879 samples, 0.13%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (83,462,031 samples, 0.01%) + + + +std::__y1::vector<unsigned int, NPrivate::TStackBasedAllocator<unsigned int, 16ul, true, std::__y1::allocator<unsigned int> > >::reserve (84,150,536 samples, 0.01%) + + + +__GI___writev (1,259,427,497 samples, 0.13%) + + + +std::__y1::vector<NKikimr::NTable::TPartGroupRowIter, NPrivate::TStackBasedAllocator<NKikimr::NTable::TPartGroupRowIter, 16ul, true, std::__y1::allocator<NKikimr::NTable::TPartGroupRowIter> > >::reserve (170,340,978 samples, 0.02%) + + + +[[kernel.kallsyms]] (415,369,570 samples, 0.04%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::EnsureReadOnlyLease (165,542,720 samples, 0.02%) + + + +NActors::TActivationContext::Monotonic (820,678,913 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (174,200,406 samples, 0.02%) + + + +[[vdso]] (726,100,935 samples, 0.08%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Snap (163,095,211 samples, 0.02%) + + + +NKikimr::NTable::NBloom::TPrefix::TPrefix (1,156,350,243 samples, 0.12%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::ReleaseToSpans (170,191,364 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,568,562,572 samples, 0.16%) + + + +std::__y1::__function::__func<NKikimr::SkipLabels (121,064,558 samples, 0.01%) + + + +[[kernel.kallsyms]] (854,257,698 samples, 0.09%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (165,628,136 samples, 0.02%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpSessionActor::ExecuteNextStatementPart (82,002,112 samples, 0.01%) + + + +NActors::IEventHandle::ReleaseChainBuffer (210,278,040 samples, 0.02%) + + + +ydbd.System (19,016,985,450 samples, 1.98%) +y.. + + +[[kernel.kallsyms]] (853,677,860 samples, 0.09%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (207,864,261 samples, 0.02%) + + + +NKikimr::NDataShard::TExecuteKqpDataTxUnit::Execute (841,220,649 samples, 0.09%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (2,441,668,499 samples, 0.25%) + + + +SaveRecordCacheState (470,209,631 samples, 0.05%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Release (252,404,065 samples, 0.03%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::GetInputChannelFreeSpace (2,658,634,311 samples, 0.28%) + + + +[[kernel.kallsyms]] (2,044,604,680 samples, 0.21%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NActors::TGenericExecutorThreadCtx::Sleep<NActors::TExecutorThreadCtx, NActors::EThreadState> (17,551,389,699 samples, 1.82%) +N.. + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupProxy::ProcessBatchedPutRequests (538,306,215 samples, 0.06%) + + + +NKikimr::ComparePointAndRange<std::__y1::vector<NKikimr::NScheme::TTypeInfo, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> > > (1,188,710,118 samples, 0.12%) + + + +[[kernel.kallsyms]] (4,058,257,911 samples, 0.42%) + + + +std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >::__resize_default_init[abi:v180000] (206,135,780 samples, 0.02%) + + + +NKikimr::NKqp::TKqpComputeActor::StateFunc (379,680,704,112 samples, 39.44%) +NKikimr::NKqp::TKqpComputeActor::StateFunc + + +NKikimr::NKqp::TKqpProtoBuilder::TKqpProtoBuilder (147,553,909 samples, 0.02%) + + + +[[kernel.kallsyms]] (300,501,700 samples, 0.03%) + + + +NKikimr::TEvDataShard::TEvReadResult::~TEvReadResult (462,767,657 samples, 0.05%) + + + +NActors::TInterconnectSessionTCP::Handle (318,344,168 samples, 0.03%) + + + +NActors::TInterconnectSessionTCP::DropConfirmed (188,051,035 samples, 0.02%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (308,808,427 samples, 0.03%) + + + +Ydb::Value::MergeFrom (266,592,487 samples, 0.03%) + + + +__memcmp_avx2_movbe (204,280,562 samples, 0.02%) + + + +NYql::NDq::(anonymous namespace)::EstimateIntegralDataSize (718,293,869 samples, 0.07%) + + + +std::__y1::__lower_bound[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TDataPage::TRecord>, NKikimr::NTable::NPage::TDataPage::TRecord>, TArrayRef<NKikimr::TCell const>, std::__y1::__identity, NKikimr::NTable::NPage::TCompare<NKikimr::NTable::NPage::TDataPage::TRecord> > (4,519,665,066 samples, 0.47%) + + + +NKikimr::NTabletFlatExecutor::NOps::TDriver::React (169,494,191 samples, 0.02%) + + + +syscall (409,147,347 samples, 0.04%) + + + +[[kernel.kallsyms]] (2,222,268,219 samples, 0.23%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +NKikimr::NTable::TRemap::TRemap (289,611,400 samples, 0.03%) + + + +google::protobuf::internal::ArenaStringPtr::Set (88,555,462 samples, 0.01%) + + + +std::__y1::__upper_bound[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::NPage::TCompare<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, TArrayRef<NKikimr::TCell const>, std::__y1::__identity> (654,196,732 samples, 0.07%) + + + +__memmove_avx_unaligned_erms (1,383,901,336 samples, 0.14%) + + + +ssl3_write_bytes (1,044,754,672 samples, 0.11%) + + + +NActors::TGenericExecutorThread::Send< (252,136,192 samples, 0.03%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpSessionActor::ReplySuccess (482,708,948 samples, 0.05%) + + + +NKikimr::TTcMallocMonitor::Update (385,470,792 samples, 0.04%) + + + +__memmove_avx_unaligned_erms (678,769,803 samples, 0.07%) + + + +NActors::TActorIdentity::Send< (34,609,305,484 samples, 3.59%) +NAc.. + + +write_action_begin_locked (7,983,236,687 samples, 0.83%) + + + +[[kernel.kallsyms]] (1,226,796,296 samples, 0.13%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (587,868,874 samples, 0.06%) + + + +TMemoryPool::AddChunk (1,747,447,476 samples, 0.18%) + + + +__memmove_avx_unaligned_erms (617,742,445 samples, 0.06%) + + + +[[kernel.kallsyms]] (1,747,447,476 samples, 0.18%) + + + +NYql::NDq::TDqMemoryQuota::TryShrinkMemory (1,446,230,058 samples, 0.15%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (252,136,192 samples, 0.03%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::GetChannelId (546,249,136 samples, 0.06%) + + + +NKikimr::NTable::TPartGroupKeyIter::Seek (24,126,507,051 samples, 2.51%) +NK.. + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (147,851,292 samples, 0.02%) + + + +NActors::THarmonizer::PullStats (82,103,849 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupProxy::PushRequest (135,800,572 samples, 0.01%) + + + +[[kernel.kallsyms]] (385,522,544 samples, 0.04%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned int> (484,551,348 samples, 0.05%) + + + +NKikimr::NTable::TPartIter::Apply (289,725,384 samples, 0.03%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::Complete (1,002,075,358 samples, 0.10%) + + + +grpc_slice_buffer_reset_and_unref (703,371,812 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,834,271,362 samples, 0.19%) + + + +[[kernel.kallsyms]] (84,406,825 samples, 0.01%) + + + +NKikimr::NKqp::TQueryData::~TQueryData (82,002,112 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (209,597,182 samples, 0.02%) + + + +google::protobuf::internal::ArenaStringPtr::SetBytes (3,203,931,390 samples, 0.33%) + + + +[[kernel.kallsyms]] (3,999,822,839 samples, 0.42%) + + + +syscall (284,142,554 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TCommitManager::Commit (168,858,092 samples, 0.02%) + + + +pg_thread_init (127,616,787 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (89,688,096 samples, 0.01%) + + + +NKikimr::NTable::NPage::TDataPage::LookupKey (288,094,491 samples, 0.03%) + + + +NKikimr::NDataShard::TDataShard::UpdateTableStats (964,868,559 samples, 0.10%) + + + +__memmove_avx_unaligned_erms (2,415,893,857 samples, 0.25%) + + + +[[kernel.kallsyms]] (1,025,038,340 samples, 0.11%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (6,242,860,919 samples, 0.65%) + + + +NYql::NDq::TDqComputeActorMetrics::ReportEvent (778,749,603 samples, 0.08%) + + + +[[kernel.kallsyms]] (171,908,642 samples, 0.02%) + + + +TCMallocInternalNewArray (641,199,142 samples, 0.07%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::~TDirectArrayHolderInplace (179,623,590 samples, 0.02%) + + + +std::__y1::deque<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> >::emplace_back<std::__y1::vector<NKikimr::TCell, std::__y1::allocator<NKikimr::TCell> > > (426,972,581 samples, 0.04%) + + + +NKikimr::NKqp::TKqpLookupRows::AddInputRow (954,857,015 samples, 0.10%) + + + +[[kernel.kallsyms]] (16,681,417,319 samples, 1.73%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::CommitTransactionLog (81,798,626 samples, 0.01%) + + + +NKikimr::TLocalNodeRegistrar::StateWork (141,020,433 samples, 0.01%) + + + +google::protobuf::internal::ArenaStringPtr::Set (914,025,910 samples, 0.09%) + + + +[[kernel.kallsyms]] (1,022,776,277 samples, 0.11%) + + + +NActors::TCpuManager::GetPoolStats (2,097,502,898 samples, 0.22%) + + + +NActors::TActivationContext::LoggerSettings (1,340,479,432 samples, 0.14%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (4,747,200,716 samples, 0.49%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::AddRange (2,830,008,742 samples, 0.29%) + + + +tcmalloc::tcmalloc_internal::Span::FreelistPopBatchSized< (88,555,462 samples, 0.01%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (214,968,019 samples, 0.02%) + + + +NActors::TGenericExecutorThreadCtx::Spin<NActors::TExecutorThreadCtx, NActors::EThreadState> (5,310,615,278 samples, 0.55%) + + + +__memmove_avx_unaligned_erms (337,028,025 samples, 0.04%) + + + +NActors::TGenericExecutorThread::Send< (82,185,134 samples, 0.01%) + + + +NYql::NDq::TComputeActorAsyncInputHelper::PollAsyncInput (97,668,334,950 samples, 10.14%) +NYql::NDq::TCo.. + + +Ydb::Value::~Value (82,002,112 samples, 0.01%) + + + +[[kernel.kallsyms]] (123,909,880 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (4,329,001,423 samples, 0.45%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::Read (5,307,586,498 samples, 0.55%) + + + +google::protobuf::Arena::CreateMaybeMessage<Ydb::Value> (14,591,905,264 samples, 1.52%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NTxMediator::TTxMediator::Handle (451,018,478 samples, 0.05%) + + + +NActors::TEventHolderPool::Trim (166,249,850 samples, 0.02%) + + + +google::protobuf::internal::UTF8GenericScan (4,243,365,572 samples, 0.44%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (164,619,968 samples, 0.02%) + + + +NYql::NDq::TComputeActorAsyncInputHelperSync::GetFreeSpace (120,292,868 samples, 0.01%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::__unordered_map_hasher<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::hash<unsigned long>, std::__y1::equal_to<unsigned long>, true>, std::__y1::__unordered_map_equal<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::equal_to<unsigned long>, std::__y1::hash<unsigned long>, true>, std::__y1::allocator<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > > > >::erase (215,188,395 samples, 0.02%) + + + +NKikimr::NTable::NPage::TLabelWrapper::Read (82,797,321 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::ReadRange (2,064,830,521 samples, 0.21%) + + + +NKikimr::NBsQueue::TEventHolder::TEventHolder<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPut>, TDelete> > (210,278,040 samples, 0.02%) + + + +[[kernel.kallsyms]] (130,232,041 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputMapConsumer::IsFull (166,831,044 samples, 0.02%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::GetRowId (83,374,735 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::WriteData (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (83,480,588 samples, 0.01%) + + + +[[kernel.kallsyms]] (84,406,825 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (310,378,871 samples, 0.03%) + + + +[[kernel.kallsyms]] (1,747,447,476 samples, 0.18%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (2,550,229,202 samples, 0.26%) + + + +std::__y1::vector<unsigned long, std::__y1::allocator<unsigned long> >::__assign_with_size[abi:v180000]<unsigned long*, unsigned long*> (132,653,379 samples, 0.01%) + + + +restore_stack_base (248,530,370 samples, 0.03%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (286,501,058 samples, 0.03%) + + + +__memmove_avx_unaligned_erms (3,073,983,748 samples, 0.32%) + + + +NActors::TActorIdentity::Send< (252,136,192 samples, 0.03%) + + + +NKikimr::NKqp::TQueryData::ExtractTrailingTxResult (400,706,836 samples, 0.04%) + + + +[[kernel.kallsyms]] (82,649,394 samples, 0.01%) + + + +NKikimr::TPathId::operator== (86,532,197 samples, 0.01%) + + + +NKikimr::NDataShard::TLockInfo::AddPoint (503,150,074 samples, 0.05%) + + + +std::__y1::make_unique[abi:v180000]<NKikimr::TEvBlobStorage::TEvVPut, NKikimr::TLogoBlobID&, TRope&, NKikimr::TVDiskID, bool, decltype (109,825,268 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (1,325,762,882 samples, 0.14%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (125,478,900,356 samples, 13.03%) +NKikimr::NTabletFla.. + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NActors::TActorCallbackBehaviour::Receive (260,416,739 samples, 0.03%) + + + +NYql::NDq::(anonymous namespace)::EstimateSizeImpl (6,058,772,527 samples, 0.63%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (416,482,480 samples, 0.04%) + + + +[unknown] (130,764,729 samples, 0.01%) + + + +[[kernel.kallsyms]] (125,763,990 samples, 0.01%) + + + +NActors::TActivationContext::Send< (224,541,775 samples, 0.02%) + + + +[[kernel.kallsyms]] (98,815,592 samples, 0.01%) + + + +NKikimr::TPutImpl::TPutImpl (86,134,430 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,133,319,065 samples, 0.12%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (122,155,068 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::Lookup (205,728,230 samples, 0.02%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +[[kernel.kallsyms]] (278,226,160 samples, 0.03%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::__unordered_map_hasher<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::hash<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::equal_to<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, true>, std::__y1::__unordered_map_equal<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::equal_to<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::hash<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, true>, std::__y1::allocator<std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > > > >::find<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > > (276,087,221 samples, 0.03%) + + + +NKikimr::NTable::TRowState::Set (116,471,021 samples, 0.01%) + + + +NKikimr::TCountersArray<NKikimr::TTabletPercentileCounter>::Reset (382,645,285 samples, 0.04%) + + + +[[hid]] (332,347,330 samples, 0.03%) + + + +NKikimr::TTabletMon::RecalcAll (208,150,149 samples, 0.02%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::TTabletMon::TTabletCountersForTabletType::TSolomonCounters::Apply (579,605,575 samples, 0.06%) + + + +NKikimr::TBlackboard::RunStrategies (189,117,480 samples, 0.02%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Acquire (184,307,548 samples, 0.02%) + + + +evp_EncryptDecryptUpdate (129,511,620 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (253,749,677 samples, 0.03%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (1,426,779,049 samples, 0.15%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> (837,664,016 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (84,040,239 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,538,324 samples, 0.01%) + + + +__memcmp_avx2_movbe (205,105,597 samples, 0.02%) + + + +NActors::TGenericExecutorThreadCtx::Sleep<NActors::TExecutorThreadCtx, NActors::EThreadState> (1,358,351,871 samples, 0.14%) + + + +NActors::TGenericExecutorThread::Send< (106,273,929 samples, 0.01%) + + + +NKikimr::NTable::TDatabase::Select (3,122,138,751 samples, 0.32%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (207,864,261 samples, 0.02%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (207,864,261 samples, 0.02%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +[[kernel.kallsyms]] (375,638,040 samples, 0.04%) + + + +NActors::TBasicExecutorPool::GetCurrentStats (2,018,322,468 samples, 0.21%) + + + +NKikimr::TBlobStorageGroupPutRequest::TBlobStorageGroupPutRequest (252,359,255 samples, 0.03%) + + + +[[kernel.kallsyms]] (422,604,228 samples, 0.04%) + + + +NActors::TBasicSchedulerThread::CycleFunc (21,532,183,247 samples, 2.24%) +N.. + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<__int128> (327,224,092 samples, 0.03%) + + + +std::__y1::deque<NKikimr::NKqp::TKqpStreamLookupWorker::TShardReadResult, std::__y1::allocator<NKikimr::NKqp::TKqpStreamLookupWorker::TShardReadResult> >::pop_front (462,767,657 samples, 0.05%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (409,147,347 samples, 0.04%) + + + +NActors::NSchedulerQueue::TReader::Pop (183,579,048 samples, 0.02%) + + + +NActors::TActivationContextHolder::operator* (87,930,446 samples, 0.01%) + + + +ssl3_write_pending (288,781,398 samples, 0.03%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (126,453,954 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (424,308,339 samples, 0.04%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum>, std::__y1::__unordered_map_hasher<std::__y1::pair<unsigned char, unsigned int>, std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum>, std::__y1::hash<std::__y1::pair<unsigned char, unsigned int> >, std::__y1::equal_to<std::__y1::pair<unsigned char, unsigned int> >, true>, std::__y1::__unordered_map_equal<std::__y1::pair<unsigned char, unsigned int>, std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum>, std::__y1::equal_to<std::__y1::pair<unsigned char, unsigned int> >, std::__y1::hash<std::__y1::pair<unsigned char, unsigned int> >, true>, std::__y1::allocator<std::__y1::__hash_value_type<std::__y1::pair<unsigned char, unsigned int>, NKikimr::NMetrics::TDecayingAverageWithSum> > >::__emplace_unique_key_args<std::__y1::pair<unsigned char, unsigned int>, std::__y1::piecewise_construct_t const&, std::__y1::tuple<std::__y1::pair<unsigned char, unsigned int> const&>, std::__y1::tuple<> > (84,261,294 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (2,448,192,946 samples, 0.25%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (165,638,048 samples, 0.02%) + + + +Ydb::Value::clear_value (987,910,908 samples, 0.10%) + + + +NActors::TEventPBBase<NKikimr::TEvBlobStorage::TEvVPut, NKikimrBlobStorage::TEvVPut, 268633088u, NActors::TRecordHolder<NKikimrBlobStorage::TEvVPut> >::SerializeToArcadiaStream (111,061,393 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +std::__y1::vector<NKikimr::NDataShard::TPointKey, std::__y1::allocator<NKikimr::NDataShard::TPointKey> >::__emplace_back_slow_path<NKikimr::NDataShard::TPointKey const&> (248,832,644 samples, 0.03%) + + + +[[kernel.kallsyms]] (17,083,319,189 samples, 1.77%) + + + +NActors::TActivationContext::LoggerSettings (171,099,743 samples, 0.02%) + + + +NKikimr::NKqp::TSchedulableComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DoExecuteImpl (700,355,707 samples, 0.07%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (6,028,535,602 samples, 0.63%) + + + +NYql::NDq::TDqComputeActorChannels::InCh (205,077,156 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorChannels::HandleWork (423,317,679 samples, 0.04%) + + + +NKikimr::NKqp::TKqpLookupRows::BuildRequests (69,735,950,078 samples, 7.24%) +NKikimr::N.. + + +std::__y1::deque<NKikimr::NTable::TPartIter, std::__y1::allocator<NKikimr::NTable::TPartIter> >::__add_back_capacity (125,197,202 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (169,059,753 samples, 0.02%) + + + +NKikimr::NMiniKQL::TPagedBuffer::Advance (173,737,479 samples, 0.02%) + + + +google::protobuf::internal::GenericSwap (400,706,836 samples, 0.04%) + + + +NActors::TPoolInfo::PullStats (255,055,660 samples, 0.03%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (432,078,589 samples, 0.04%) + + + +[[kernel.kallsyms]] (409,147,347 samples, 0.04%) + + + +NYql::NDq::TDqInputChannel::DeserializeAllData (287,441,170 samples, 0.03%) + + + +NKikimr::TPinnedPageRef::Drop (165,559,681 samples, 0.02%) + + + +NYql::NDq::TDqInputImpl<NYql::NDq::TDqAsyncInputBuffer, NYql::NDq::IDqAsyncInputBuffer>::GetFreeSpace (413,727,206 samples, 0.04%) + + + +NActors::IActor::Send (456,271,707 samples, 0.05%) + + + +NActors::IActor::Send (123,408,435 samples, 0.01%) + + + +NYql::NDq::TDqInputChannel::Pop (14,050,181,435 samples, 1.46%) + + + +syscall (301,204,087 samples, 0.03%) + + + +NActors::TActivationContextHolder::operator (123,165,018 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,747,447,476 samples, 0.18%) + + + +NKikimr::NTable::TPartScheme::MakePinout (791,983,934 samples, 0.08%) + + + +__memmove_avx_unaligned_erms (429,501,694 samples, 0.04%) + + + +std::__y1::__tree<std::__y1::__value_type<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::TSystemColumnInfo>, std::__y1::__map_value_compare<TBasicString<char, std::__y1::char_traits<char> >, std::__y1::__value_type<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::TSystemColumnInfo>, TLess<TBasicString<char, std::__y1::char_traits<char> > >, true>, std::__y1::allocator<std::__y1::__value_type<TBasicString<char, std::__y1::char_traits<char> >, NKikimr::TSystemColumnInfo> > >::find<TBasicStringBuf<char, std::__y1::char_traits<char> > > (3,491,039,611 samples, 0.36%) + + + +THashTable<std::__y1::pair<NKikimr::TLogoBlobID const, THashMap<unsigned int, NActors::TSharedData, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> > >, NKikimr::TLogoBlobID, THash<NKikimr::TLogoBlobID>, TSelect1st, TEqualTo<NKikimr::TLogoBlobID>, std::__y1::allocator<NKikimr::TLogoBlobID> >::basic_clear (293,934,747 samples, 0.03%) + + + +NKikimr::CompareTypedCells (85,689,011 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (86,533,802 samples, 0.01%) + + + +__memcmp_avx2_movbe (165,546,559 samples, 0.02%) + + + +std::__y1::vector<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey, std::__y1::allocator<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey> >::__emplace_back_slow_path<NKikimr::NMiniKQL::IEngineFlat::TValidatedKey> (126,061,983 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::NOps::TDriver::React (216,000,048 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (81,873,064 samples, 0.01%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Release (96,666,964 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (1,348,808,418 samples, 0.14%) + + + +NKikimr::NMiniKQL::GetCellValue (5,493,144,556 samples, 0.57%) + + + +NKikimr::NMiniKQL::TPagedBuffer::Advance (814,740,300 samples, 0.08%) + + + +NKikimr::NTabletPipe::TServer::StateActive (91,531,311 samples, 0.01%) + + + +NActors::TGenericExecutorThread::RegisterActor< (88,691,416 samples, 0.01%) + + + +Ydb::Value::Clear (91,898,409 samples, 0.01%) + + + +NActors::TActivationContextHolder::operator* (127,059,221 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (86,533,802 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::DestroyProtos (82,002,112 samples, 0.01%) + + + +NActors::TActivationContextHolder::operator* (912,888,218 samples, 0.09%) + + + +syscall (4,172,755,882 samples, 0.43%) + + + +NActors::TStatsCollectingActor::Wakeup (3,207,663,319 samples, 0.33%) + + + +NActors::TActivationContext::LoggerSettings (167,831,623 samples, 0.02%) + + + +NActors::TExecutorThreadCtx::WakeUp (409,147,347 samples, 0.04%) + + + +TCMallocInternalNewArray (86,055,165 samples, 0.01%) + + + +NActors::TActivationContext::Send< (125,290,263 samples, 0.01%) + + + +NYql::NDq::TDqInputChannel::GetFreeSpace (1,181,103,751 samples, 0.12%) + + + +NActors::TInterconnectSessionTCP::MakePacket (122,147,110 samples, 0.01%) + + + +grpc_combiner_continue_exec_ctx (7,983,236,687 samples, 0.83%) + + + +[[kernel.kallsyms]] (16,245,417,032 samples, 1.69%) + + + +std::__y1::__shared_ptr_emplace<NKikimr::NMiniKQL::TPagedBuffer, std::__y1::allocator<NKikimr::NMiniKQL::TPagedBuffer> >::__on_zero_shared (119,969,672 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (2,025,032,618 samples, 0.21%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::ExportValueToProtoImpl (60,937,474,917 samples, 6.33%) +NKikimr:.. + + +TCMallocInternalNewArray (816,340,579 samples, 0.08%) + + + +__memset_avx2_unaligned_erms (331,834,440 samples, 0.03%) + + + +[ydbd] (286,239,299 samples, 0.03%) + + + +[[kernel.kallsyms]] (3,055,101,096 samples, 0.32%) + + + +std::__y1::vector<NActors::TExecutorThreadStats, std::__y1::allocator<NActors::TExecutorThreadStats> >::__append (413,293,420 samples, 0.04%) + + + +[[kernel.kallsyms]] (415,369,570 samples, 0.04%) + + + +[[kernel.kallsyms]] (84,580,412 samples, 0.01%) + + + +NKikimr::NTxMediator::TTxMediator::StateWork (451,018,478 samples, 0.05%) + + + +[[kernel.kallsyms]] (218,219,037 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (212,593,813 samples, 0.02%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DrainOutputChannel (406,233,714 samples, 0.04%) + + + +NKikimr::TTabletMon::Apply (579,605,575 samples, 0.06%) + + + +__memmove_avx_unaligned_erms (166,393,044 samples, 0.02%) + + + +grpc_core::ExecCtx::Flush (8,103,055,301 samples, 0.84%) + + + +[[kernel.kallsyms]] (98,815,592 samples, 0.01%) + + + +pg_thread_init (132,012,898 samples, 0.01%) + + + +[[kernel.kallsyms]] (415,369,570 samples, 0.04%) + + + +NHPTimer::GetSeconds (1,719,202,974 samples, 0.18%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::HasSchemaChanges (797,246,171 samples, 0.08%) + + + +NActors::TBasicExecutorPool::GetThreadCpuConsumption (120,676,206 samples, 0.01%) + + + +SaveRecordCacheState (206,853,712 samples, 0.02%) + + + +[[kernel.kallsyms]] (626,610,060 samples, 0.07%) + + + +[[kernel.kallsyms]] (1,747,447,476 samples, 0.18%) + + + +NYql::NDq::TDqComputeActorChannels::OutCh (3,086,498,147 samples, 0.32%) + + + +NKikimr::(anonymous namespace)::TMemProfMonitor::StateWork (385,470,792 samples, 0.04%) + + + +__memmove_avx_unaligned_erms (85,510,584 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::InternalExtend (625,856,502 samples, 0.07%) + + + +LoadRecordCacheState (218,945,939 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (2,283,004,481 samples, 0.24%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::~TPartGroupFlatIndexIter (124,937,973 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper (1,740,382,255 samples, 0.18%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (119,804,070 samples, 0.01%) + + + +std::__y1::deque<NKikimr::NTable::TPartIter, std::__y1::allocator<NKikimr::NTable::TPartIter> >::emplace_back<NKikimr::NTable::TPart const*&, TArrayRef<unsigned int const>&, TIntrusiveConstPtr<NKikimr::NTable::TKeyCellDefaults, TDefaultIntrusivePtrOps<NKikimr::NTable::TKeyCellDefaults> > const&, NKikimr::NTable::IPages*&> (911,951,179 samples, 0.09%) + + + +NKikimr::CompareTypedCells (380,763,044 samples, 0.04%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (82,185,134 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (85,334,466 samples, 0.01%) + + + +grpc_core::SslProtectorProtect (2,448,594,145 samples, 0.25%) + + + +__dynamic_cast (87,963,638 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (119,969,672 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (4,172,216,762 samples, 0.43%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +__madvise (206,510,236 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (750,838,114 samples, 0.08%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (159,311,107 samples, 0.02%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Next (126,159,026 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (422,049,219 samples, 0.04%) + + + +NYql::NDq::TDqInputChannel::PushImpl (287,441,170 samples, 0.03%) + + + +[[kernel.kallsyms]] (351,938,243 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::HugeCache::ShrinkCache (206,510,236 samples, 0.02%) + + + +NKikimr::TPutImpl::GeneratePutRequests (109,825,268 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::reserve (82,589,434 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::Execute (110,896,679,262 samples, 11.52%) +NKikimr::NDataSha.. + + +[[kernel.kallsyms]] (1,287,650,663 samples, 0.13%) + + + +NActors::TGenericExecutorThreadCtx::Spin<NActors::TExecutorThreadCtx, NActors::EThreadState> (7,173,218,070 samples, 0.75%) + + + +syscall (82,185,134 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::SendReply (252,136,192 samples, 0.03%) + + + +NKikimr::NTable::TRemap::~TRemap (6,158,573,899 samples, 0.64%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::ReadRange (126,159,026 samples, 0.01%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (195,882,525 samples, 0.02%) + + + +[[kernel.kallsyms]] (15,470,249,185 samples, 1.61%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (1,095,452,344 samples, 0.11%) + + + +NKikimr::NBsQueue::TEventHolder::SendToVDisk (334,845,359 samples, 0.03%) + + + +NKikimr::TOwnedCellVec::Allocate (744,860,007 samples, 0.08%) + + + +[[kernel.kallsyms]] (334,719,420 samples, 0.03%) + + + +[[kernel.kallsyms]] (2,767,150,918 samples, 0.29%) + + + +[[kernel.kallsyms]] (82,185,134 samples, 0.01%) + + + +TCMallocInternalAlignedAlloc (119,164,995 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (298,324,405 samples, 0.03%) + + + +syscall (1,344,827,460 samples, 0.14%) + + + +NKikimr::TTablet::CheckEntry (456,271,707 samples, 0.05%) + + + +NActors::TGenericExecutorThread::Send< (27,275,821,809 samples, 2.83%) +NA.. + + +NKikimr::TBlobStorageGroupProxy::HandleNormal (166,818,189 samples, 0.02%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::FinishPackAndCheckSize (1,838,077,772 samples, 0.19%) + + + +std::__y1::vector<unsigned int, NPrivate::TStackBasedAllocator<unsigned int, 16ul, true, std::__y1::allocator<unsigned int> > >::reserve (83,750,852 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +set_stack_base (89,665,735 samples, 0.01%) + + + +Ydb::ResultSet::ByteSizeLong (57,303,167,595 samples, 5.95%) +Ydb::Re.. + + +Ydb::Column::_InternalSerialize (124,769,531 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (208,799,526 samples, 0.02%) + + + +std::__y1::vector<char, NPrivate::TStackBasedAllocator<char, 16ul, true, std::__y1::allocator<char> > >::reserve (415,549,896 samples, 0.04%) + + + +[[kernel.kallsyms]] (409,147,347 samples, 0.04%) + + + +NActors::TActivationContextHolder::operator (588,680,015 samples, 0.06%) + + + +NKikimr::NDataShard::TPipeline::RunExecutionPlan (876,260,139 samples, 0.09%) + + + +[[kernel.kallsyms]] (278,226,160 samples, 0.03%) + + + +[[kernel.kallsyms]] (133,171,484 samples, 0.01%) + + + +NKikimr::NTable::NPage::TFlatIndex::LookupKey (695,416,271 samples, 0.07%) + + + +NActors::TInterconnectSessionTCP::FillSendingBuffer (83,641,762 samples, 0.01%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (907,346,793,356 samples, 94.24%) +NActors::TGenericExecutorThread::ProcessExecutorPool + + +[[kernel.kallsyms]] (716,281,440 samples, 0.07%) + + + +NYql::NDq::TDqInputChannel::PushImpl (14,050,181,435 samples, 1.46%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +_nv034985rm (84,406,825 samples, 0.01%) + + + +std::__y1::vector<NKikimr::NTable::TCellOp, NPrivate::TStackBasedAllocator<NKikimr::NTable::TCellOp, 64ul, true, std::__y1::allocator<NKikimr::NTable::TCellOp> > >::assign (252,683,065 samples, 0.03%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::IsFull (466,562,881 samples, 0.05%) + + + +[[kernel.kallsyms]] (915,067,300 samples, 0.10%) + + + +NKikimr::NKqp::TKqpProtoBuilder::~TKqpProtoBuilder (166,114,526 samples, 0.02%) + + + +NKikimr::TTabletReqWriteLog::SendToBS (170,076,717 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (88,555,462 samples, 0.01%) + + + +NKikimr::NKqp::TSchedulableComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::AccountActorSystemStats (284,472,220 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::TranslateCacheTouchesToSharedCache (81,802,196 samples, 0.01%) + + + +NActors::TActivationContextHolder::operator (249,664,535 samples, 0.03%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::BaseStateFuncBody (3,955,863,554 samples, 0.41%) + + + +[[kernel.kallsyms]] (854,257,698 samples, 0.09%) + + + +NActors::TGenericExecutorThreadCtx::Spin<NActors::TExecutorThreadCtx, NActors::EThreadState> (4,760,872,075 samples, 0.49%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (2,025,032,618 samples, 0.21%) + + + +[[kernel.kallsyms]] (626,610,060 samples, 0.07%) + + + +NActors::IActor::Send (85,485,621 samples, 0.01%) + + + +NActors::TThreadParkPad::Park (517,864,794 samples, 0.05%) + + + +NActors::TInterconnectSessionTCP::Enqueue (298,892,903 samples, 0.03%) + + + +__libc_recv (84,580,412 samples, 0.01%) + + + +_nv033886rm (84,406,825 samples, 0.01%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::HandleResponse<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPutResult>, TDelete> > (900,103,865 samples, 0.09%) + + + +Ydb::Value::~Value (82,002,112 samples, 0.01%) + + + +syscall (171,908,642 samples, 0.02%) + + + +[[kernel.kallsyms]] (798,295,462 samples, 0.08%) + + + +[[kernel.kallsyms]] (385,522,544 samples, 0.04%) + + + +[[kernel.kallsyms]] (1,204,719,283 samples, 0.13%) + + + +[[kernel.kallsyms]] (1,000,927,591 samples, 0.10%) + + + +__memset_avx2_unaligned_erms (89,279,582 samples, 0.01%) + + + +Ydb::ResultSet::~ResultSet (93,558,951,001 samples, 9.72%) +Ydb::ResultSet.. + + +[[kernel.kallsyms]] (415,369,570 samples, 0.04%) + + + +NKikimr::NTxMediator::TTxMediator::ProcessDomainStep (451,018,478 samples, 0.05%) + + + +NKikimr::NGRpcService::(anonymous namespace)::TExecuteQueryRPC::StateWork (218,769,885,456 samples, 22.72%) +NKikimr::NGRpcService::(anonymous n.. + + +__memset_avx2_unaligned_erms (220,185,173 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (83,462,031 samples, 0.01%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::Enqueue<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPut>, TDelete> > (255,904,965 samples, 0.03%) + + + +[[kernel.kallsyms]] (171,908,642 samples, 0.02%) + + + +NKikimr::ComparePrefixBorders (167,640,051 samples, 0.02%) + + + +NActors::TExecutorPoolBaseMailboxed::Send (1,848,324,913 samples, 0.19%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (2,245,184,465 samples, 0.23%) + + + +NKikimr::TTabletCountersBase::operator= (502,327,474 samples, 0.05%) + + + +[[kernel.kallsyms]] (82,185,134 samples, 0.01%) + + + +_nv031787rm (84,406,825 samples, 0.01%) + + + +NKikimr::NTable::TPartGroupKeyIter::Seek (1,436,518,214 samples, 0.15%) + + + +[[kernel.kallsyms]] (98,815,592 samples, 0.01%) + + + +NActors::THarmonizer::Harmonize (82,103,849 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (497,650,027 samples, 0.05%) + + + +TCMallocInternalNewArray (85,970,679 samples, 0.01%) + + + +NThreading::TLegacyFuture<void, false>::DoExecute (21,532,183,247 samples, 2.24%) +N.. + + +[[kernel.kallsyms]] (16,417,447,011 samples, 1.71%) + + + +NActors::TActorContext::Send< (111,583,922 samples, 0.01%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::TryGetIndex (1,199,575,147 samples, 0.12%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (301,204,087 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (84,092,828 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (206,134,757 samples, 0.02%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpSessionActor::ProcessExecuterResult (482,708,948 samples, 0.05%) + + + +NKikimr::TEvBlobStorage::TEvPut::~TEvPut (93,718,742 samples, 0.01%) + + + +google::protobuf::internal::GenericSwap (85,957,878 samples, 0.01%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (82,185,134 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ConfirmReadOnlyLease (165,542,720 samples, 0.02%) + + + +[[kernel.kallsyms]] (348,697,884 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (294,156,288 samples, 0.03%) + + + +std::__y1::vector<NKikimr::NTable::TPartGroupRowIter, NPrivate::TStackBasedAllocator<NKikimr::NTable::TPartGroupRowIter, 16ul, true, std::__y1::allocator<NKikimr::NTable::TPartGroupRowIter> > >::__destroy_vector::operator (206,928,389 samples, 0.02%) + + + +NKikimr::NDataShard::TDataShard::TTxInitiateStatsUpdate::Execute (879,574,589 samples, 0.09%) + + + +NKikimr::NTable::NPage::TDataPageRecord<NKikimr::NTable::NPage::TDataPage::TRecord, NKikimr::NTable::NPage::TDataPage::TItem>::Cell (125,966,657 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (2,245,184,465 samples, 0.23%) + + + +tcmalloc::tcmalloc_internal::(anonymous namespace)::do_free_pages (206,510,236 samples, 0.02%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Start (546,409,763 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (1,533,524,774 samples, 0.16%) + + + +NActors::TActorBootstrapped<NKikimr::TTabletReqWriteLog>::StateBootstrap (369,022,458 samples, 0.04%) + + + +google::protobuf::internal::ArenaStringPtr::Set (421,248,118 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (324,269,913 samples, 0.03%) + + + +Ydb::Value::_InternalSerialize (25,789,283,669 samples, 2.68%) +Yd.. + + +NKikimr::TBlobStorageGroupPutRequest::~TBlobStorageGroupPutRequest (260,043,761 samples, 0.03%) + + + +NYdbGrpc::TGRpcRequestImpl<Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, NKikimr::NGRpcService::TGRpcYdbQueryService, google::protobuf::TextFormat::Printer, google::protobuf::TextFormat::Printer>::WriteByteDataOk (8,218,794,161 samples, 0.85%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (609,221,253 samples, 0.06%) + + + +NKikimr::NMiniKQL::TScopedAlloc::Acquire (422,182,642 samples, 0.04%) + + + +NYql::NDq::TDqTaskRunner::FetchAndDispatch (103,981,467,212 samples, 10.80%) +NYql::NDq::TDqTa.. + + +std::__y1::vector<unsigned int, NPrivate::TStackBasedAllocator<unsigned int, 16ul, true, std::__y1::allocator<unsigned int> > >::__append (89,238,849 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupRequestActor<NKikimr::TBlobStorageGroupPutRequest>::SendResponse (252,136,192 samples, 0.03%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +NKikimr::TEvDataShard::TEvReadResult::~TEvReadResult (462,767,657 samples, 0.05%) + + + +old_sort::__sort3[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (210,225,724 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::RemoveRange (217,602,507 samples, 0.02%) + + + +NYql::NUdf::TUnboxedValuePod::AsStringRef (558,264,289 samples, 0.06%) + + + +Ydb::Value::ByteSizeLong (56,585,718,269 samples, 5.88%) +Ydb::Va.. + + +std::__y1::vector<char, NPrivate::TStackBasedAllocator<char, 16ul, true, std::__y1::allocator<char> > >::__insert_with_size[abi:v180000]<char const*, char const*> (576,723,827 samples, 0.06%) + + + +NKikimr::NKqp::TSchedulableComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DoExecuteImpl (383,864,022 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (121,163,066 samples, 0.01%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::IsFull (334,702,255 samples, 0.03%) + + + +__memmove_avx_unaligned_erms (248,363,091 samples, 0.03%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (8,892,327,312 samples, 0.92%) + + + +Ydb::Column::~Column (83,633,501 samples, 0.01%) + + + +NActors::TSharedExecutorPool::GetSharedStatsForHarmonizer (89,279,582 samples, 0.01%) + + + +TCMallocInternalNewArray (273,094,997 samples, 0.03%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (881,346,782,152 samples, 91.54%) +NActors::TGenericExecutorThread::ProcessExecutorPool + + +NKikimr::NTable::NPage::TDataPageRecord<NKikimr::NTable::NPage::TDataPage::TRecord, NKikimr::NTable::NPage::TDataPage::TItem>::Cell (2,781,804,883 samples, 0.29%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (9,546,953,034 samples, 0.99%) + + + +[[kernel.kallsyms]] (86,907,510 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackImpl<false, false, NKikimr::NMiniKQL::TPagedBuffer> (26,321,152,821 samples, 2.73%) +NK.. + + +NActors::TActivationContext::Send< (111,967,540 samples, 0.01%) + + + +NKikimr::NDataShard::(anonymous namespace)::TCellBlockBuilder::AddRow (118,101,608 samples, 0.01%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::GetEndRowId (166,389,270 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorChannels::PollChannel (2,962,716,829 samples, 0.31%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (11,964,153,477 samples, 1.24%) + + + +NKikimr::NTable::TPartIter::TPartIter (834,367,646 samples, 0.09%) + + + +TCMallocInternalAlignedAlloc (209,239,577 samples, 0.02%) + + + +NKikimr::ComparePrefixBorders (82,122,820 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (87,906,983 samples, 0.01%) + + + +_nv030047rm (84,406,825 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::__append (84,477,828 samples, 0.01%) + + + +BIO_read (1,325,762,882 samples, 0.14%) + + + +NKikimr::NDataShard::TDataShard::TTxReadContinue::Execute (5,434,122,140 samples, 0.56%) + + + +NActors::IActor::Send (38,853,214,391 samples, 4.04%) +NAct.. + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (1,306,565,889 samples, 0.14%) + + + +NActors::TActivationContextHolder::operator (458,107,458 samples, 0.05%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::TryGetIndex (164,310,370 samples, 0.02%) + + + +MicroSeconds (27,857,672,162 samples, 2.89%) +Mi.. + + +[[kernel.kallsyms]] (82,649,394 samples, 0.01%) + + + +NKikimr::NTable::NPage::TDataPageWriter::Put (152,172,403 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,344,827,444 samples, 0.14%) + + + +NKikimr::TBlobStorageGroupProxy::Handle (574,854,225 samples, 0.06%) + + + +NKikimr::NTabletFlatExecutor::TOpsCompact::Feed (169,494,191 samples, 0.02%) + + + +NActors::TExecutorThreadStats::Aggregate (630,970,080 samples, 0.07%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (181,880,917 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (795,012,113 samples, 0.08%) + + + +NRopeDetails::TChunkList<TRcBuf>::Erase (382,853,727 samples, 0.04%) + + + +NYql::NDecimal::Serialize (340,772,851 samples, 0.04%) + + + +rm_isr (127,472,478 samples, 0.01%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpSessionActor::ExecuteState (482,708,948 samples, 0.05%) + + + +NKikimr::TEvTablet::TEvCommit::~TEvCommit (413,142,304 samples, 0.04%) + + + +[[kernel.kallsyms]] (171,908,642 samples, 0.02%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::SendToVDisk (334,845,359 samples, 0.03%) + + + +NActors::TMailboxHeader::MarkForSchedule (85,334,466 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorChannels::OutCh (2,045,583,288 samples, 0.21%) + + + +NYql::NDq::TComputeActorAsyncInputHelper::PollAsyncInput (124,152,649 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NActors::TExecutorThreadStats::MaxActivityType (204,607,297 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,705,065,720 samples, 0.18%) + + + +NActors::TExecutorThreadCtx::WakeUp (4,368,517,466 samples, 0.45%) + + + +THashTable<NKikimr::TPathId, NKikimr::TPathId, THash<NKikimr::TPathId>, TIdentity, TEqualTo<NKikimr::TPathId>, std::__y1::allocator<NKikimr::TPathId> >::insert_unique_noresize<NKikimr::TPathId> (211,931,780 samples, 0.02%) + + + +NKikimr::NMiniKQL::MakeString (1,956,593,000 samples, 0.20%) + + + +[[kernel.kallsyms]] (944,738,357 samples, 0.10%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::DoExecute (921,942,876 samples, 0.10%) + + + +[[kernel.kallsyms]] (181,880,917 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (256,257,421 samples, 0.03%) + + + +_nv041366rm (84,406,825 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (209,726,702 samples, 0.02%) + + + +NKikimr::NDataShard::TLockInfo::OnRemoved (401,728,540 samples, 0.04%) + + + +clock_nanosleep@GLIBC_2.2.5 (18,248,479,803 samples, 1.90%) +c.. + + +NYql::NDecimal::Deserialize (209,725,778 samples, 0.02%) + + + +[[kernel.kallsyms]] (82,185,134 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TPageCollectionReadEnv::TryGetPage (205,728,230 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,226,796,296 samples, 0.13%) + + + +NActors::TActorSystem::Send< (609,221,253 samples, 0.06%) + + + +[[kernel.kallsyms]] (1,074,637,236 samples, 0.11%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (3,032,040,182 samples, 0.31%) + + + +NKikimr::NTable::NPage::TDataPage::LookupKey (6,383,464,832 samples, 0.66%) + + + +__libc_sendmsg (4,038,512,445 samples, 0.42%) + + + +[[kernel.kallsyms]] (1,747,447,476 samples, 0.18%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DoExecuteImpl (320,644,535,183 samples, 33.30%) +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKq.. + + +NHPTimer::GetSeconds (1,172,859,292 samples, 0.12%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::PollAsyncInput (154,402,343,390 samples, 16.04%) +NYql::NDq::TDqComputeAct.. + + +NYql::NDq::TDqComputeActorChannels::PollChannel (179,595,878 samples, 0.02%) + + + +NActors::TExecutorThreadCtx::WakeUp (82,185,134 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (2,245,184,465 samples, 0.23%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (128,405,022 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,025,035,116 samples, 0.11%) + + + +[[kernel.kallsyms]] (84,406,825 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorChannels::HasFreeMemoryInChannel (4,152,796,291 samples, 0.43%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (208,629,504 samples, 0.02%) + + + +NActors::TMailboxHeader::MarkForSchedule (485,258,807 samples, 0.05%) + + + +std::__y1::__variant_detail::__visitation::__base::__dispatcher<0ul>::__dispatch[abi:v180000]<std::__y1::__variant_detail::__visitation::__variant::__value_visitor<NActors::TBasicExecutorPool::GetReadyActivationCommon (398,135,881 samples, 0.04%) + + + +NKikimr::NMiniKQL::TBindTerminator::~TBindTerminator (216,255,301 samples, 0.02%) + + + +NKikimr::NDataShard::(anonymous namespace)::ToRawTypeValue (337,123,228 samples, 0.04%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (261,287,137 samples, 0.03%) + + + +NActors::TActivationContext::LoggerSettings (262,070,413 samples, 0.03%) + + + +std::__y1::__destroy_at[abi:v180000]<std::__y1::pair<unsigned long const, NYql::NDq::TDqComputeActorChannels::TOutputChannelState::TInFlightMessage>, 0> (382,853,727 samples, 0.04%) + + + +[[kernel.kallsyms]] (6,762,391,671 samples, 0.70%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (123,246,025 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::assign (124,097,803 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::ProcessOutputsImpl (212,119,685 samples, 0.02%) + + + +[[kernel.kallsyms]] (172,632,152 samples, 0.02%) + + + +NKikimr::NPrivate::TAggregatedCumulativeCounters::SetValues (81,605,845 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (165,063,956 samples, 0.02%) + + + +NThreading::NReadAsFilledPrivate::TReadBucket<NThreading::NReadAsFilledPrivate::TWriteBucket<251u, NThreading::NReadAsFilledPrivate::TEmpty, NThreading::NReadAsFilledPrivate::TEmptyAux>, NThreading::TReadAsFilledQueue<NActors::IEventHandle>::TContainer>::PopAux (126,471,208 samples, 0.01%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DoExecuteImpl (208,524,175 samples, 0.02%) + + + +NActors::TActivationContext::LoggerSettings (154,947,574 samples, 0.02%) + + + +[[kernel.kallsyms]] (171,908,642 samples, 0.02%) + + + +NActors::TActivationContext::GetCurrentEventTicksAsSeconds (6,001,157,429 samples, 0.62%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::THTSwapMailbox> (6,293,370,615 samples, 0.65%) + + + +google::protobuf::internal::ArenaStringPtr::Set (841,938,993 samples, 0.09%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (208,629,504 samples, 0.02%) + + + +NKikimr::NMiniKQL::MakeStringNotFilled (1,027,218,338 samples, 0.11%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (3,534,975,616 samples, 0.37%) + + + +NActors::TActorIdentity::Send< (125,290,263 samples, 0.01%) + + + +NKikimr::IsSystemColumn (133,516,398 samples, 0.01%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (544,593,614 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (1,193,611,911 samples, 0.12%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (84,316,981 samples, 0.01%) + + + +UdfFreeWithSize (687,916,701 samples, 0.07%) + + + +NActors::TActivationContext::Send< (252,136,192 samples, 0.03%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (106,273,929 samples, 0.01%) + + + +THashTable<std::__y1::pair<std::__y1::pair<unsigned char, unsigned int> const, unsigned int>, std::__y1::pair<unsigned char, unsigned int>, THash<std::__y1::pair<unsigned char, unsigned int> >, TSelect1st, TEqualTo<std::__y1::pair<unsigned char, unsigned int> >, std::__y1::allocator<std::__y1::pair<unsigned char, unsigned int> > >::insert_unique_noresize<std::__y1::pair<std::__y1::pair<unsigned char, unsigned int> const, unsigned int> > (111,790,442 samples, 0.01%) + + + +NYql::NDq::TDqDataSerializer::Deserialize (13,720,941,785 samples, 1.43%) + + + +[[kernel.kallsyms]] (348,697,884 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (81,738,050 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (120,676,206 samples, 0.01%) + + + +[[kernel.kallsyms]] (82,185,134 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (168,424,110 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (86,328,352 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (128,153,978 samples, 0.01%) + + + +NActors::TInputSessionTCP::ProcessEvents (198,145,279 samples, 0.02%) + + + +SSL_write (1,086,066,612 samples, 0.11%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackImpl<false, false, NKikimr::NMiniKQL::TPagedBuffer> (6,116,989,174 samples, 0.64%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (85,615,138 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (85,400,593 samples, 0.01%) + + + +THashMap<unsigned int, unsigned int, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::operator[]<unsigned int> (456,879,941 samples, 0.05%) + + + +[[kernel.kallsyms]] (1,133,319,065 samples, 0.12%) + + + +NKikimr::NTable::TDatabase::Select (96,519,568,631 samples, 10.03%) +NKikimr::NTabl.. + + +NKikimr::NKqp::TKqpExecuterBase<NKikimr::NKqp::(anonymous namespace)::TKqpDataExecuter, (110,544,678,432 samples, 11.48%) +NKikimr::NKqp::TK.. + + +nvidia_isr (127,472,478 samples, 0.01%) + + + +[[kernel.kallsyms]] (171,908,642 samples, 0.02%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::ForEachRow<NYql::NDq::TDqInputImpl<NYql::NDq::TDqAsyncInputBuffer, NYql::NDq::IDqAsyncInputBuffer>::Pop (257,625,358 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::CommitTransactionLog (167,923,282 samples, 0.02%) + + + +UdfFreeWithSize (88,110,309 samples, 0.01%) + + + +NKikimr::TBlackboard::RunStrategy (220,189,076 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (1,433,430,385 samples, 0.15%) + + + +tcmalloc::MallocExtension::SnapshotCurrent (288,322,772 samples, 0.03%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupProxyTimeStats::TBlobStorageGroupProxyTimeStats (108,465,908 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (86,907,510 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +TCMallocInternalNewArray (122,109,188 samples, 0.01%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::TReadAsFilledMailbox> (4,845,397,554 samples, 0.50%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (127,950,956 samples, 0.01%) + + + +syscall (16,977,879,752 samples, 1.76%) + + + +NKikimr::NKqp::TKqpLookupRows::ReplyResult (22,718,141,985 samples, 2.36%) +N.. + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (116,540,092 samples, 0.01%) + + + +HashBucketCountExt (125,131,499 samples, 0.01%) + + + +std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (344,725,149 samples, 0.04%) + + + +NActors::TStatsCollectingActor::TActivityStats::Set (143,390,036 samples, 0.01%) + + + +NActors::TInternalActorTypeGuard< (84,811,527 samples, 0.01%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::CheckRunStatus (9,424,872,062 samples, 0.98%) + + + +TRcBuf::TBackend::VisitRaw<TRcBuf::TBackend::TBackendHolder, TRcBuf::TBackend::Destroy<TRcBuf::TBackend::TBackendHolder> (370,076,089 samples, 0.04%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (133,119,671 samples, 0.01%) + + + +NActors::UnlockFromExecution<NActors::TMailboxTable::THTSwapMailbox> (448,628,254 samples, 0.05%) + + + +NActors::TGenericExecutorThread::Send< (147,851,292 samples, 0.02%) + + + +[[kernel.kallsyms]] (1,096,683,000 samples, 0.11%) + + + +[[kernel.kallsyms]] (1,747,447,476 samples, 0.18%) + + + +NActors::TBasicExecutorPool::ScheduleActivationEx (126,785,137 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (129,371,770 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (329,529,135 samples, 0.03%) + + + +NKikimr::SkipLabels (376,013,375 samples, 0.04%) + + + +NActors::TExecutorPoolBaseMailboxed::Register (581,532,838 samples, 0.06%) + + + +NKikimr::TBlobStorageGroupPutRequest::EncodeQuantum (252,139,604 samples, 0.03%) + + + +NActors::TBasicExecutorPool::GetReadyActivationCommon (6,952,894,351 samples, 0.72%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (88,555,462 samples, 0.01%) + + + +NKikimr::NTable::TPartWriter::WriteMainRow (169,494,191 samples, 0.02%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::Seek (10,998,118,576 samples, 1.14%) + + + +[[kernel.kallsyms]] (17,083,326,734 samples, 1.77%) + + + +NKikimr::NTabletFlatExecutor::TOpsCompact::Feed (216,000,048 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (4,564,544,100 samples, 0.47%) + + + +[[kernel.kallsyms]] (892,362,173 samples, 0.09%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (173,733,239 samples, 0.02%) + + + +google::protobuf::MessageLite::SerializeAsString (197,598,825 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (86,533,802 samples, 0.01%) + + + +[[kernel.kallsyms]] (2,752,967,732 samples, 0.29%) + + + +NActors::IActor::Send (82,185,134 samples, 0.01%) + + + +NActors::TExecutorThread::ThreadProc (18,917,047,828 samples, 1.96%) +N.. + + +[[kernel.kallsyms]] (151,580,583 samples, 0.02%) + + + +NKikimr::NTable::TTable::Select (3,122,138,751 samples, 0.32%) + + + +TCMallocInternalNewArray (165,212,484 samples, 0.02%) + + + +SetParallelStartTimestamps (296,680,083 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TryUnload (2,353,652,625 samples, 0.24%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (256,257,421 samples, 0.03%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (19,303,890,868 samples, 2.01%) +o.. + + +tcmalloc::tcmalloc_internal::CentralFreeList::InsertRange (1,436,871,330 samples, 0.15%) + + + +google::protobuf::internal::IsStructurallyValidUTF8 (7,388,087,259 samples, 0.77%) + + + +NKikimr::NDataShard::TDataShard::Handle (126,695,153,524 samples, 13.16%) +NKikimr::NDataShard.. + + +NYql::(anonymous namespace)::TContigousChunkOverBuf::~TContigousChunkOverBuf (382,853,727 samples, 0.04%) + + + +NKikimr::TEvDataShard::TEvRead::~TEvRead (794,540,576 samples, 0.08%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (119,298,523 samples, 0.01%) + + + +[[kernel.kallsyms]] (850,027,160 samples, 0.09%) + + + +[[kernel.kallsyms]] (124,533,476 samples, 0.01%) + + + +std::__y1::__shared_ptr_emplace<NKikimr::NMiniKQL::TPagedBuffer, std::__y1::allocator<NKikimr::NMiniKQL::TPagedBuffer> >::__on_zero_shared (382,853,727 samples, 0.04%) + + + +[[kernel.kallsyms]] (124,533,476 samples, 0.01%) + + + +NActors::TExecutorThreadCtx::WakeUp (301,204,087 samples, 0.03%) + + + +NHPTimer::GetSeconds (86,408,191 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::DeleteReadIterator (794,540,576 samples, 0.08%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (605,410,896 samples, 0.06%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpStreamLookupActor::GetAsyncInputData (94,748,340,604 samples, 9.84%) +NKikimr::NKqp:.. + + +NKikimr::NTable::NPage::TFlatIndex::TFlatIndex (379,853,913 samples, 0.04%) + + + +TCMallocInternalNewArray (340,535,153 samples, 0.04%) + + + +UdfAllocateWithSize (111,852,130 samples, 0.01%) + + + +_aesni_ctr32_ghash_6x (3,614,995,082 samples, 0.38%) + + + +NActors::TEventOutputChannel::FeedBuf (83,641,762 samples, 0.01%) + + + +NKikimr::TKeyDesc::TKeyDesc<TVector<NKikimr::NScheme::TTypeInfo, std::__y1::allocator<NKikimr::NScheme::TTypeInfo> >, TVector<NKikimr::TKeyDesc::TColumnOp, std::__y1::allocator<NKikimr::TKeyDesc::TColumnOp> > > (2,199,411,290 samples, 0.23%) + + + +[[kernel.kallsyms]] (416,482,480 samples, 0.04%) + + + +[[kernel.kallsyms]] (98,815,592 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (126,491,265 samples, 0.01%) + + + +NKikimr::TPutImpl::RunStrategy (129,287,687 samples, 0.01%) + + + +NActors::IActor::Registered (581,532,838 samples, 0.06%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +non-virtual thunk to NKikimr::NTabletFlatExecutor::TExecutor::Execute (125,478,900,356 samples, 13.03%) +non-virtual thunk t.. + + +NKikimr::NKqp::(anonymous namespace)::TKqpDataExecuter::ExecuteState (110,626,839,323 samples, 11.49%) +NKikimr::NKqp::(a.. + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::insert_unique<std::__y1::pair<unsigned int const, unsigned int> > (7,820,516,427 samples, 0.81%) + + + +[[kernel.kallsyms]] (3,999,822,839 samples, 0.42%) + + + +NActors::TInputSessionTCP::ReadMore (872,059,241 samples, 0.09%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::StateWork (3,206,726,073 samples, 0.33%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (1,583,358,654 samples, 0.16%) + + + +NActors::THarmonizer::Harmonize (255,055,660 samples, 0.03%) + + + +NActors::TBasicExecutorPool::GetReadyActivationCommon (25,956,928,655 samples, 2.70%) +NA.. + + +[[kernel.kallsyms]] (130,232,041 samples, 0.01%) + + + +[[kernel.kallsyms]] (7,828,152,830 samples, 0.81%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (161,752,310 samples, 0.02%) + + + +NKikimr::NDataShard::TReadIteratorState::~TReadIteratorState (794,540,576 samples, 0.08%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::BuildMeta (454,176,436 samples, 0.05%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (5,547,703,541 samples, 0.58%) + + + +[[kernel.kallsyms]] (409,147,347 samples, 0.04%) + + + +Ydb::Value::~Value (42,178,025,739 samples, 4.38%) +Ydb::.. + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::ReportStats (643,046,900 samples, 0.07%) + + + +NKikimr::NTable::TDatabaseImpl::Get (82,427,917 samples, 0.01%) + + + +NKikimr::NTable::TRowState::Set (1,666,604,935 samples, 0.17%) + + + +NKikimr::TBlobStorageGroupProxy::StateCommon (82,384,112 samples, 0.01%) + + + +[[kernel.kallsyms]] (84,580,412 samples, 0.01%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (837,671,381 samples, 0.09%) + + + +google::protobuf::MessageLite::AppendPartialToString (169,469,509 samples, 0.02%) + + + +[[kernel.kallsyms]] (125,763,990 samples, 0.01%) + + + +[[kernel.kallsyms]] (411,976,363 samples, 0.04%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NDataShard::TCheckReadUnit::Execute (4,285,253,787 samples, 0.45%) + + + +NKikimr::ComparePrefixBorders (1,292,848,799 samples, 0.13%) + + + +[[kernel.kallsyms]] (125,763,990 samples, 0.01%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::TComputationGraph::GetTerminator (199,301,785 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (418,909,658 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ListTooLong (208,497,717 samples, 0.02%) + + + +NKikimr::NDataShard::(anonymous namespace)::TShortTableInfo::TShortTableInfo (286,842,703 samples, 0.03%) + + + +nf_conntrack_tcp_packet (136,081,028 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (82,240,160 samples, 0.01%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +NKikimr::NTabletFlatExecutor::TLogicRedo::CommitROTransaction (85,339,368 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (163,763,130 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (208,497,717 samples, 0.02%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackData<false, unsigned int, NKikimr::NMiniKQL::TPagedBuffer> (126,667,809 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (128,227,904 samples, 0.01%) + + + +[[kernel.kallsyms]] (149,499,141 samples, 0.02%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::IsFull (132,335,000 samples, 0.01%) + + + +[[kernel.kallsyms]] (351,938,243 samples, 0.04%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::DestroyProtos (90,524,222,769 samples, 9.40%) +google::proto.. + + +NKikimr::NTable::TFeed::Process (216,000,048 samples, 0.02%) + + + +[[hid]] (332,347,330 samples, 0.03%) + + + +NActors::TInputSessionTCP::WorkingState (1,203,708,263 samples, 0.13%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::Lookup (6,200,960,381 samples, 0.64%) + + + +__memcmp_avx2_movbe (2,636,301,587 samples, 0.27%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::ExportValueToProtoImpl (89,327,513,014 samples, 9.28%) +NKikimr::NMin.. + + +NKikimr::NMiniKQL::(anonymous namespace)::PackData<false, unsigned int, NKikimr::NMiniKQL::TPagedBuffer> (2,739,468,329 samples, 0.28%) + + + +NActors::TGenericExecutorThread::Send< (214,968,019 samples, 0.02%) + + + +NKikimr::NTable::TPartIter::Apply (331,426,180 samples, 0.03%) + + + +TCMallocInternalNewArray (86,045,215 samples, 0.01%) + + + +google::protobuf::internal::ArenaStringPtr::Destroy (22,232,704,060 samples, 2.31%) +g.. + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (3,884,930,197 samples, 0.40%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::DoInsert (2,703,719,310 samples, 0.28%) + + + +NActors::TGenericExecutorThread::RegisterActor< (626,933,999 samples, 0.07%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (126,044,277 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::GenerateTraffic (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (11,702,838,552 samples, 1.22%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (432,078,589 samples, 0.04%) + + + +std::__y1::vector<unsigned int, NPrivate::TStackBasedAllocator<unsigned int, 16ul, true, std::__y1::allocator<unsigned int> > >::__insert_with_size[abi:v180000]<unsigned int const*, unsigned int const*> (320,621,271 samples, 0.03%) + + + +NActors::TActivationContextHolder::operator* (127,543,080 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,126,038,470 samples, 0.12%) + + + +[[kernel.kallsyms]] (18,064,903,949 samples, 1.88%) +[.. + + +NActors::TExecutorThread::ThreadProc (9,790,139,722 samples, 1.02%) + + + +NKikimr::NPrivate::TAggregatedCumulativeCounters::RecalcAll (121,033,996 samples, 0.01%) + + + +[[kernel.kallsyms]] (13,996,716,053 samples, 1.45%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (1,162,080,699 samples, 0.12%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +TCMallocInternalNewArray (209,819,342 samples, 0.02%) + + + +NKikimr::NDataShard::TSysLocks::HasCurrentWriteLock (249,983,138 samples, 0.03%) + + + +NKikimr::TBlobStorageGroupPutRequest::Action (457,626,617 samples, 0.05%) + + + +Ydb::ResultSet::Clear (91,898,409 samples, 0.01%) + + + +__nanosleep (228,404,144 samples, 0.02%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Next (1,820,756,181 samples, 0.19%) + + + +__memcmp_avx2_movbe (536,444,151 samples, 0.06%) + + + +NYql::NDq::TDqInputImpl<NYql::NDq::TDqInputChannelImpl, NYql::NDq::IDqInputChannel>::Pop (126,044,277 samples, 0.01%) + + + +__memset_avx2_unaligned_erms (413,293,420 samples, 0.04%) + + + +NActors::TBasicExecutorPool::GetReadyActivationCommon (206,519,201 samples, 0.02%) + + + +NKikimr::TTcMallocMonitor::UpdateCounters (385,470,792 samples, 0.04%) + + + +TBasicString<char, std::__y1::char_traits<char> >::Clone (86,533,802 samples, 0.01%) + + + +NActors::TActivationContextHolder::operator* (201,354,378 samples, 0.02%) + + + +NKikimr::TCell::AsValue<unsigned long, unsigned long> (119,616,129 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::DoExecute (125,478,900,356 samples, 13.03%) +NKikimr::NTabletFla.. + + +TCMallocInternalNewArray (383,915,832 samples, 0.04%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (331,188,616 samples, 0.03%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::CheckRequestAndInit (4,285,253,787 samples, 0.45%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<__int128> (594,627,178 samples, 0.06%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::TReadAsFilledMailbox> (3,445,964,514 samples, 0.36%) + + + +NKikimr::NKqp::TKqpLookupRows::FillReadRequest (1,050,622,920 samples, 0.11%) + + + +NKikimr::ComparePrefixBorders (162,781,620 samples, 0.02%) + + + +NKikimr::NKqp::(anonymous namespace)::TKqpStreamLookupActor::ProcessInputRows (69,820,751,394 samples, 7.25%) +NKikimr::N.. + + +[[kernel.kallsyms]] (15,935,503,951 samples, 1.66%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (458,601,172 samples, 0.05%) + + + +[[kernel.kallsyms]] (3,127,174,746 samples, 0.32%) + + + +NYql::NDq::TDqInputChannel::Pop (287,441,170 samples, 0.03%) + + + +[[kernel.kallsyms]] (84,406,825 samples, 0.01%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (5,104,299,058 samples, 0.53%) + + + +NYql::NDq::TDqComputeActorMetrics::ReportEvent (213,571,947 samples, 0.02%) + + + +[ydbd] (127,142,681 samples, 0.01%) + + + +NActors::TActorContext::Send< (106,273,929 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::Write (85,550,519 samples, 0.01%) + + + +NKikimr::NDataShard::TSysLocks::HasWriteLocks (211,051,397 samples, 0.02%) + + + +NKikimr::TTablet::Handle (675,629,548 samples, 0.07%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +[[kernel.kallsyms]] (206,510,236 samples, 0.02%) + + + +bwrite_conv (248,363,091 samples, 0.03%) + + + +NActors::TInterconnectSessionTCP::IssueRam (121,924,875 samples, 0.01%) + + + +NActors::TInterconnectProxyTCP::ForwardSessionEventToSession (298,909,034 samples, 0.03%) + + + +NActors::TBasicExecutorPool::GetReadyActivationCommon (6,201,327,843 samples, 0.64%) + + + +[[kernel.kallsyms]] (3,042,189,686 samples, 0.32%) + + + +__memcmp_avx2_movbe (3,048,345,027 samples, 0.32%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (86,127,647 samples, 0.01%) + + + +NKikimr::TAlignedPagePoolImpl<NKikimr::TSystemMmap>::~TAlignedPagePoolImpl (127,807,050 samples, 0.01%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::ForEachRow<NYql::NDq::TDqInputImpl<NYql::NDq::TDqInputChannelImpl, NYql::NDq::IDqInputChannel>::Pop (126,044,277 samples, 0.01%) + + + +NActors::TActivationContextHolder::operator* (124,628,403 samples, 0.01%) + + + +[[kernel.kallsyms]] (415,369,570 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (88,555,462 samples, 0.01%) + + + +NKikimr::CompareTypedCells (126,810,772 samples, 0.01%) + + + +[[kernel.kallsyms]] (348,697,884 samples, 0.04%) + + + +NKikimr::NTable::TPartIter::~TPartIter (828,859,472 samples, 0.09%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ExecuteTransaction (921,942,876 samples, 0.10%) + + + +NKikimr::SendPutToGroup (111,583,922 samples, 0.01%) + + + +NActors::TActorIdentity::Send< (82,185,134 samples, 0.01%) + + + +bio_read_intern (1,325,762,882 samples, 0.14%) + + + +NKikimr::NPrivate::TAggregatedSimpleCounters::RecalcAll (87,116,153 samples, 0.01%) + + + +[[vdso]] (11,839,342,024 samples, 1.23%) + + + +NKikimr::NDataShard::(anonymous namespace)::TCellBlockBuilder::AddRow (6,187,048,192 samples, 0.64%) + + + +Ydb::Value::ByteSizeLong (53,261,022,196 samples, 5.53%) +Ydb::Va.. + + +[[kernel.kallsyms]] (3,999,822,839 samples, 0.42%) + + + +NKikimr::NKqp::(anonymous namespace)::GetRangePartitioning (66,075,947,614 samples, 6.86%) +NKikimr::.. + + +NKikimr::TTabletReqWriteLog::Bootstrap (369,022,458 samples, 0.04%) + + + +[[kernel.kallsyms]] (288,157,808 samples, 0.03%) + + + +NActors::TGenericExecutorThread::GetCurrentStats (1,380,524,233 samples, 0.14%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::UnpackBatch (287,441,170 samples, 0.03%) + + + +[[kernel.kallsyms]] (149,499,141 samples, 0.02%) + + + +NKikimr::TPutImpl::RunStrategy (220,189,076 samples, 0.02%) + + + +NYql::NDq::TDqTaskRunner::Run (1,649,398,232 samples, 0.17%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::Lookup (203,993,874 samples, 0.02%) + + + +NKikimr::NKqp::TKqpStreamLookupWorker::GetKeyColumnTypes (165,414,116 samples, 0.02%) + + + +[[kernel.kallsyms]] (218,219,037 samples, 0.02%) + + + +TCMallocInternalNewArray (806,526,582 samples, 0.08%) + + + +NKikimr::TPutImpl::RunStrategies (220,189,076 samples, 0.02%) + + + +NKikimr::NTable::TPartGroupFlatIndexIter::GetEndRowId (120,993,465 samples, 0.01%) + + + +[[kernel.kallsyms]] (415,369,570 samples, 0.04%) + + + +NActors::TGenericExecutorThread::Execute<NActors::TMailboxTable::TReadAsFilledMailbox> (135,181,523,185 samples, 14.04%) +NActors::TGenericExec.. + + +NYql::NDq::TDqComputeActorChannels::OutCh (167,039,238 samples, 0.02%) + + + +NKikimr::NTable::TPartIter::SkipToRowVersion (119,147,140 samples, 0.01%) + + + +NKikimr::NDataShard::TExecuteKqpDataTxUnit::AddLocksToResult (841,220,649 samples, 0.09%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (2,045,767,247 samples, 0.21%) + + + +NKikimr::NMiniKQL::TPagedBuffer::AppendPage (88,175,277 samples, 0.01%) + + + +THashTable<TBasicString<char, std::__y1::char_traits<char> >, TBasicString<char, std::__y1::char_traits<char> >, THash<TBasicString<char, std::__y1::char_traits<char> > >, TIdentity, TEqualTo<TBasicString<char, std::__y1::char_traits<char> > >, std::__y1::allocator<TBasicString<char, std::__y1::char_traits<char> > > >::find<TBasicString<char, std::__y1::char_traits<char> > > (121,064,558 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TCommitManager::SendCommitEv (165,542,720 samples, 0.02%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (308,808,427 samples, 0.03%) + + + +NActors::TActorSystem::Send< (128,405,022 samples, 0.01%) + + + +google::protobuf::internal::WireFormatLite::VerifyUtf8String (7,634,952,176 samples, 0.79%) + + + +__memset_avx2_unaligned_erms (192,225,128 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (547,844,914 samples, 0.06%) + + + +NYql::NDq::TEvDqCompute::TEvState::~TEvState (85,519,133 samples, 0.01%) + + + +Ydb::ResultSet::MergeFrom (85,957,878 samples, 0.01%) + + + +Ydb::ResultSet::_InternalSerialize (59,334,184,819 samples, 6.16%) +Ydb::Res.. + + +NActors::TStatsCollectingActor::TExecutorPoolCounters::Set (143,390,036 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (334,932,906 samples, 0.03%) + + + +NKikimr::NMiniKQL::NDetails::PackDecimal<NKikimr::NMiniKQL::TPagedBuffer> (504,593,769 samples, 0.05%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (167,908,983 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (1,269,339,029 samples, 0.13%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (23,332,072,424 samples, 2.42%) +NA.. + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (122,500,139 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Span::FreelistPopBatchSized< (2,702,263,812 samples, 0.28%) + + + +NKikimr::GetServiceCounters (376,013,375 samples, 0.04%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned long> (175,872,909 samples, 0.02%) + + + +NKikimr::NTable::TTable::Select (95,316,914,248 samples, 9.90%) +NKikimr::NTabl.. + + +tcmalloc::tcmalloc_internal::Span::FreelistPopBatchSized< (122,155,068 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (84,092,828 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (87,228,770 samples, 0.01%) + + + +std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> >::__push_back_slow_path<NKikimr::TOwnedTableRange> (169,146,774 samples, 0.02%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (18,917,047,828 samples, 1.96%) +N.. + + +NActors::TActivationContext::LoggerSettings (250,880,235 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (91,548,192 samples, 0.01%) + + + +nft_do_chain_ipv4 (84,687,669 samples, 0.01%) + + + +[[kernel.kallsyms]] (181,880,917 samples, 0.02%) + + + +NKikimr::CreateBlobStorageGroupPutRequest (252,359,255 samples, 0.03%) + + + +NKikimr::NTable::TPartWriter::WriteMainRow (216,000,048 samples, 0.02%) + + + +[[kernel.kallsyms]] (415,369,570 samples, 0.04%) + + + +NActors::TInterconnectSessionTCP::WriteData (85,550,519 samples, 0.01%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::FindOrSplit (463,178,123 samples, 0.05%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackString (1,965,453,119 samples, 0.20%) + + + +Ydb::Value::~Value (82,002,112 samples, 0.01%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (339,753,178 samples, 0.04%) + + + +[[kernel.kallsyms]] (211,345,314 samples, 0.02%) + + + +NYql::NDq::TDqInputChannel::DeserializeAllData (14,050,181,435 samples, 1.46%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (82,981,015 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,259,427,497 samples, 0.13%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackBlob<NKikimr::NMiniKQL::TPagedBuffer> (172,034,079 samples, 0.02%) + + + +[[kernel.kallsyms]] (15,557,954,433 samples, 1.62%) + + + +Ydb::ResultSet::MergeFrom (308,808,427 samples, 0.03%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::PackImpl<false, false, NKikimr::NMiniKQL::TPagedBuffer> (16,253,943,545 samples, 1.69%) + + + +NKikimr::NKqp::TKqpComputeActor::CheckRunStatus (505,915,369 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::StackTraceTable::AddTrace (288,322,772 samples, 0.03%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (754,528,780 samples, 0.08%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::ProcessIoStats (417,741,836 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::ReleaseToSpans (764,128,345 samples, 0.08%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned int> (127,991,357 samples, 0.01%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned int> (337,839,560 samples, 0.04%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::__unordered_map_hasher<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::hash<unsigned long>, std::__y1::equal_to<unsigned long>, true>, std::__y1::__unordered_map_equal<unsigned long, std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > >, std::__y1::equal_to<unsigned long>, std::__y1::hash<unsigned long>, true>, std::__y1::allocator<std::__y1::__hash_value_type<unsigned long, std::__y1::vector<NKikimr::TOwnedTableRange, std::__y1::allocator<NKikimr::TOwnedTableRange> > > > >::__emplace_unique_key_args<unsigned long, std::__y1::piecewise_construct_t const&, std::__y1::tuple<unsigned long const&>, std::__y1::tuple<> > (250,916,879 samples, 0.03%) + + + +[[kernel.kallsyms]] (348,697,884 samples, 0.04%) + + + +NKikimr::TAllocationAnalyzer::Prepare (97,148,020 samples, 0.01%) + + + +nvidia_isr (84,406,825 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,000,927,591 samples, 0.10%) + + + +[[kernel.kallsyms]] (1,226,796,088 samples, 0.13%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (157,819,464 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (119,298,523 samples, 0.01%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (2,533,947,510 samples, 0.26%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::HandleRequest<TAutoPtr<NActors::TEventHandle<NKikimr::TEvBlobStorage::TEvVPut>, TDelete>, NKikimr::TEvBlobStorage::TEvVPut, NKikimr::TEvBlobStorage::TEvVPutResult> (590,750,324 samples, 0.06%) + + + +std::__y1::vector<NYql::NUdf::TUnboxedValue, NKikimr::NMiniKQL::TMKQLAllocator<NYql::NUdf::TUnboxedValue, (4,189,744,419 samples, 0.44%) + + + +clock_gettime@@GLIBC_2.17 (85,538,324 samples, 0.01%) + + + +NKikimr::NMiniKQL::MakeStringNotFilled (86,127,647 samples, 0.01%) + + + +[[kernel.kallsyms]] (169,863,817 samples, 0.02%) + + + +std::__y1::deque<NKikimr::NTable::TPartIter, std::__y1::allocator<NKikimr::NTable::TPartIter> >::emplace_back<NKikimr::NTable::TPart const*&, TArrayRef<unsigned int const>&, TIntrusiveConstPtr<NKikimr::NTable::TKeyCellDefaults, TDefaultIntrusivePtrOps<NKikimr::NTable::TKeyCellDefaults> > const&, NKikimr::NTable::IPages*&> (30,832,019,287 samples, 3.20%) +std.. + + +MicroSeconds (1,218,174,468 samples, 0.13%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::Handle (959,230,461 samples, 0.10%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputMapConsumer::IsFull (194,923,542 samples, 0.02%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (252,136,192 samples, 0.03%) + + + +std::__y1::__shared_ptr_emplace<NKikimr::NMiniKQL::TPagedBuffer, std::__y1::allocator<NKikimr::NMiniKQL::TPagedBuffer> >::__on_zero_shared (366,001,159 samples, 0.04%) + + + +syscall (98,815,592 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::StateWait (648,382,315 samples, 0.07%) + + + +__memmove_avx_unaligned_erms (275,171,362 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (121,163,066 samples, 0.01%) + + + +NMonitoring::TDynamicCounters::EnumerateSubgroups (288,049,737 samples, 0.03%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (341,501,618 samples, 0.04%) + + + +[[kernel.kallsyms]] (169,863,817 samples, 0.02%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::Finish (2,324,888,505 samples, 0.24%) + + + +[[kernel.kallsyms]] (392,946,265 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (4,902,571,694 samples, 0.51%) + + + +THashMap<unsigned int, NActors::TSharedData, THash<unsigned int>, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::operator[]<unsigned int> (809,849,230 samples, 0.08%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (125,290,263 samples, 0.01%) + + + +google::protobuf::Message::MaybeComputeUnknownFieldsSize (243,247,184 samples, 0.03%) + + + +NKikimrTabletBase::TTabletLogMetadata::_InternalSerialize (169,469,509 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (245,438,185 samples, 0.03%) + + + +NKikimr::NTable::NPage::TDataPageWriter::Put (89,452,980 samples, 0.01%) + + + +NKikimr::NMiniKQL::TDirectArrayHolderInplace::GetElement (1,808,316,034 samples, 0.19%) + + + +[[kernel.kallsyms]] (1,126,038,470 samples, 0.12%) + + + +MallocExtension_Internal_SnapshotCurrent (288,322,772 samples, 0.03%) + + + +NKikimr::TKeyDesc::~TKeyDesc (1,508,741,549 samples, 0.16%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::AttachLeaseCommit (166,906,211 samples, 0.02%) + + + +NYdbGrpc::TGRpcRequestImpl<Ydb::Query::ExecuteQueryRequest, Ydb::Query::ExecuteQueryResponsePart, NKikimr::NGRpcService::TGRpcYdbQueryService, google::protobuf::TextFormat::Printer, google::protobuf::TextFormat::Printer>::WriteByteDataOk (8,263,057,916 samples, 0.86%) + + + +NKikimr::NKqp::TKqpComputeActor::StateFunc (211,975,230 samples, 0.02%) + + + +[[kernel.kallsyms]] (809,991,734 samples, 0.08%) + + + +[[kernel.kallsyms]] (1,013,177,486 samples, 0.11%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +NKikimr::NDataShard::TDependencyTracker::TMvccDependencyTrackingLogic::AddOperation (126,214,859 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::Handle (648,382,315 samples, 0.07%) + + + +NKikimr::TEvBlobStorage::TEvVPut::TEvVPut (109,825,268 samples, 0.01%) + + + +NKikimr::NMiniKQL::MKQLAllocWithSize (479,443,142 samples, 0.05%) + + + +[[kernel.kallsyms]] (812,978,578 samples, 0.08%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (6,028,535,602 samples, 0.63%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::ResetTouchesAndToLoad (2,395,611,955 samples, 0.25%) + + + +[[kernel.kallsyms]] (86,638,907 samples, 0.01%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::StateFuncWrapper (1,527,242,441 samples, 0.16%) + + + +TMemoryPool::DoClear (462,767,657 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (209,597,182 samples, 0.02%) + + + +UdfAllocateWithSize (129,347,614 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +rm_isr (84,406,825 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::Bootstrap (875,116,596 samples, 0.09%) + + + +NYql::NDq::TDqTaskRunner::BindAllocator (456,198,888 samples, 0.05%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::Finish (1,838,077,772 samples, 0.19%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (324,269,913 samples, 0.03%) + + + +NKikimr::NTabletFlatExecutor::TSharedPageCache::Handle (2,132,212,865 samples, 0.22%) + + + +NActors::TActivationContextHolder::operator= (202,385,653 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (3,431,512,644 samples, 0.36%) + + + +[[vdso]] (206,416,194 samples, 0.02%) + + + +grpc_core::DoSslWrite (1,122,831,263 samples, 0.12%) + + + +NYql::NDq::TDqComputeActorChannels::HasFreeMemoryInChannel (85,185,967 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::SendPeriodicTableStats (197,090,863 samples, 0.02%) + + + +__memmove_avx_unaligned_erms (1,829,691,635 samples, 0.19%) + + + +nft_do_chain_ipv4 (167,005,411 samples, 0.02%) + + + +[[kernel.kallsyms]] (211,345,314 samples, 0.02%) + + + +NKikimr::NTable::NPage::TDataPage::Set (214,273,322 samples, 0.02%) + + + +_nv033868rm (84,406,825 samples, 0.01%) + + + +std::__y1::__tree_remove[abi:v180000]<std::__y1::__tree_node_base<void*>*> (183,575,806 samples, 0.02%) + + + +NKikimr::NMiniKQL::NDetails::UnpackInteger<unsigned long> (169,444,801 samples, 0.02%) + + + +NActors::TActivationContext::Send< (147,851,292 samples, 0.02%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (82,185,134 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::FreeSmallSlow (124,725,641 samples, 0.01%) + + + +NKikimr::NMiniKQL::TUnboxedValueBatch::emplace_back<NYql::NUdf::TUnboxedValue> (117,622,811 samples, 0.01%) + + + +NKikimr::NDataShard::TDataShard::SendWithConfirmedReadOnlyLease (165,542,720 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (166,831,505 samples, 0.02%) + + + +std::__y1::vector<NKikimr::TCell, std::__y1::allocator<NKikimr::TCell> >::__append_uninitialized (168,296,790 samples, 0.02%) + + + +std::__y1::__hash_table<std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::__unordered_map_hasher<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::hash<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::equal_to<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, true>, std::__y1::__unordered_map_equal<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::equal_to<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, std::__y1::hash<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > >, true>, std::__y1::allocator<std::__y1::__hash_value_type<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> >, std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > > > >::find<std::__y1::basic_string<char, std::__y1::char_traits<char>, std::__y1::allocator<char> > > (9,772,142,311 samples, 1.02%) + + + +grpc_call_start_batch (8,176,005,700 samples, 0.85%) + + + +std::__y1::__shared_ptr_emplace<NKikimr::NMiniKQL::TPagedBuffer, std::__y1::allocator<NKikimr::NMiniKQL::TPagedBuffer> >::__on_zero_shared (370,076,089 samples, 0.04%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::UpdateCounters (960,929,495 samples, 0.10%) + + + +NKikimr::NDataShard::TLockLocker::RemoveOneLock (841,220,649 samples, 0.09%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (11,637,327,469 samples, 1.21%) + + + +NYql::NDq::(anonymous namespace)::TDqOutputChannel<false>::Pop (1,838,077,772 samples, 0.19%) + + + +NKikimr::NMiniKQL::MakeStringNotFilled (747,974,208 samples, 0.08%) + + + +NKikimr::NBsQueue::TVDiskBackpressureClientActor::StateFunc (1,527,237,535 samples, 0.16%) + + + +[[vdso]] (24,597,803,581 samples, 2.55%) +[[.. + + +NKikimr::NMemory::TMemoryTrackerActor::UpdateDynamicCounters (376,013,375 samples, 0.04%) + + + +start_thread (907,346,793,356 samples, 94.24%) +start_thread + + +NKikimr::NPrivate::TAggregatedHistogramCounters::SetValue (290,994,841 samples, 0.03%) + + + +[[kernel.kallsyms]] (212,300,330 samples, 0.02%) + + + +[[kernel.kallsyms]] (83,970,478 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (303,174,728 samples, 0.03%) + + + +NKikimr::NTable::NPage::TDataPageWriter::Add (216,000,048 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (168,129,971 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (370,076,089 samples, 0.04%) + + + +BIO_write (248,363,091 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (128,227,904 samples, 0.01%) + + + +NKikimr::TBlobStorageGroupPutRequest::ResumeBootstrap (791,149,554 samples, 0.08%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::~TReadOperation (2,048,507,637 samples, 0.21%) + + + +[[kernel.kallsyms]] (83,480,588 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::HugeCache::Release (206,510,236 samples, 0.02%) + + + +flush_write_staging_buffer (84,951,095 samples, 0.01%) + + + +non-virtual thunk to NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::GetInputChannelFreeSpace (858,729,206 samples, 0.09%) + + + +NWilson::TSpan::~TSpan (460,666,549 samples, 0.05%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::assign (500,096,813 samples, 0.05%) + + + +NActors::TGenericExecutorThread::ProcessExecutorPool (9,762,369,979 samples, 1.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::AddOutOfLineHelper (287,053,342 samples, 0.03%) + + + +NActors::TActorSystem::GenericSend<&NActors::IExecutorPool::Send> (553,955,612 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::invoke_delete_hooks_and_free<&tcmalloc::tcmalloc_internal::FreeSmallSlow, (740,649,164 samples, 0.08%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (6,952,906,582 samples, 0.72%) + + + +google::protobuf::MessageLite::AppendPartialToString (116,736,831,732 samples, 12.13%) +google::protobuf::.. + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NActors::TInterconnectSessionTCP::HandleRam (1,443,563,208 samples, 0.15%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (661,501,360 samples, 0.07%) + + + +[[kernel.kallsyms]] (292,210,729 samples, 0.03%) + + + +LoadRecordCacheState (883,381,442 samples, 0.09%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (131,083,875 samples, 0.01%) + + + +[[kernel.kallsyms]] (130,232,041 samples, 0.01%) + + + +NKikimr::NMiniKQL::TValuePackerTransport<false>::BuildMeta (452,879,727 samples, 0.05%) + + + +[[kernel.kallsyms]] (17,732,924,417 samples, 1.84%) +[.. + + +NKikimr::NMiniKQL::TBindTerminator::TBindTerminator (132,760,959 samples, 0.01%) + + + +NKikimr::NTable::TRowState::TRowState (289,957,673 samples, 0.03%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NActors::TGenericExecutorThread::Send< (432,078,589 samples, 0.04%) + + + +__memmove_avx_unaligned_erms (206,457,723 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorChannels::CanSendChannelData (2,583,023,350 samples, 0.27%) + + + +_nv033868rm (86,001,079 samples, 0.01%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (118,052,308 samples, 0.01%) + + + +[[kernel.kallsyms]] (892,362,173 samples, 0.09%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (1,211,559,295 samples, 0.13%) + + + +NKikimr::NDataShard::TDataShard::TReadOperation::PrepareValidationInfo (3,998,411,084 samples, 0.42%) + + + +NKikimr::NDataShard::TReadUnit::Execute (110,896,679,262 samples, 11.52%) +NKikimr::NDataSha.. + + +[[kernel.kallsyms]] (98,815,592 samples, 0.01%) + + + +NYql::NDq::TDqTaskRunner::FetchAndDispatch (83,929,355 samples, 0.01%) + + + +NActors::IActor::Send (252,136,192 samples, 0.03%) + + + +[[kernel.kallsyms]] (375,638,040 samples, 0.04%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (220,147,211 samples, 0.02%) + + + +__memcmp_avx2_movbe (157,688,538 samples, 0.02%) + + + +NYql::NDq::TDqComputeActorBase<NKikimr::NKqp::TKqpComputeActor, NYql::NDq::TComputeActorAsyncInputHelperSync>::TOutputChannelInfo::DrainChannel (1,838,077,772 samples, 0.19%) + + + +NKikimr::NBsQueue::TBlobStorageQueue::TItem::TItem<NKikimr::TEvBlobStorage::TEvVPut> (210,278,040 samples, 0.02%) + + + +[[kernel.kallsyms]] (84,580,412 samples, 0.01%) + + + +[ydbd] (592,797,338 samples, 0.06%) + + + +[[kernel.kallsyms]] (284,142,554 samples, 0.03%) + + + +grpc::internal::CallOpSet<grpc::internal::CallOpSendInitialMetadata, grpc::internal::CallOpSendMessage, grpc::internal::CallOpServerSendStatus, grpc::internal::CallNoOp<4>, grpc::internal::CallNoOp<5>, grpc::internal::CallNoOp<6> >::ContinueFillOpsAfterInterception (8,176,005,700 samples, 0.85%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (208,497,717 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (3,533,644,347 samples, 0.37%) + + + +[[kernel.kallsyms]] (1,126,038,470 samples, 0.12%) + + + +_nv041477rm (84,406,825 samples, 0.01%) + + + +NKikimr::NDataShard::TTableLocks::AddPointLock (2,958,495,362 samples, 0.31%) + + + +NYql::NDq::TDqSyncComputeActorBase<NKikimr::NKqp::TKqpComputeActor>::DrainOutputChannel (8,018,815,665 samples, 0.83%) + + + +NActors::TExecutorThreadCtx::WakeUp (98,815,592 samples, 0.01%) + + + +NKikimr::NCache::TSwitchableCache<NKikimr::NTabletFlatExecutor::TSharedPageCache::TPage, NKikimr::NTabletFlatExecutor::TSharedPageCache::TCompositeCachePageTraits>::TCacheHolder::Touch (208,137,561 samples, 0.02%) + + + +tcp_flush (780,214,693 samples, 0.08%) + + + +__GI___readv (461,271,316 samples, 0.05%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::FetchFromCentralCache (85,725,759 samples, 0.01%) + + + +Ydb::ResultSet::~ResultSet (82,002,112 samples, 0.01%) + + + +[[kernel.kallsyms]] (13,621,833,045 samples, 1.41%) + + + +[[kernel.kallsyms]] (2,049,546,359 samples, 0.21%) + + + +NKikimr::TTabletCountersBase::MakeDiffForAggr (544,443,200 samples, 0.06%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Turn (1,286,922,444 samples, 0.13%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::Read (105,514,549,760 samples, 10.96%) +NKikimr::NDataSh.. + + +tcmalloc::tcmalloc_internal::ThreadCache::ReleaseToCentralCache (339,753,178 samples, 0.04%) + + + +TCMallocInternalNewArray (89,671,159 samples, 0.01%) + + + +NKikimr::NTable::TPartIter::TPartIter (30,198,896,572 samples, 3.14%) +NKi.. + + +NKikimr::NMiniKQL::PgReleaseThreadContext (212,259,648 samples, 0.02%) + + + +NKikimr::NTable::TPartScheme::MakePinout (28,385,533,001 samples, 2.95%) +NK.. + + +NActors::TActorSystem::Send (128,405,022 samples, 0.01%) + + + +std::__y1::__murmur2_or_cityhash<unsigned long, 64ul>::operator (173,060,835 samples, 0.02%) + + + +[[kernel.kallsyms]] (16,559,647,400 samples, 1.72%) + + + +NKikimr::NDataShard::TBuildAndWaitDependenciesUnit::BuildDependencies (126,214,859 samples, 0.01%) + + + +NKikimr::NKqp::TKqpReadActor::GetAsyncInputData (482,692,841 samples, 0.05%) + + + +[[kernel.kallsyms]] (83,715,695 samples, 0.01%) + + + +[[kernel.kallsyms]] (14,926,739,188 samples, 1.55%) + + + +std::__y1::__variant_detail::__visitation::__base::__dispatcher<0ul>::__dispatch[abi:v180000]<std::__y1::__variant_detail::__dtor<std::__y1::__variant_detail::__traits<std::__y1::unique_ptr<NKikimr::TEvBlobStorage::TEvVPut, std::__y1::default_delete<NKikimr::TEvBlobStorage::TEvVPut> >, std::__y1::unique_ptr<NKikimr::TEvBlobStorage::TEvVMultiPut, std::__y1::default_delete<NKikimr::TEvBlobStorage::TEvVMultiPut> > >, (83,086,418 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (207,979,673 samples, 0.02%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (121,426,817 samples, 0.01%) + + + +google::protobuf::Arena::CreateMaybeMessage<Ydb::Value> (564,103,983 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::Span::FreelistPopBatchSized< (2,834,039,257 samples, 0.29%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::DoExecute (1,216,249,879 samples, 0.13%) + + + +std::__y1::vector<NKikimr::TCell, NPrivate::TStackBasedAllocator<NKikimr::TCell, 16ul, true, std::__y1::allocator<NKikimr::TCell> > >::reserve (287,554,444 samples, 0.03%) + + + +google::protobuf::internal::WireFormatLite::InternalWriteMessage (501,583,747 samples, 0.05%) + + + +NKikimr::NKqp::TKqpProtoBuilder::BuildYdbResultSet (110,104,434,340 samples, 11.44%) +NKikimr::NKqp::TK.. + + +NKikimr::NKqp::TKqpReadActor::PackCells (360,490,286 samples, 0.04%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TryLoad (203,993,874 samples, 0.02%) + + + +[[kernel.kallsyms]] (16,977,879,752 samples, 1.76%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::Execute (1,216,249,879 samples, 0.13%) + + + +NActors::TMailboxTable::GenericSendTo<&NActors::IExecutorPool::ScheduleActivation> (485,258,807 samples, 0.05%) + + + +UdfAllocateWithSize (210,113,402 samples, 0.02%) + + + +start_thread (21,532,183,247 samples, 2.24%) +s.. + + +TGUCSettings::Get (10,727,284,775 samples, 1.11%) + + + +THashTable<std::__y1::pair<unsigned int const, TVector<NKikimr::NKqp::TKqpExecuterTxResult, std::__y1::allocator<NKikimr::NKqp::TKqpExecuterTxResult> > >, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::basic_clear (82,002,112 samples, 0.01%) + + + +[[kernel.kallsyms]] (301,204,087 samples, 0.03%) + + + +NKikimr::NMiniKQL::(anonymous namespace)::UnpackFromChunkedBuffer<false> (169,818,359 samples, 0.02%) + + + +__memcmp_avx2_movbe (2,054,862,998 samples, 0.21%) + + + +NYql::NDq::TDqComputeActorChannels::SendChannelData (84,983,543 samples, 0.01%) + + + +std::__y1::__upper_bound[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::NPage::TCompare<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TPageIterator<NKikimr::NTable::NPage::TBlockWithRecords<NKikimr::NTable::NPage::TFlatIndex::TRecord>, NKikimr::NTable::NPage::TFlatIndex::TRecord>, TArrayRef<NKikimr::TCell const>, std::__y1::__identity> (8,883,846,353 samples, 0.92%) + + + +NKikimr::NMiniKQL::THolderFactory::CreateDirectArrayHolder (90,269,215 samples, 0.01%) + + + +NActors::TBasicExecutorPool::ScheduleActivationExCommon (82,649,394 samples, 0.01%) + + + +NKikimr::NDataShard::(anonymous namespace)::TReader::GetReadTxMap (375,943,762 samples, 0.04%) + + + +TCMallocInternalNewArray (1,868,570,026 samples, 0.19%) + + + +[[kernel.kallsyms]] (84,580,412 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutorGCLogic::OnCommitLog (124,021,755 samples, 0.01%) + + + +[[kernel.kallsyms]] (123,909,880 samples, 0.01%) + + + +NKikimr::NTabletFlatExecutor::TExecutor::EnsureReadOnlyLease (1,163,514,899 samples, 0.12%) + + + +NKikimr::NDataShard::TRangeTreap<NKikimr::NDataShard::TLockInfo*, NKikimr::NDataShard::TRangeTreapDefaultValueTraits<NKikimr::NDataShard::TLockInfo*> >::RecomputeMaxRight (207,317,220 samples, 0.02%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +std::__y1::vector<NKikimr::NTable::TCellOp, NPrivate::TStackBasedAllocator<NKikimr::NTable::TCellOp, 64ul, true, std::__y1::allocator<NKikimr::NTable::TCellOp> > >::assign (168,028,837 samples, 0.02%) + + + +NActors::TExecutorThread::ThreadProc (1,044,193,941 samples, 0.11%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (1,294,878,699 samples, 0.13%) + + + +[[kernel.kallsyms]] (84,406,825 samples, 0.01%) + + + +[[kernel.kallsyms]] (351,938,243 samples, 0.04%) + + + +NActors::UnlockFromExecution<NActors::TMailboxTable::TReadAsFilledMailbox> (83,022,960 samples, 0.01%) + + + +[[kernel.kallsyms]] (3,999,822,839 samples, 0.42%) + + + +NKikimr::TPinnedPageRef::TPinnedPageRef (1,751,112,615 samples, 0.18%) + + + +NKikimr::NTable::TRunIter::Next (200,959,506 samples, 0.02%) + + + +std::__y1::__tree<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, std::__y1::__map_value_compare<unsigned int, std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo>, TLess<unsigned int>, true>, std::__y1::allocator<std::__y1::__value_type<unsigned int, NKikimr::NDataShard::(anonymous namespace)::TShortColumnInfo> > >::destroy (207,864,261 samples, 0.02%) + + + +NKikimr::IsSystemColumn (7,514,019,446 samples, 0.78%) + + + +all (962,771,773,468 samples, 100%) + + + +NKikimr::NTable::TPartGroupKeyIter::Next (123,738,043 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::HugePageAwareAllocator::ReleaseHugepage (206,510,236 samples, 0.02%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +[[kernel.kallsyms]] (2,844,441,177 samples, 0.30%) + + + +NYql::NDq::(anonymous namespace)::EstimateIntegralDataSize (164,138,020 samples, 0.02%) + + + +_nv034985rm (86,001,079 samples, 0.01%) + + + +[[kernel.kallsyms]] (18,248,479,787 samples, 1.90%) +[.. + + +NActors::TExecutorThreadCtx::WakeUp (284,142,554 samples, 0.03%) + + + +NYql::NUdf::TUnboxedValuePod::AsStringRef (209,843,578 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::Sampler::RecordAllocationSlow (628,303,071 samples, 0.07%) + + + +NKikimr::TSerializedCellVec::TSerializedCellVec (799,489,645 samples, 0.08%) + + + +tcmalloc::tcmalloc_internal::(anonymous namespace)::SampleifyAllocation (84,079,228 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::StackTraceTable::Iterate (97,148,020 samples, 0.01%) + + + +tcmalloc::tcmalloc_internal::CentralFreeList::RemoveRange (2,965,222,692 samples, 0.31%) + + + +NKikimr::NTable::NPage::TLabelWrapper::Read (134,160,770 samples, 0.01%) + + + +old_sort::__sort3[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TPartScheme::MakePinout (605,441,425 samples, 0.06%) + + + +UdfFreeWithSize (173,020,109 samples, 0.02%) + + + +THashTable<std::__y1::pair<unsigned int const, unsigned int>, unsigned int, THash<unsigned int>, TSelect1st, TEqualTo<unsigned int>, std::__y1::allocator<unsigned int> >::reserve (426,617,752 samples, 0.04%) + + + +std::__y1::__variant_detail::__visitation::__base::__dispatcher<0ul>::__dispatch[abi:v180000]<std::__y1::__variant_detail::__visitation::__variant::__value_visitor<NActors::TBasicExecutorPool::GetReadyActivationCommon (200,921,040 samples, 0.02%) + + + +NKikimr::TOwnedCellVec::Allocate (341,101,857 samples, 0.04%) + + + +tls13_enc (253,847,740 samples, 0.03%) + + + +_nv041477rm (127,472,478 samples, 0.01%) + + + +NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::Turn (126,159,026 samples, 0.01%) + + + +[[kernel.kallsyms]] (334,719,420 samples, 0.03%) + + + +NActors::TActorCallbackBehaviour::Receive (83,741,778 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (425,000,544 samples, 0.04%) + + + +[[vdso]] (85,538,324 samples, 0.01%) + + + +[[kernel.kallsyms]] (807,023,087 samples, 0.08%) + + + +NActors::IActor::Register (626,933,999 samples, 0.07%) + + + +[[kernel.kallsyms]] (85,550,519 samples, 0.01%) + + + +NKikimr::NTable::CreateIndexIter (542,145,576 samples, 0.06%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::AllocateSlow<&tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::CppOomPolicy, tcmalloc::tcmalloc_internal::DefaultAlignPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>::handle_oom> (85,725,759 samples, 0.01%) + + + +Ydb::Query::ExecuteQueryResponsePart::ByteSizeLong (57,303,167,595 samples, 5.95%) +Ydb::Qu.. + + +NKikimr::NDataShard::TBuildAndWaitDependenciesUnit::Execute (168,508,237 samples, 0.02%) + + + +[[kernel.kallsyms]] (3,999,822,839 samples, 0.42%) + + + +tcp_write (4,818,727,138 samples, 0.50%) + + + +Ydb::Value::~Value (82,002,112 samples, 0.01%) + + + +[ydbd] (246,495,010 samples, 0.03%) + + + +tcmalloc::tcmalloc_internal::internal_transfer_cache::RingBufferTransferCache<tcmalloc::tcmalloc_internal::CentralFreeList, tcmalloc::tcmalloc_internal::TransferCacheManager>::InsertRange (1,691,929,263 samples, 0.18%) + + + +NKikimr::TOwnedCellVecBatch::Append (84,386,404 samples, 0.01%) + + + +old_sort::__introsort<std::__y1::_ClassicAlgPolicy, std::__y1::__less<void, void>&, unsigned int*> (163,458,489 samples, 0.02%) + + + +aes_gcm_cipher (87,232,188 samples, 0.01%) + + + +TCMallocInternalAlignedAlloc (169,904,963 samples, 0.02%) + + + +tcmalloc::tcmalloc_internal::ThreadCache::DeallocateSlow (2,025,032,618 samples, 0.21%) + + + +NActors::TExecutorThreadStats::Aggregate (1,168,401,101 samples, 0.12%) + + + +NKikimr::NTabletFlatExecutor::TPrivatePageCache::TInfo::EnsurePage (872,060,468 samples, 0.09%) + + + +__memmove_avx_unaligned_erms (616,991,256 samples, 0.06%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::MergeFromInnerLoop<google::protobuf::RepeatedPtrField<Ydb::Value>::TypeHandler> (85,957,878 samples, 0.01%) + + + +google::protobuf::internal::RepeatedPtrFieldBase::DestroyProtos (82,002,112 samples, 0.01%) + + + +NActors::TActivationContext::Send< (27,962,292,948 samples, 2.90%) +NA.. + + +tcmalloc::tcmalloc_internal::ThreadCache::Scavenge (87,228,770 samples, 0.01%) + + + +[[kernel.kallsyms]] (3,949,417,195 samples, 0.41%) + + + +NActors::THarmonizer::PullStats (255,055,660 samples, 0.03%) + + + +std::__y1::__sift_up[abi:v180000]<std::__y1::_ClassicAlgPolicy, NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::TComparator&, NKikimr::NTable::TTableIterBase<NKikimr::NTable::TTableIterOps>::TElement*> (332,860,210 samples, 0.03%) + + + +[[kernel.kallsyms]] (152,591,339 samples, 0.02%) + + + +_nv041459rm (127,472,478 samples, 0.01%) + + + +google::protobuf::internal::ArenaStringPtr::Set (11,794,334,549 samples, 1.23%) + + + +NKikimr::TBlobStorageGroupProxy::Handle (82,384,112 samples, 0.01%) + + + +[[kernel.kallsyms]] (1,865,965,379 samples, 0.19%) + + + +[[kernel.kallsyms]] (86,907,510 samples, 0.01%) + + + +[[kernel.kallsyms]] (17,083,326,702 samples, 1.77%) + + + +NActors::TActivationContext::GetCurrentEventTicksAsSeconds (82,162,937 samples, 0.01%) + + + +[[kernel.kallsyms]] (83,480,588 samples, 0.01%) + + + +__memmove_avx_unaligned_erms (1,425,028,052 samples, 0.15%) + + + +slow_alloc<tcmalloc::tcmalloc_internal::TCMallocPolicy<tcmalloc::tcmalloc_internal::MallocOomPolicy, tcmalloc::tcmalloc_internal::AlignAsPolicy, tcmalloc::tcmalloc_internal::InvokeHooksPolicy, tcmalloc::tcmalloc_internal::LocalNumaPartitionPolicy>, decltype (167,916,787 samples, 0.02%) + + + +TCMallocInternalDeleteArrayAligned_nothrow (84,040,239 samples, 0.01%) + + + +