catboost 1.25.1 → 1.27.0

package/inc/util/string/vector.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#include "cast.h"
-#include "split.h"
-
-#include <util/generic/map.h>
-#include <util/generic/strbuf.h>
-#include <util/generic/string.h>
-#include <util/generic/vector.h>
-#include <util/string/cast.h>
-#include <util/system/yassert.h>
-
-#define KEEP_EMPTY_TOKENS 0x01
-
-//
-// NOTE: Check StringSplitter below to get more convenient split string interface.
-
-namespace NPrivate {
-
-    void SplitStringImpl(TVector<TString>* res, const char* ptr,
-                         const char* delimiter, size_t maxFields, int options);
-    void SplitStringImpl(TVector<TString>* res, const char* ptr, size_t len,
-                         const char* delimiter, size_t maxFields, int options);
-
-    void SplitStringImpl(TVector<TUtf16String>* res, const wchar16* ptr,
-                         const wchar16* delimiter, size_t maxFields, int options);
-    void SplitStringImpl(TVector<TUtf16String>* res, const wchar16* ptr, size_t len,
-                         const wchar16* delimiter, size_t maxFields, int options);
-
-    template <typename C>
-    struct TStringDeducer;
-
-    template <>
-    struct TStringDeducer<char> {
-        using type = TString;
-    };
-
-    template <>
-    struct TStringDeducer<wchar16> {
-        using type = TUtf16String;
-    };
-}
-
-template <typename C>
-TVector<typename ::NPrivate::TStringDeducer<C>::type>
-SplitString(const C* ptr, const C* delimiter,
-            size_t maxFields = 0, int options = 0) {
-    TVector<typename ::NPrivate::TStringDeducer<C>::type> res;
-    ::NPrivate::SplitStringImpl(&res, ptr, delimiter, maxFields, options);
-    return res;
-}
-
-template <typename C>
-TVector<typename ::NPrivate::TStringDeducer<C>::type>
-SplitString(const C* ptr, size_t len, const C* delimiter,
-            size_t maxFields = 0, int options = 0) {
-    TVector<typename ::NPrivate::TStringDeducer<C>::type> res;
-    ::NPrivate::SplitStringImpl(&res, ptr, len, delimiter, maxFields, options);
-    return res;
-}
-
-template <typename C>
-TVector<typename ::NPrivate::TStringDeducer<C>::type>
-SplitString(const typename ::NPrivate::TStringDeducer<C>::type& str, const C* delimiter,
-            size_t maxFields = 0, int options = 0) {
-    return SplitString(str.data(), str.size(), delimiter, maxFields, options);
-}
-
-template <class TIter>
-inline TString JoinStrings(TIter begin, TIter end, const TStringBuf delim) {
-    if (begin == end)
-        return TString();
-
-    TString result = ToString(*begin);
-
-    for (++begin; begin != end; ++begin) {
-        result.append(delim);
-        result.append(ToString(*begin));
-    }
-
-    return result;
-}
-
-template <class TIter>
-inline TUtf16String JoinStrings(TIter begin, TIter end, const TWtringBuf delim) {
-    if (begin == end)
-        return TUtf16String();
-
-    TUtf16String result = ToWtring(*begin);
-
-    for (++begin; begin != end; ++begin) {
-        result.append(delim);
-        result.append(ToWtring(*begin));
-    }
-
-    return result;
-}
-
-/// Concatenates elements of given TVector<TString>.
-inline TString JoinStrings(const TVector<TString>& v, const TStringBuf delim) {
-    return JoinStrings(v.begin(), v.end(), delim);
-}
-
-inline TString JoinStrings(const TVector<TString>& v, size_t index, size_t count, const TStringBuf delim) {
-    Y_ASSERT(index + count <= v.size() && "JoinStrings(): index or count out of range");
-    return JoinStrings(v.begin() + index, v.begin() + index + count, delim);
-}
-
-template <typename T>
-inline TString JoinVectorIntoString(const TVector<T>& v, const TStringBuf delim) {
-    return JoinStrings(v.begin(), v.end(), delim);
-}
-
-template <typename T>
-inline TString JoinVectorIntoString(const TVector<T>& v, size_t index, size_t count, const TStringBuf delim) {
-    Y_ASSERT(index + count <= v.size() && "JoinVectorIntoString(): index or count out of range");
-    return JoinStrings(v.begin() + index, v.begin() + index + count, delim);
-}
-
-TUtf16String JoinStrings(const TVector<TUtf16String>& v, const TWtringBuf delim);
-TUtf16String JoinStrings(const TVector<TUtf16String>& v, size_t index, size_t count, const TWtringBuf delim);
-
-//! Converts vector of strings to vector of type T variables
-template <typename T, typename TStringType>
-TVector<T> Scan(const TVector<TStringType>& input) {
-    TVector<T> output;
-    output.reserve(input.size());
-    for (int i = 0; i < input.ysize(); ++i) {
-        output.push_back(FromString<T>(input[i]));
-    }
-    return output;
-}

package/inc/util/system/align.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include "yassert.h"
-#include "defaults.h"
-#include <util/generic/bitops.h>
-
-template <class T>
-static inline T AlignDown(T len, T align) noexcept {
-    Y_ASSERT(IsPowerOf2(align)); // align should be power of 2
-    return len & ~(align - 1);
-}
-
-template <class T>
-static inline T AlignUp(T len, T align) noexcept {
-    const T alignedResult = AlignDown(len + (align - 1), align);
-    Y_ASSERT(alignedResult >= len); // check for overflow
-    return alignedResult;
-}
-
-template <class T>
-static inline T AlignUpSpace(T len, T align) noexcept {
-    Y_ASSERT(IsPowerOf2(align));       // align should be power of 2
-    return ((T)0 - len) & (align - 1); // AlignUp(len, align) - len;
-}
-
-template <class T>
-static inline T* AlignUp(T* ptr, size_t align) noexcept {
-    return (T*)AlignUp((uintptr_t)ptr, align);
-}
-
-template <class T>
-static inline T* AlignDown(T* ptr, size_t align) noexcept {
-    return (T*)AlignDown((uintptr_t)ptr, align);
-}
-
-template <class T>
-static inline T AlignUp(T t) noexcept {
-    return AlignUp(t, (size_t)PLATFORM_DATA_ALIGN);
-}
-
-template <class T>
-static inline T AlignDown(T t) noexcept {
-    return AlignDown(t, (size_t)PLATFORM_DATA_ALIGN);
-}
-
-template <class T>
-static inline T Align(T t) noexcept {
-    return AlignUp(t);
-}
-

package/inc/util/system/atexit.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "defaults.h"
-
-using TAtExitFunc = void (*)(void*);
-using TTraditionalAtExitFunc = void (*)();
-
-void AtExit(TAtExitFunc func, void* ctx);
-void AtExit(TAtExitFunc func, void* ctx, size_t priority);
-
-void AtExit(TTraditionalAtExitFunc func);
-void AtExit(TTraditionalAtExitFunc func, size_t priority);
-
-bool ExitStarted();
-
-/**
- * Generally it's a bad idea to call this method except for some rare cases,
- * like graceful python DLL module unload.
- * This function is not threadsafe.
- * Calls in the moment when application is not terminating - bad idea.
- */
-void ManualRunAtExitFinalizers();

package/inc/util/system/atomic.h

@@ -1,51 +0,0 @@
-#pragma once
-
-#include "defaults.h"
-
-using TAtomicBase = intptr_t;
-using TAtomic = volatile TAtomicBase;
-
-#if defined(__GNUC__)
-#include "atomic_gcc.h"
-#elif defined(_MSC_VER)
-#include "atomic_win.h"
-#else
-#error unsupported platform
-#endif
-
-#if !defined(ATOMIC_COMPILER_BARRIER)
-#define ATOMIC_COMPILER_BARRIER()
-#endif
-
-static inline TAtomicBase AtomicSub(TAtomic& a, TAtomicBase v) {
-    return AtomicAdd(a, -v);
-}
-
-static inline TAtomicBase AtomicGetAndSub(TAtomic& a, TAtomicBase v) {
-    return AtomicGetAndAdd(a, -v);
-}
-
-#if defined(USE_GENERIC_SETGET)
-static inline TAtomicBase AtomicGet(const TAtomic& a) {
-    return a;
-}
-
-static inline void AtomicSet(TAtomic& a, TAtomicBase v) {
-    a = v;
-}
-#endif
-
-static inline bool AtomicTryLock(TAtomic* a) {
-    return AtomicCas(a, 1, 0);
-}
-
-static inline bool AtomicTryAndTryLock(TAtomic* a) {
-    return (AtomicGet(*a) == 0) && AtomicTryLock(a);
-}
-
-static inline void AtomicUnlock(TAtomic* a) {
-    ATOMIC_COMPILER_BARRIER();
-    AtomicSet(*a, 0);
-}
-
-#include "atomic_ops.h"

package/inc/util/system/atomic_gcc.h

@@ -1,90 +0,0 @@
-#pragma once
-
-#define ATOMIC_COMPILER_BARRIER() __asm__ __volatile__("" \
-                                                       :  \
-                                                       :  \
-                                                       : "memory")
-
-static inline TAtomicBase AtomicGet(const TAtomic& a) {
-    TAtomicBase tmp;
-#if defined(_arm64_)
-    __asm__ __volatile__(
-        "ldar %x[value], %[ptr]  \n\t"
-        : [value] "=r"(tmp)
-        : [ptr] "Q"(a)
-        : "memory");
-#else
-    __atomic_load(&a, &tmp, __ATOMIC_ACQUIRE);
-#endif
-    return tmp;
-}
-
-static inline void AtomicSet(TAtomic& a, TAtomicBase v) {
-#if defined(_arm64_)
-    __asm__ __volatile__(
-        "stlr %x[value], %[ptr]  \n\t"
-        : [ptr] "=Q"(a)
-        : [value] "r"(v)
-        : "memory");
-#else
-    __atomic_store(&a, &v, __ATOMIC_RELEASE);
-#endif
-}
-
-static inline intptr_t AtomicIncrement(TAtomic& p) {
-    return __atomic_add_fetch(&p, 1, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicGetAndIncrement(TAtomic& p) {
-    return __atomic_fetch_add(&p, 1, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicDecrement(TAtomic& p) {
-    return __atomic_sub_fetch(&p, 1, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicGetAndDecrement(TAtomic& p) {
-    return __atomic_fetch_sub(&p, 1, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicAdd(TAtomic& p, intptr_t v) {
-    return __atomic_add_fetch(&p, v, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicGetAndAdd(TAtomic& p, intptr_t v) {
-    return __atomic_fetch_add(&p, v, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicSwap(TAtomic* p, intptr_t v) {
-    (void)p; // disable strange 'parameter set but not used' warning on gcc
-    intptr_t ret;
-    __atomic_exchange(p, &v, &ret, __ATOMIC_SEQ_CST);
-    return ret;
-}
-
-static inline bool AtomicCas(TAtomic* a, intptr_t exchange, intptr_t compare) {
-    (void)a; // disable strange 'parameter set but not used' warning on gcc
-    return __atomic_compare_exchange(a, &compare, &exchange, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicGetAndCas(TAtomic* a, intptr_t exchange, intptr_t compare) {
-    (void)a; // disable strange 'parameter set but not used' warning on gcc
-    __atomic_compare_exchange(a, &compare, &exchange, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
-    return compare;
-}
-
-static inline intptr_t AtomicOr(TAtomic& a, intptr_t b) {
-    return __atomic_or_fetch(&a, b, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicXor(TAtomic& a, intptr_t b) {
-    return __atomic_xor_fetch(&a, b, __ATOMIC_SEQ_CST);
-}
-
-static inline intptr_t AtomicAnd(TAtomic& a, intptr_t b) {
-    return __atomic_and_fetch(&a, b, __ATOMIC_SEQ_CST);
-}
-
-static inline void AtomicBarrier() {
-    __sync_synchronize();
-}

package/inc/util/system/atomic_ops.h

@@ -1,189 +0,0 @@
-#pragma once
-
-#include <util/generic/typetraits.h>
-
-template <typename T>
-inline TAtomic* AsAtomicPtr(T volatile* target) {
-    return reinterpret_cast<TAtomic*>(target);
-}
-
-template <typename T>
-inline const TAtomic* AsAtomicPtr(T const volatile* target) {
-    return reinterpret_cast<const TAtomic*>(target);
-}
-
-// integral types
-
-template <typename T>
-struct TAtomicTraits {
-    enum {
-        Castable = std::is_integral<T>::value && sizeof(T) == sizeof(TAtomicBase) && !std::is_const<T>::value,
-    };
-};
-
-template <typename T, typename TT>
-using TEnableIfCastable = std::enable_if_t<TAtomicTraits<T>::Castable, TT>;
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicGet(T const volatile& target) {
-    return static_cast<T>(AtomicGet(*AsAtomicPtr(&target)));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, void> AtomicSet(T volatile& target, TAtomicBase value) {
-    AtomicSet(*AsAtomicPtr(&target), value);
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicIncrement(T volatile& target) {
-    return static_cast<T>(AtomicIncrement(*AsAtomicPtr(&target)));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicGetAndIncrement(T volatile& target) {
-    return static_cast<T>(AtomicGetAndIncrement(*AsAtomicPtr(&target)));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicDecrement(T volatile& target) {
-    return static_cast<T>(AtomicDecrement(*AsAtomicPtr(&target)));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicGetAndDecrement(T volatile& target) {
-    return static_cast<T>(AtomicGetAndDecrement(*AsAtomicPtr(&target)));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicAdd(T volatile& target, TAtomicBase value) {
-    return static_cast<T>(AtomicAdd(*AsAtomicPtr(&target), value));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicGetAndAdd(T volatile& target, TAtomicBase value) {
-    return static_cast<T>(AtomicGetAndAdd(*AsAtomicPtr(&target), value));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicSub(T volatile& target, TAtomicBase value) {
-    return static_cast<T>(AtomicSub(*AsAtomicPtr(&target), value));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicGetAndSub(T volatile& target, TAtomicBase value) {
-    return static_cast<T>(AtomicGetAndSub(*AsAtomicPtr(&target), value));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicSwap(T volatile* target, TAtomicBase exchange) {
-    return static_cast<T>(AtomicSwap(AsAtomicPtr(target), exchange));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, bool> AtomicCas(T volatile* target, TAtomicBase exchange, TAtomicBase compare) {
-    return AtomicCas(AsAtomicPtr(target), exchange, compare);
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicGetAndCas(T volatile* target, TAtomicBase exchange, TAtomicBase compare) {
-    return static_cast<T>(AtomicGetAndCas(AsAtomicPtr(target), exchange, compare));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, bool> AtomicTryLock(T volatile* target) {
-    return AtomicTryLock(AsAtomicPtr(target));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, bool> AtomicTryAndTryLock(T volatile* target) {
-    return AtomicTryAndTryLock(AsAtomicPtr(target));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, void> AtomicUnlock(T volatile* target) {
-    AtomicUnlock(AsAtomicPtr(target));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicOr(T volatile& target, TAtomicBase value) {
-    return static_cast<T>(AtomicOr(*AsAtomicPtr(&target), value));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicAnd(T volatile& target, TAtomicBase value) {
-    return static_cast<T>(AtomicAnd(*AsAtomicPtr(&target), value));
-}
-
-template <typename T>
-inline TEnableIfCastable<T, T> AtomicXor(T volatile& target, TAtomicBase value) {
-    return static_cast<T>(AtomicXor(*AsAtomicPtr(&target), value));
-}
-
-// pointer types
-
-template <typename T>
-inline T* AtomicGet(T* const volatile& target) {
-    return reinterpret_cast<T*>(AtomicGet(*AsAtomicPtr(&target)));
-}
-
-template <typename T>
-inline void AtomicSet(T* volatile& target, T* value) {
-    AtomicSet(*AsAtomicPtr(&target), reinterpret_cast<TAtomicBase>(value));
-}
-
-using TNullPtr = decltype(nullptr);
-
-template <typename T>
-inline void AtomicSet(T* volatile& target, TNullPtr) {
-    AtomicSet(*AsAtomicPtr(&target), 0);
-}
-
-template <typename T>
-inline T* AtomicSwap(T* volatile* target, T* exchange) {
-    return reinterpret_cast<T*>(AtomicSwap(AsAtomicPtr(target), reinterpret_cast<TAtomicBase>(exchange)));
-}
-
-template <typename T>
-inline T* AtomicSwap(T* volatile* target, TNullPtr) {
-    return reinterpret_cast<T*>(AtomicSwap(AsAtomicPtr(target), 0));
-}
-
-template <typename T>
-inline bool AtomicCas(T* volatile* target, T* exchange, T* compare) {
-    return AtomicCas(AsAtomicPtr(target), reinterpret_cast<TAtomicBase>(exchange), reinterpret_cast<TAtomicBase>(compare));
-}
-
-template <typename T>
-inline T* AtomicGetAndCas(T* volatile* target, T* exchange, T* compare) {
-    return reinterpret_cast<T*>(AtomicGetAndCas(AsAtomicPtr(target), reinterpret_cast<TAtomicBase>(exchange), reinterpret_cast<TAtomicBase>(compare)));
-}
-
-template <typename T>
-inline bool AtomicCas(T* volatile* target, T* exchange, TNullPtr) {
-    return AtomicCas(AsAtomicPtr(target), reinterpret_cast<TAtomicBase>(exchange), 0);
-}
-
-template <typename T>
-inline T* AtomicGetAndCas(T* volatile* target, T* exchange, TNullPtr) {
-    return reinterpret_cast<T*>(AtomicGetAndCas(AsAtomicPtr(target), reinterpret_cast<TAtomicBase>(exchange), 0));
-}
-
-template <typename T>
-inline bool AtomicCas(T* volatile* target, TNullPtr, T* compare) {
-    return AtomicCas(AsAtomicPtr(target), 0, reinterpret_cast<TAtomicBase>(compare));
-}
-
-template <typename T>
-inline T* AtomicGetAndCas(T* volatile* target, TNullPtr, T* compare) {
-    return reinterpret_cast<T*>(AtomicGetAndCas(AsAtomicPtr(target), 0, reinterpret_cast<TAtomicBase>(compare)));
-}
-
-template <typename T>
-inline bool AtomicCas(T* volatile* target, TNullPtr, TNullPtr) {
-    return AtomicCas(AsAtomicPtr(target), 0, 0);
-}
-
-template <typename T>
-inline T* AtomicGetAndCas(T* volatile* target, TNullPtr, TNullPtr) {
-    return reinterpret_cast<T*>(AtomicGetAndCas(AsAtomicPtr(target), 0, 0));
-}

package/inc/util/system/atomic_win.h

@@ -1,114 +0,0 @@
-#pragma once
-
-#include <intrin.h>
-
-#define USE_GENERIC_SETGET
-
-#if defined(_i386_)
-
-#pragma intrinsic(_InterlockedIncrement)
-#pragma intrinsic(_InterlockedDecrement)
-#pragma intrinsic(_InterlockedExchangeAdd)
-#pragma intrinsic(_InterlockedExchange)
-#pragma intrinsic(_InterlockedCompareExchange)
-
-static inline intptr_t AtomicIncrement(TAtomic& a) {
-    return _InterlockedIncrement((volatile long*)&a);
-}
-
-static inline intptr_t AtomicGetAndIncrement(TAtomic& a) {
-    return _InterlockedIncrement((volatile long*)&a) - 1;
-}
-
-static inline intptr_t AtomicDecrement(TAtomic& a) {
-    return _InterlockedDecrement((volatile long*)&a);
-}
-
-static inline intptr_t AtomicGetAndDecrement(TAtomic& a) {
-    return _InterlockedDecrement((volatile long*)&a) + 1;
-}
-
-static inline intptr_t AtomicAdd(TAtomic& a, intptr_t b) {
-    return _InterlockedExchangeAdd((volatile long*)&a, b) + b;
-}
-
-static inline intptr_t AtomicGetAndAdd(TAtomic& a, intptr_t b) {
-    return _InterlockedExchangeAdd((volatile long*)&a, b);
-}
-
-static inline intptr_t AtomicSwap(TAtomic* a, intptr_t b) {
-    return _InterlockedExchange((volatile long*)a, b);
-}
-
-static inline bool AtomicCas(TAtomic* a, intptr_t exchange, intptr_t compare) {
-    return _InterlockedCompareExchange((volatile long*)a, exchange, compare) == compare;
-}
-
-static inline intptr_t AtomicGetAndCas(TAtomic* a, intptr_t exchange, intptr_t compare) {
-    return _InterlockedCompareExchange((volatile long*)a, exchange, compare);
-}
-
-#else // _x86_64_
-
-#pragma intrinsic(_InterlockedIncrement64)
-#pragma intrinsic(_InterlockedDecrement64)
-#pragma intrinsic(_InterlockedExchangeAdd64)
-#pragma intrinsic(_InterlockedExchange64)
-#pragma intrinsic(_InterlockedCompareExchange64)
-
-static inline intptr_t AtomicIncrement(TAtomic& a) {
-    return _InterlockedIncrement64((volatile __int64*)&a);
-}
-
-static inline intptr_t AtomicGetAndIncrement(TAtomic& a) {
-    return _InterlockedIncrement64((volatile __int64*)&a) - 1;
-}
-
-static inline intptr_t AtomicDecrement(TAtomic& a) {
-    return _InterlockedDecrement64((volatile __int64*)&a);
-}
-
-static inline intptr_t AtomicGetAndDecrement(TAtomic& a) {
-    return _InterlockedDecrement64((volatile __int64*)&a) + 1;
-}
-
-static inline intptr_t AtomicAdd(TAtomic& a, intptr_t b) {
-    return _InterlockedExchangeAdd64((volatile __int64*)&a, b) + b;
-}
-
-static inline intptr_t AtomicGetAndAdd(TAtomic& a, intptr_t b) {
-    return _InterlockedExchangeAdd64((volatile __int64*)&a, b);
-}
-
-static inline intptr_t AtomicSwap(TAtomic* a, intptr_t b) {
-    return _InterlockedExchange64((volatile __int64*)a, b);
-}
-
-static inline bool AtomicCas(TAtomic* a, intptr_t exchange, intptr_t compare) {
-    return _InterlockedCompareExchange64((volatile __int64*)a, exchange, compare) == compare;
-}
-
-static inline intptr_t AtomicGetAndCas(TAtomic* a, intptr_t exchange, intptr_t compare) {
-    return _InterlockedCompareExchange64((volatile __int64*)a, exchange, compare);
-}
-
-static inline intptr_t AtomicOr(TAtomic& a, intptr_t b) {
-    return _InterlockedOr64(&a, b) | b;
-}
-
-static inline intptr_t AtomicAnd(TAtomic& a, intptr_t b) {
-    return _InterlockedAnd64(&a, b) & b;
-}
-
-static inline intptr_t AtomicXor(TAtomic& a, intptr_t b) {
-    return _InterlockedXor64(&a, b) ^ b;
-}
-
-#endif // _x86_
-
-//TODO
-static inline void AtomicBarrier() {
-    TAtomic val = 0;
-
-    AtomicSwap(&val, 0);
-}

package/inc/util/system/backtrace.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <util/generic/fwd.h>
-#include <util/system/defaults.h>
-
-class IOutputStream;
-
-size_t BackTrace(void** p, size_t len);
-
-struct TResolvedSymbol {
-    const char* Name;
-    void* NearestSymbol;
-};
-
-TResolvedSymbol ResolveSymbol(void* sym, char* buf, size_t len);
-
-void FormatBackTrace(IOutputStream* out, void* const* backtrace, size_t backtraceSize);
-void FormatBackTrace(IOutputStream* out);
-void PrintBackTrace();
-
-using TFormatBackTraceFn = void (*)(IOutputStream*, void* const* backtrace, size_t backtraceSize);
-
-TFormatBackTraceFn SetFormatBackTraceFn(TFormatBackTraceFn f);
-TFormatBackTraceFn GetFormatBackTraceFn();
-
-class TBackTrace {
-private:
-    static constexpr size_t CAPACITY = 300;
-    void* Data[CAPACITY];
-    size_t Size;
-
-public:
-    TBackTrace();
-    void Capture();
-    void PrintTo(IOutputStream&) const;
-    TString PrintToString() const;
-
-    static TBackTrace FromCurrentException();
-};