summaryrefslogtreecommitdiffstats
path: root/library/cpp/yt
Commit message (Collapse)AuthorAgeFilesLines
* Make THROW_ERROR_EXCEPTION_UNLESS/IF chainable with error attributespechatnov3 days2-4/+15
| | | | commit_hash:4e76ece0b75ab787ed04b6be5f183cecbf9b8167
* Unpoison use-after-dtor access to ref countermakxenov7 days3-6/+22
| | | | | | | | Two scenarios addressed: - Access to ref counters after explicit destructor of an object - Access to vptr for upcast of an already destroyed object commit_hash:a8f27500111817f325832d006feb3ce6c3c830f1
* YT-28451: Add tagged logging API and opaque event payloadbabenko7 days23-274/+1966
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Replace `TLogEvent::MessageRef` with an opaque `Payload` that carries the message together with structured key/value tags, deferring tag rendering to the consumer (logging thread). - Add the `TTaggedPayloadWriter`/`TTaggedPayloadReader` codec (`NDetail`), with a per-thread chunk-cached builder so tagged logging does no per-message heap allocation. - Model the payload as a typed `TLogEventPayload` — a `std::variant` of the opaque strong typedefs `TTaggedLogEventPayload` and `TStructuredLogEventPayload` (each over `TSharedRef`). The active alternative identifies the event kind, so the separate `ELogMessageKind` enum and `TLogEvent::MessageKind` field are removed; consumers dispatch via `std::holds_alternative`/`std::get` instead of a tag. - Add the fluent `YT_TLOG_*` API: `YT_TLOG_INFO("Message").With(key, value)` and `.With(key, value, "%spec")`; disabled levels skip argument evaluation. - Add well-known tags: `.With(value)` attaches a value under a statically known key resolved by ADL (e.g. `.With(error)` for the `Error` tag). - Teach the plain-text and structured formatters to render tags; add the `enable_native_tags` knob to emit tags into a nested structured attribute. - Add producer-side benchmarks. The tagged API is cheaper than `YT_LOG_*` for tagged calls and on par for tag-free ones: #| || **Producer call** | **`YT_LOG_*`** | **`YT_TLOG_*`** | **Δ** || || no tags | 81 ns | 82 ns | +2% || || 1 tag | 124 ns | 88 ns | -29% || || 2 tags | 140 ns | 101 ns | -28% || || 3 tags | 372 ns | 283 ns | -24% || |# -- #| || **<a href="https://nda.ya.ru/t/p0sVNSOC7ijzFF" target="_blank">![](https://nda.ya.ru/t/mAiQIjHx7Mm3JC =30x) Echo tests</a>** || |# commit_hash:70efc90e5c2b71e5311415a4e4508db42ff28971
* Fix yt logging use-after-dtormakxenov11 days1-3/+23
| | | | | | | Similar to `CacheDestroyed` above in this file. It is possible that `ThreadMessageTag` is read by the logger during thread shutdown after this thread-local's destruction (e.g. when another thread-local's destructor logs). Added a trivially destructible flag to guard the tag content. commit_hash:852afe8245de23e9abe69a08bf5d9bfe4b17496b
* Fix use-after-free in TError during program shutdownperst2012 days2-16/+29
| | | | | | | | | | | | | | | | --- Type: fix Component: library/cpp/yt/error Problem: TError::Enricher_ and TError::FromExceptionEnricher_ are static class members whose destructors are registered when error.cpp is loaded. However, if any code calls Singleton<>() during static initialization before error.cpp loads, the OnExit handler gets registered in standard atexit() first. Due to LIFO ordering, at program exit the enrichers are destroyed before OnExit() runs, but OnExit() then destroys Singletons whose destructors may create TError objects (e.g., to cancel futures), which invokes Enrich() on the already-destroyed std::function, causing use-after-free. This can lead to intermittent segfaults depending on the link order of translation units. Solution: Store enrichers in a LeakySingleton<TEnricherStorage> so they are never destroyed, as TError can be created anywhere including during program shutdown. --- Pull Request resolved: https://github.com/ytsaurus/ytsaurus/pull/1582 commit_hash:a9607f0094b4c60414d00ebca844db6a2ceafeb9
* YT-18571: Drop the redundant `#undef FOO_INL_H_` from `-inl.h` guard blocks.babenko12 days12-12/+0
| | | | commit_hash:8ccfa9ed373c83b84c21d12078e06befb05f026c
* Add bit I/O and binary interpolative coding to library/cpp/yt/codingbabenko12 days8-0/+660
| | | | | | | | | | ### `bit_io.h` MSB-first bit-stream writer/reader (`TBitWriter` / `TBitReader`) over a caller-owned buffer. The writer flushes whole 32-bit words via the unaligned-store API; the reader assumes a few bytes of over-read slack. ### `interpolative.h` - **Truncated-binary (minimal) code** — the entropy-optimal integer code for a uniform value in `[0, rangeSize)`. - **Binary interpolative coding** — `InterpolativeEncode` / `InterpolativeDecode` for sorted, strictly increasing integer sequences over a known range `[lo, hi]`. It recursively codes the median of each subrange, compressing clustered sequences well below a flat `log2` per element with no per-element headers. Length is conveyed out of band (e.g. via the existing `varint`). commit_hash:8baf84444b8cf8e8a6e32776b4ff48582187ac2b
* Avoid copy in TYsonString::ToSharedRef for TCowString payloadbabenko13 days1-2/+2
| | | | | Use the payload itself as the shared range holder instead of copying the string via TSharedRef::FromString. commit_hash:b427dbe6e8a8eaf3aa3c46b57f0f9965d57b3a95
* YT-18571: Drop TSharedRef::FromString(const char* str)babenko13 days4-10/+2
| | | | | | | | | Rationale: all overloads of `TSharedRef::FromString` must remain cheap and don't copy any payload. Remove the zero-terminated C string overload of `TSharedRef::FromString`. Callers passing a string literal should use `std::string/TString` explicitly. #| || **<a href="https://nda.ya.ru/t/-VG7qyBv7iD8vm" target="_blank">![](https://nda.ya.ru/t/mAiQIjHx7Mm3JC =30x) Echo tests</a>** || |# commit_hash:1a6718abcbe4e6a8f58592f55de8c37ceb2b73d3
* Make the yt and flow sources buildable in the ytsaurus-cpp-sdk exportmikari2026-07-071-0/+1
| | | | | Make the yt and flow sources buildable in the ytsaurus-cpp-sdk export commit_hash:a733ad0d534a3717117cd80d162f6d527843decd
* Extract TSlotMap and use it in TFuturebabenko2026-07-065-0/+382
| | | | commit_hash:624d9e33790566421f01090a99e63155da5027f8
* Revert commit rXXXXXX, Revert TCowString in TYsonString (library/cpp/yt part)babenko2026-07-063-18/+22
| | | | commit_hash:e6e226cb571efc3d4045f3154e7028c6cbbdef3d
* Revert TCowString in TYsonString (library/cpp/yt part)babenko2026-07-053-22/+18
| | | | | Reverts the library/cpp/yt portion of rXXXXXX. commit_hash:61c578eb480ea5a760364158808fd1f304773ae7
* Add TAnyObject::Holds<T> and rename IsCurrentlyStored to HoldsTypebabenko2026-07-033-7/+41
| | | | commit_hash:5f0c248f2c24b501b04777fb0300693b0e942c89
* Optimize TLogger::WithTag/WithRawTagpechatnov2026-07-036-14/+61
| | | | | Make TLogger::WithTag use a compile-time format string commit_hash:0a119b8eb278bceb411b7d071bbefe0b41e6233d
* Reliable on-demand construction of TThreadLockTracker instancebabenko2026-07-011-3/+8
| | | | commit_hash:39506fb1534ae2d5c5dfe509c9d95a7f74c2aa18
* YT-22593: Add AsciiStringToLower/AsciiStringToUpperbabenko2026-06-282-1/+30
| | | | commit_hash:106e53bffa668818abf8e4003d694e1eb0a0316f
* Address-salted ref-counted signaturebabenko2026-06-274-0/+118
| | | | | Self-validating signature word at the head of every `TRefCounter` (`YT_ENABLE_REF_COUNTED_SIGNATURE`, on by default in debug) so a coredump walker can distinguish a live ref-counted object from freed-but-unreclaimed memory and locate the counter without virtual-base casts. Consumed by gdb_plugin (separate PR). commit_hash:6696d8c26a8298be6543b1e3456de617d06417e9
* YT-28458: Add rseq-backed hot sensorsbabenko2026-06-243-9/+26
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Rename `percpu.{cpp,h}` to `per_cpu.{cpp,h}` and update all includers. Add an rseq-backed implementation of the hot per-CPU counter, time counter and gauge (`rseq_sensor_impl.{h,cpp}`): each update commits to the calling CPU's shard lock-free via an rseq critical section (`library/cpp/yt/rseq` `AddPerCpu`/`StorePerCpu`) — no atomic and no lock on the fast path. The shard array is sized to `NRseq::GetCpuCount()` and folded into the sensor allocation (`NewWithExtraSpace`); reads aggregate with `LoadPerCpu`. The gauge keeps last-writer-wins semantics. Linux-only. The existing `TPerCpu{Counter,TimeCounter,Gauge}` stay (`per_cpu_sensor_impl.{h,cpp}`) as the atomic sharded fallback. The two are interchangeable and chosen per sensor at construction in `TSolomonRegistry`, so the hot Increment/Update path carries no dispatch: * The rseq fast path is **off by default**; opt in via `singletons/solomon_registry/enable_rseq`. Even when on, a hot sensor uses it only in a process where the kernel rseq area sits at a fixed thread-pointer offset (tcmalloc/glibc-owned), per the rseq library's runtime safety probe (`NRseq::IsPerCpuFastPathSafe`). Everything else — notably a `dlopen`'d YQL UDF whose `__rseq_abi` lands in dynamically allocated TLS — uses the atomic sharded sensors. * `TSolomonRegistry` is a reconfigurable singleton (`solomon_registry`) with an `enable_rseq` knob (default false), settable in static config and updatable via dynamic config. Off Linux the rseq sensors do not exist and the registry uses the atomic sharded sensors for hot requests. The per-CPU summary is unchanged (TTscp + spinlock). Unit tests cover the atomic sensors, the rseq sensors (Linux-only), and the simple sensors. The controller-agent memory-watchdog integration tests are made resilient to the (core-count-dependent) per-sensor footprint. Benchmark (hot per-CPU path, 64-core host), atomic sharded vs rseq: | Benchmark | atomic | rseq | speedup | | --- | --- | --- | --- | | BM_PerCpuCounter, threads:1 | 30.7 ns | 3.6 ns | ~8.5x | | BM_PerCpuCounter, threads:16 | 30.9 ns | 4.4 ns | ~7x | | BM_PerCpuGauge, threads:1 | 32.8 ns | 12.4 ns | ~2.6x | | BM_PerCpuGauge, threads:16 | 32.7 ns | 12.5 ns | ~2.5x | commit_hash:8c633d31f03b2cc862ed2217ae08342bf42adc52
* Add ExactRefCountedCast and TRef::Containsbabenko2026-06-247-0/+199
| | | | | | | | | Some handy helpers. `ExactRefCountedCast<T>(p)`: exact-type downcast for `New<T>()`-allocated objects. `New<T>(`) builds a final `TRefCountedWrapper<T>`, so this casts to the wrapper and upcasts back to `T*`; being final, the `dynamic_cast` lowers to a single `type_info` compare (~2ns vs ~20ns for the is-a path). `TRef::Contains(other)`: true iff other's range lies within this range. commit_hash:138e8719b8ecbd953437b81380e54f736db029ef
* Add std::string-backed stream adapters to library/cpp/yt/stringbabenko2026-06-235-0/+319
| | | | commit_hash:54a07f0d411d0ece7af812a9fdf91509f25ee5cb
* YT-28458: Make per-CPU rseq fast path dlopen-safebabenko2026-06-234-8/+118
| | | | | | | | | | | | | | | | | | | | | | | | | Hardens `library/cpp/yt/rseq` for the case where it is linked into a dlopen'd, position-independent module (e.g. a YQL UDF `.so`). Extracted from the profiling work that enables the rseq fast path by default. **TLS model.** The weak `__rseq_abi` gets `global-dynamic` linkage under `__PIC__/__PIE__` (`initial-exec` otherwise), mirroring `contrib/libs/tcmalloc`. `initial-exec` needs a slot in the static TLS block reserved at startup, which the loader cannot grant a module dlopen'd later — the module would fail to load with "cannot allocate memory in static TLS block". This only changes the cold `&__rseq_abi` accesses; the hot path still reads `*(thread_pointer + CpuIdFieldOffset)`. **Runtime safety probe `IsPerCpuFastPathSafe()`.** The cached thread-pointer offset is valid only when `__rseq_abi` sits at a fixed offset from the thread pointer — a glibc-owned area or the static TLS block (incl. tcmalloc), the common case. When our `__rseq_abi` instead lands in a dlopen'd module's *dynamically allocated* TLS, the offset is valid only on the thread that computed it; on other threads the hot path's first store (`area->rseq_cs`) would corrupt unrelated memory. The probe spawns one thread and checks — by pointer comparison, never dereferencing the suspect offset — that the offset names that thread's rseq area; if not, callers use the atomic fallback. Decided once and cached (one thread spawn at first use).= commit_hash:633f58f500d9d097800da81f526c56283445ffc7
* YT-22593: migrate assorted library/cpp/yt string APIs to std::stringbabenko2026-06-224-24/+24
| | | | commit_hash:bfab0d0115b50949f66878004cf718b988575734
* YT-28504: Support heterogeneous lookup in cachesbabenko2026-06-192-2/+4
| | | | commit_hash:acb3e84437f5bdb125d7c1807847eb5edecbb11f
* Add lock-free per-CPU primitives to library/cpp/yt/rseqbabenko2026-06-197-3/+781
| | | | | | | | | | | | | | | | | Introduce AddPerCpu and StorePerCpu over an rseq-sharded per-CPU array. On the x86-64 Linux fast path the update is committed by a hand-rolled rseq critical section (non-atomic, migration-safe): addq for the 8-byte accumulate, movq / movdqu for the 8- or 16-byte store. The kernel restarts the sequence on preemption or migration, and only one thread runs on a CPU at a time, so no atomic or lock is needed. Off the fast path (other arches, no kernel rseq) the operation falls back to an atomic on the slot indexed by sched_getcpu(). A naturally-aligned 8-byte store is single-copy atomic on x86-64, so it is never observed torn; the 16-byte store may be, which is acceptable for a last-writer-wins gauge. commit_hash:6250f6e9e35cf3895ebafe0b534ec12cca50b03b
* Add TTscp::GetApproximatebabenko2026-06-185-27/+52
| | | | | | | | | | | | | | | | | | | | | TTscp::GetApproximate takes the processor id from the rseq fast path (GetCurrentCpuId) and the instant from a non-serializing rdtsc, instead of the single serializing rdtscp of TTscp::Get. TPerCpuGauge::Update switches to it: the per-shard timestamp only orders writes across shards to pick the freshest value, so the lower precision is fine. Update is virtual and now YT_PREVENT_TLS_CACHING -- the fiber-TLS boundary the inlined rseq read needs. #### Benchmark sas2-2769 (glibc 2.31 + tcmalloc, rseq fast path), median of 5: | primitive | time | |---|---| | TTscp::Get() (rdtscp) | 14.1 ns | | TTscp::GetApproximate() (rseq + rdtsc) | 10.6 ns (-25%) | commit_hash:b277b6551accd6d0b879f8ffb168bcbe8d9fbb74
* Make library/cpp/yt/rseq a Linux-only dependency of library/cpp/yt/systembabenko2026-06-154-16/+20
| | | | | Make library/cpp/yt/rseq a Linux-only dependency of library/cpp/yt/system commit_hash:7d6f5e738658447529440425b55b2891f6664d81
* Add YT_DEFINE_SENTINEL_OPTIONAL macrobabenko2026-06-152-3/+17
| | | | | | | | | | | | | | | | | | | Add a macro for defining `TSentinelOptional` type aliases when the value type is not structural (e.g. has protected members) and therefore cannot use `TValueSentinel<V>`. The macro collapses the boilerplate sentinel struct plus `using` declaration into a single line: ```cpp // before struct TInstantSentinel { static constexpr auto Sentinel = TInstant::Zero(); }; using TSentinelOptionalInstant = TSentinelOptional<TInstant, TInstantSentinel>; // after YT_DEFINE_SENTINEL_OPTIONAL(TSentinelOptionalInstant, TInstant, TInstant::Zero()); ``` Also convert the existing call sites in `service_detail.cpp` and `inferrum/block_cache.cpp`. commit_hash:5dcdeb8db215736b0ce5a5b71f30aead91c7b8e8
* YT-18571: Move TTscp to library/cpp/yt/systembabenko2026-06-153-0/+97
| | | | commit_hash:33721d8fd9919cec2c217db529145c881baf144b
* Fix rseq fast path on glibc < 2.35: read the shared __rseq_abi areababenko2026-06-141-28/+43
| | | | | | | | | | | | | | | | | | | | | | | The own-area approach did not deliver the fast path on glibc 2.31 (YT's current runtime). There tcmalloc registers the conventional `__rseq_abi` area for every thread; our attempt to register a separate area was rejected by the kernel with EINVAL (a thread may have only one rseq area), so `cpu_id` stayed -1 and every `GetCurrentCpuId()` fell back to `sched_getcpu()` (~17-20 ns, slower than the rdtscp it replaced). Read the shared `__rseq_abi` symbol instead -- the area tcmalloc, librseq and pre-2.35 glibc all register. Our definition is weak, so it coalesces with theirs when present (the common case -- tcmalloc owns it) and stands alone otherwise (e.g. musl), with us registering it. We register with the conventional signature `0x53053053` and size 32, so re-registering an already-registered area returns EBUSY (treated as success) rather than EINVAL -- coexisting cleanly with tcmalloc. glibc >= 2.35 still takes the `__rseq_offset` path unchanged. Measured on sas2-2769 (glibc 2.31 + tcmalloc): `GetCurrentCpuId()` 20.0 ns -> 0.60 ns, verified via strace that our registration now returns EBUSY against tcmalloc's `__rseq_abi` (was EINVAL against a separate area). commit_hash:509809deeb5f7c671817fcd9ebcc8499eabf096e
* Fold TEnumTraits GetMinValue/GetMaxValue to compile timebabenko2026-06-141-6/+12
| | | | | | | | | | | | | | | | | GetMinValue()/GetMaxValue() are constexpr, but when called from a runtime context for a large-domain enum, clang does not fold the min/max_element and emits a runtime scan over the whole domain on every call. This is hot on the master replay path: TEnumIndexedArray::operator[] bounds-checks against these (e.g. TCypressManager::FindHandler), and TCompositeAutomaton::RememberReign hits GetCurrentReign() = GetMaxValue() over the ~3300-entry EMasterReign domain per mutation. Bind the result to a constexpr local to force compile-time evaluation. Verified by disasm on a 240-value sample enum: getmin() goes from a ~44-instruction runtime scan to a single 'mov $const'. No behavior change. Part of YT-28453 (master replay-speed optimizations). commit_hash:7cdb969e00ba219415d80c5c8c984aa8bbde99d2
* Add library/cpp/yt/rseq: NYT::GetCurrentCpuId() via Linux rseqbabenko2026-06-1412-0/+455
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Self-contained current-CPU-id reader backed by Linux **rseq** (restartable sequences), with **no third-party dependency** (no librseq): * The rseq ABI is hand-defined; the calling thread is registered lazily via the rseq syscall. * Fast path is a single inlined, **branch-free** thread-local read. The offset always points at a readable `cpu_id` -- the glibc-owned area when glibc registers rseq (>= 2.35, via the weak `__rseq_offset`/`__rseq_size`), otherwise our own area -- so an unregistered thread reads `-1` and routes to the slow path. * Falls back to `sched_getcpu()` (Linux) or `0` (darwin/windows). Works on glibc **and musl** alike (librseq does not build on musl). Fiber-TLS contract: the inlined read must be reached only via a non-inlinable, fiber-switch-free frame (a virtual call or `YT_PREVENT_TLS_CACHING`). #### Benchmark -- cost of one cpu-id read | source | time / call | |---|---| | `GetCurrentCpuId()` (rseq) | **0.34 ns** | | `sched_getcpu()` (vDSO) | 3.5 ns | | `rdtscp` (what `TTscp::Get()` does) | 23 ns | This is an alternative to the librseq-based review/13886037 -- same speed, but no contrib dependency and it also covers musl. The unit test pins to each allowed CPU and asserts the reported id matches. 🤖 Generated with [Claude Code](https://claude.com/claude-code) commit_hash:09d282c2f48755836b1cd68cedbffc3c6a662eed
* Include port.h from logger.hbabenko2026-06-131-0/+2
| | | | | | | | | | YT_LOG_TRACE is gated on YT_ENABLE_TRACE_LOGGING, defined in library/cpp/yt/misc/port.h. logger.h relies on that macro but does not include port.h, so in a TU that does not pull in port.h before logger.h, YT_LOG_TRACE silently compiles to a no-op regardless of the configured log level. Make logger.h self-contained by including the header that defines the macro it depends on. commit_hash:c53f26a7dff9d3f9c5a9d9aab8ea7fa31d11ec49
* Speed up NYT::Formatbabenko2026-06-134-71/+44
| | | | | | | | | | | | | | | | | | | | | | | | | | | Profile-driven optimizations of the `Format` hot path, benchmarked against a representative master debug log (structured `"Key: %v"` messages dominated by GUIDs, strings, integers, bools and durations). Median improvements of ~15-20% across the workload, measured on a dedicated host. Changes: - `string_builder`: use `resize_uninitialized` in `DoReserve` to avoid zero-filling the buffer on every `Format` call. - `format`: replace the per-argument `memchr` (`spec.Contains('n')`) with an inline scan, force-inline `RunFormatterAt`, and add a `FormatString` fast path for the common plain `%v` / empty spec. - `guid`: rewrite `WriteGuidToBuffer` using a `clz`-derived digit count and a back-to-front fill instead of the per-magnitude branch cascade (cut from ~26% to ~12% of a GUID-heavy line). Validated against an `%x` reference over 2M random GUIDs plus edge cases. Also adds `library/cpp/yt/string/benchmark` to track `Format` performance. ### Benchmarks Median ns/op (lower is better), pinned core on a dedicated Xeon E5-2650 v2, 9x1s repetitions. See `library/cpp/yt/string/benchmark`. | Benchmark | What it formats | Before | After | Speedup | | --- | --- | ---: | ---: | ---: | | `ManyMixedArgs` | ~18 args: GUIDs, strings, duration, ints | 1030 | 833 | -19% | | `StringAndTwoGuids` | literal prefix + two GUIDs | 233 | 185 | -21% | | `IntAndGuid` | one int + one GUID | 205 | 179 | -13% | | `ManyInts` | six integers | 389 | 340 | -13% | | `Guid` | a single GUID | 156 | 131 | -16% | | `String` | a single string | 139 | 104 | -25% | | `Int` | a single integer | 142 | 120 | -15% | | `NoArgs` | a literal with no arguments | 88.8 | 85.7 | -3% | commit_hash:ce9957a06c3ff28b2889aa65fbbddf4ca444f9fe
* Add TSharedMutableRef::AllocateViaMmapbabenko2026-06-125-1/+220
| | | | commit_hash:1666d5c27b2dfe54460efdc686d98ad955b0c4f1
* YT-22593: Reduce TString usage in core/miscbabenko2026-06-071-1/+1
| | | | commit_hash:ba8c42476d6274212745348071682042e780037f
* Cache process/thread id getters and use them in TError origin capturebabenko2026-06-0719-10/+261
| | | | | | | | | | | | | | | | | | | | | ## Motivation Profiling the YT master Automaton thread showed TOriginAttributes::Capture (run on every non-OK TError) spending ~60% of its time in a getpid() syscall — uncached on glibc >= 2.25. NYT::GetCurrentThreadId() (gettid) feeds hot thread-affinity / log-manager checks on the same thread. ## Changes - New library/cpp/yt/system/process_id.* with cached GetProcessId(); GetSystemThreadId() now caches the kernel tid in TLS. Both caches reset in the child after fork. - Moved thread_name.{h,cpp} from misc to system. - Removed GetCurrentProcessId/GetCurrentThreadId shims from yt/yt/core/misc/proc.{h,cpp}; migrated all callers to NYT::GetProcessId / NYT::GetSystemThreadId. - TOriginAttributes::Capture uses the cached getters; recorded Tid is now the real kernel tid (matches perf/ps). - Added microbenchmarks (library/cpp/yt/system/benchmarks, yt/yt/core/benchmarks/error.cpp). ## Microbenchmarks (release) | | before | after | |---|---|---| | getpid | 101 ns | 0.33 ns | | gettid | 102 ns | 1.64 ns | | Capture | 161 ns | 50 ns | | failed TError | 221 ns | 74 ns | commit_hash:ee37ae57d61a5a2dd33daee935270f4bb93b7ff9
* Generalize GetEnvValueOrThrow with a typed conversion overloadbabenko2026-06-034-1/+83
| | | | | Add a templated GetEnvValueOrThrow<T> that parses the environment variable value via FromString, next to the existing std::string overload. commit_hash:0421b0463c473c8c7f88c0b1619484e52b002897
* YT: Add formatter for all protobuf enumsgrigminakov2026-06-021-1/+3
| | | | commit_hash:58bf07dcff4aac728a67e0607d2c3b49ad1feef1
* Cosmetics: fix typos in docstrings and commentsgearonixx2026-05-293-3/+3
| | | | | | | | | | | Fix typos in docstrings --- Pull Request resolved: https://github.com/ytsaurus/ytsaurus/pull/1733 Co-authored-by: ilyaibraev <[email protected]> commit_hash:33a12aeaeeaec2f93ef9f465a3d5cdff95b62757
* YT-26105: Make TError aware of ::TSystemErrordann2392026-05-251-0/+2
| | | | commit_hash:ca6efe06865fe9fc9ebfd5ca8bbd79c2acbb4ff3
* Use std::invoke to call std::invokable in TAtomicObject::Transformosidorkin2026-05-222-6/+6
| | | | commit_hash:699e7e9a27bcf1220bbe3e408349a36a50408644
* Remove excess blank linepechatnov2026-05-191-1/+0
| | | | commit_hash:fff41cdbc1400a312067a6517c334440404c662b
* YT-22593: Migrate yt/yt/ytree to std::stringbabenko2026-05-183-20/+36
| | | | commit_hash:3466775b052bc8a85a2aa85e9605968e7a5ea025
* Fix babenko-issuesdann2392026-05-121-1/+1
| | | | commit_hash:2728816c79b29fccf31698e16733a0220fd3069e
* YT-26137: Drop indicies in multicell managercherepashka2026-05-122-2/+4
| | | | | | | | | * Changelog entry Type: feature Component: master Drop indicies in multicell manager commit_hash:692a550606183f6a8cb93425761911bbba09dceb
* Extract environment variables helpers to library/cpp/yt/systembabenko2026-05-013-0/+26
| | | | commit_hash:5a11a7288f325d6fa0a9bec9a1ce0b7afa1f4984
* YT: Add missing 16bit types to TErrorAttribute conversionsdgolear2026-04-303-0/+22
| | | | commit_hash:7e973890af2061e2a78b34d31c404f000375a88b
* Intermediate changesrobot-piglet2026-04-301-1/+1
| | | | commit_hash:075da2320aef76c06611fc1f363508ed26ad1a78
* YT_DECLARE_SPIN_LOCK whack-a-mole 2: electric boogaloo, Theatrical Cutdann2392026-04-298-20/+23
| | | | commit_hash:946123c814d23e070516ef5f7d339cf6025547b6
generated by cgit v1.3 (git 2.53.0) at 2026-07-24 07:38:14 +0000