From 96647fad5355ff5ef45a00a6d85c097028584ab0 Mon Sep 17 00:00:00 2001
From: lukyan <lukyan@yandex-team.ru>
Date: Thu, 10 Feb 2022 16:48:13 +0300
Subject: Restoring authorship annotation for <lukyan@yandex-team.ru>. Commit 2
of 2.
---
.../cpp/linear_regression/linear_regression.cpp | 42 +-
library/cpp/linear_regression/linear_regression.h | 4 +-
library/cpp/testing/benchmark/bench.cpp | 2 +-
library/cpp/yt/coding/varint-inl.h | 18 +-
library/cpp/yt/coding/varint.h | 10 +-
library/cpp/yt/memory/blob.cpp | 160 +++----
library/cpp/yt/memory/blob.h | 220 +++++-----
library/cpp/yt/memory/intrusive_ptr.h | 106 ++---
library/cpp/yt/memory/new-inl.h | 430 +++++++++----------
library/cpp/yt/memory/new.h | 68 +--
library/cpp/yt/memory/range.h | 16 +-
library/cpp/yt/memory/ref.cpp | 186 ++++----
library/cpp/yt/memory/ref.h | 8 +-
library/cpp/yt/memory/ref_counted-inl.h | 466 ++++++++++-----------
library/cpp/yt/memory/ref_counted.h | 264 ++++++------
library/cpp/yt/memory/ref_tracked-inl.h | 98 ++---
library/cpp/yt/memory/ref_tracked.cpp | 76 ++--
library/cpp/yt/memory/ref_tracked.h | 126 +++---
library/cpp/yt/memory/shared_range.h | 6 +-
.../cpp/yt/memory/unittests/intrusive_ptr_ut.cpp | 160 +++----
library/cpp/yt/memory/unittests/weak_ptr_ut.cpp | 68 +--
library/cpp/yt/memory/unittests/ya.make | 30 +-
library/cpp/yt/memory/weak_ptr.h | 184 ++++----
library/cpp/yt/memory/ya.make | 50 +--
library/cpp/yt/misc/port.h | 6 +-
library/cpp/yt/misc/source_location.cpp | 2 +-
library/cpp/yt/misc/ya.make | 42 +-
library/cpp/yt/yson_string/string.cpp | 2 +-
library/cpp/yt/yson_string/string.h | 2 +-
29 files changed, 1426 insertions(+), 1426 deletions(-)
(limited to 'library/cpp')
diff --git a/library/cpp/linear_regression/linear_regression.cpp b/library/cpp/linear_regression/linear_regression.cpp
index bcab777133..150f9d214e 100644
--- a/library/cpp/linear_regression/linear_regression.cpp
+++ b/library/cpp/linear_regression/linear_regression.cpp
@@ -33,7 +33,7 @@ bool TFastLinearRegressionSolver::Add(const TVector<double>& features, const dou
AddFeaturesProduct(weight, features, LinearizedOLSMatrix);
const double weightedGoal = goal * weight;
- double* olsVectorElement = OLSVector.data();
+ double* olsVectorElement = OLSVector.data();
for (const double feature : features) {
*olsVectorElement += feature * weightedGoal;
++olsVectorElement;
@@ -72,31 +72,31 @@ bool TLinearRegressionSolver::Add(const TVector<double>& features, const double
;
}
- double* olsMatrixElement = LinearizedOLSMatrix.data();
+ double* olsMatrixElement = LinearizedOLSMatrix.data();
- const double* lastMean = LastMeans.data();
- const double* newMean = NewMeans.data();
- const double* lastMeansEnd = lastMean + LastMeans.size();
- const double* newMeansEnd = newMean + NewMeans.size();
+ const double* lastMean = LastMeans.data();
+ const double* newMean = NewMeans.data();
+ const double* lastMeansEnd = lastMean + LastMeans.size();
+ const double* newMeansEnd = newMean + NewMeans.size();
#ifdef _sse2_
- for (; lastMean != lastMeansEnd; ++lastMean, ++newMean) {
+ for (; lastMean != lastMeansEnd; ++lastMean, ++newMean) {
__m128d factor = _mm_set_pd(*lastMean, *lastMean);
const double* secondFeatureMean = newMean;
- for (; secondFeatureMean + 1 < newMeansEnd; secondFeatureMean += 2, olsMatrixElement += 2) {
+ for (; secondFeatureMean + 1 < newMeansEnd; secondFeatureMean += 2, olsMatrixElement += 2) {
__m128d matrixElem = _mm_loadu_pd(olsMatrixElement);
__m128d secondFeatureMeanElem = _mm_loadu_pd(secondFeatureMean);
__m128d product = _mm_mul_pd(factor, secondFeatureMeanElem);
__m128d addition = _mm_add_pd(matrixElem, product);
_mm_storeu_pd(olsMatrixElement, addition);
}
- for (; secondFeatureMean < newMeansEnd; ++secondFeatureMean) {
+ for (; secondFeatureMean < newMeansEnd; ++secondFeatureMean) {
*olsMatrixElement++ += *lastMean * *secondFeatureMean;
}
}
#else
- for (; lastMean != lastMeansEnd; ++lastMean, ++newMean) {
- for (const double* secondFeatureMean = newMean; secondFeatureMean < newMeansEnd; ++secondFeatureMean) {
+ for (; lastMean != lastMeansEnd; ++lastMean, ++newMean) {
+ for (const double* secondFeatureMean = newMean; secondFeatureMean < newMeansEnd; ++secondFeatureMean) {
*olsMatrixElement++ += *lastMean * *secondFeatureMean;
}
}
@@ -326,13 +326,13 @@ namespace {
#ifdef _sse2_
inline void AddFeaturesProduct(const double weight, const TVector<double>& features, TVector<double>& linearizedOLSTriangleMatrix) {
- const double* leftFeature = features.data();
- const double* featuresEnd = features.data() + features.size();
- double* matrixElement = linearizedOLSTriangleMatrix.data();
+ const double* leftFeature = features.data();
+ const double* featuresEnd = features.data() + features.size();
+ double* matrixElement = linearizedOLSTriangleMatrix.data();
size_t unaligned = features.size() & 0x1;
- for (; leftFeature != featuresEnd; ++leftFeature, ++matrixElement) {
+ for (; leftFeature != featuresEnd; ++leftFeature, ++matrixElement) {
const double weightedFeature = weight * *leftFeature;
const double* rightFeature = leftFeature;
__m128d wf = {weightedFeature, weightedFeature};
@@ -340,7 +340,7 @@ namespace {
*matrixElement += weightedFeature * *rightFeature;
}
unaligned = (unaligned + 1) & 0x1;
- for (; rightFeature != featuresEnd; rightFeature += 2, matrixElement += 2) {
+ for (; rightFeature != featuresEnd; rightFeature += 2, matrixElement += 2) {
__m128d rf = _mm_loadu_pd(rightFeature);
__m128d matrixRow = _mm_loadu_pd(matrixElement);
__m128d rowAdd = _mm_mul_pd(rf, wf);
@@ -352,13 +352,13 @@ namespace {
}
#else
inline void AddFeaturesProduct(const double weight, const TVector<double>& features, TVector<double>& linearizedTriangleMatrix) {
- const double* leftFeature = features.data();
- const double* featuresEnd = features.data() + features.size();
- double* matrixElement = linearizedTriangleMatrix.data();
- for (; leftFeature != featuresEnd; ++leftFeature, ++matrixElement) {
+ const double* leftFeature = features.data();
+ const double* featuresEnd = features.data() + features.size();
+ double* matrixElement = linearizedTriangleMatrix.data();
+ for (; leftFeature != featuresEnd; ++leftFeature, ++matrixElement) {
const double weightedFeature = weight * *leftFeature;
const double* rightFeature = leftFeature;
- for (; rightFeature != featuresEnd; ++rightFeature, ++matrixElement) {
+ for (; rightFeature != featuresEnd; ++rightFeature, ++matrixElement) {
*matrixElement += weightedFeature * *rightFeature;
}
*matrixElement += weightedFeature;
diff --git a/library/cpp/linear_regression/linear_regression.h b/library/cpp/linear_regression/linear_regression.h
index 5015e2e4b6..e57de5ff6c 100644
--- a/library/cpp/linear_regression/linear_regression.h
+++ b/library/cpp/linear_regression/linear_regression.h
@@ -147,12 +147,12 @@ public:
bool Add(const TVector<double>& features, const TVector<double>& goals) {
Y_ASSERT(features.size() == goals.size());
- return Add(features.data(), features.data() + features.size(), goals.data());
+ return Add(features.data(), features.data() + features.size(), goals.data());
}
bool Add(const TVector<double>& features, const TVector<double>& goals, const TVector<double>& weights) {
Y_ASSERT(features.size() == goals.size() && features.size() == weights.size());
- return Add(features.data(), features.data() + features.size(), goals.data(), weights.data());
+ return Add(features.data(), features.data() + features.size(), goals.data(), weights.data());
}
template <typename TFloatType>
diff --git a/library/cpp/testing/benchmark/bench.cpp b/library/cpp/testing/benchmark/bench.cpp
index 8d69d64080..08d8708005 100644
--- a/library/cpp/testing/benchmark/bench.cpp
+++ b/library/cpp/testing/benchmark/bench.cpp
@@ -591,7 +591,7 @@ int NBench::Main(int argc, char** argv) {
if (opts.Threads > 1) {
NYmp::SetThreadCount(opts.Threads);
- NYmp::ParallelForStaticChunk(tests.data(), tests.data() + tests.size(), 1, func);
+ NYmp::ParallelForStaticChunk(tests.data(), tests.data() + tests.size(), 1, func);
} else {
for (auto it : tests) {
func(&it);
diff --git a/library/cpp/yt/coding/varint-inl.h b/library/cpp/yt/coding/varint-inl.h
index c226d7de22..f0a09e9d30 100644
--- a/library/cpp/yt/coding/varint-inl.h
+++ b/library/cpp/yt/coding/varint-inl.h
@@ -31,14 +31,14 @@ Y_FORCE_INLINE int WriteVarUint64Impl(TWriteCallback doWrite, ui64 value)
// These are optimized versions of these Read/Write functions in protobuf/io/coded_stream.cc.
Y_FORCE_INLINE int WriteVarUint64(IOutputStream* output, ui64 value)
{
- return WriteVarUint64Impl([&] (ui8 byte) {
+ return WriteVarUint64Impl([&] (ui8 byte) {
output->Write(byte);
}, value);
}
Y_FORCE_INLINE int WriteVarUint64(char* output, ui64 value)
{
- return WriteVarUint64Impl([&] (ui8 byte) {
+ return WriteVarUint64Impl([&] (ui8 byte) {
*output++ = byte;
}, value);
}
@@ -48,17 +48,17 @@ Y_FORCE_INLINE int WriteVarUint64(char* output, ui64 value)
template <class TOutput>
Y_FORCE_INLINE int WriteVarUint32Impl(TOutput output, ui32 value)
{
- return WriteVarUint64(output, static_cast<ui64>(value));
+ return WriteVarUint64(output, static_cast<ui64>(value));
}
Y_FORCE_INLINE int WriteVarUint32(IOutputStream* output, ui32 value)
{
- return WriteVarUint32Impl(output, value);
+ return WriteVarUint32Impl(output, value);
}
Y_FORCE_INLINE int WriteVarUint32(char* output, ui32 value)
{
- return WriteVarUint32Impl(output, value);
+ return WriteVarUint32Impl(output, value);
}
////////////////////////////////////////////////////////////////////////////////
@@ -66,7 +66,7 @@ Y_FORCE_INLINE int WriteVarUint32(char* output, ui32 value)
template <class TOutput>
Y_FORCE_INLINE int WriteVarInt32Impl(TOutput output, i32 value)
{
- return WriteVarUint64(output, static_cast<ui64>(ZigZagEncode32(value)));
+ return WriteVarUint64(output, static_cast<ui64>(ZigZagEncode32(value)));
}
Y_FORCE_INLINE int WriteVarInt32(IOutputStream* output, i32 value)
@@ -84,7 +84,7 @@ Y_FORCE_INLINE int WriteVarInt32(char* output, i32 value)
template <class TOutput>
Y_FORCE_INLINE int WriteVarInt64Impl(TOutput output, i64 value)
{
- return WriteVarUint64(output, static_cast<ui64>(ZigZagEncode64(value)));
+ return WriteVarUint64(output, static_cast<ui64>(ZigZagEncode64(value)));
}
Y_FORCE_INLINE int WriteVarInt64(IOutputStream* output, i64 value)
@@ -121,7 +121,7 @@ Y_FORCE_INLINE int ReadVarUint64Impl(TReadCallback doRead, ui64* value)
Y_FORCE_INLINE int ReadVarUint64(IInputStream* input, ui64* value)
{
- return ReadVarUint64Impl([&] () {
+ return ReadVarUint64Impl([&] () {
char byte;
if (input->Read(&byte, 1) != 1) {
throw TSimpleException("Premature end of stream while reading varuint64");
@@ -132,7 +132,7 @@ Y_FORCE_INLINE int ReadVarUint64(IInputStream* input, ui64* value)
Y_FORCE_INLINE int ReadVarUint64(const char* input, ui64* value)
{
- return ReadVarUint64Impl([&] () {
+ return ReadVarUint64Impl([&] () {
char byte = *input;
++input;
return byte;
diff --git a/library/cpp/yt/coding/varint.h b/library/cpp/yt/coding/varint.h
index e79db873ae..c5399f8b06 100644
--- a/library/cpp/yt/coding/varint.h
+++ b/library/cpp/yt/coding/varint.h
@@ -16,7 +16,7 @@ constexpr size_t MaxVarUint64Size = (8 * sizeof(ui64) - 1) / 7 + 1;
constexpr size_t MaxVarInt32Size = (8 * sizeof(ui32) - 1) / 7 + 1;
constexpr size_t MaxVarUint32Size = (8 * sizeof(ui32) - 1) / 7 + 1;
-
+
// Various functions to read/write varints.
// Returns the number of bytes written.
@@ -25,8 +25,8 @@ int WriteVarUint32(IOutputStream* output, ui32 value);
int WriteVarInt32(IOutputStream* output, i32 value);
int WriteVarInt64(IOutputStream* output, i64 value);
-int WriteVarUint64(char* output, ui64 value);
-int WriteVarUint32(char* output, ui32 value);
+int WriteVarUint64(char* output, ui64 value);
+int WriteVarUint32(char* output, ui32 value);
int WriteVarInt32(char* output, i32 value);
int WriteVarInt64(char* output, i64 value);
@@ -36,8 +36,8 @@ int ReadVarUint32(IInputStream* input, ui32* value);
int ReadVarInt32(IInputStream* input, i32* value);
int ReadVarInt64(IInputStream* input, i64* value);
-int ReadVarUint64(const char* input, ui64* value);
-int ReadVarUint32(const char* input, ui32* value);
+int ReadVarUint64(const char* input, ui64* value);
+int ReadVarUint32(const char* input, ui32* value);
int ReadVarInt32(const char* input, i32* value);
int ReadVarInt64(const char* input, i64* value);
diff --git a/library/cpp/yt/memory/blob.cpp b/library/cpp/yt/memory/blob.cpp
index 8dfaeb791a..86000b033b 100644
--- a/library/cpp/yt/memory/blob.cpp
+++ b/library/cpp/yt/memory/blob.cpp
@@ -1,6 +1,6 @@
-#include "blob.h"
-#include "ref.h"
-
+#include "blob.h"
+#include "ref.h"
+
#include <library/cpp/ytalloc/api/ytalloc.h>
namespace NYT {
@@ -9,26 +9,26 @@ namespace NYT {
static constexpr size_t InitialBlobCapacity = 16;
static constexpr double BlobCapacityMultiplier = 1.5;
-
+
TBlob::TBlob(
TRefCountedTypeCookie tagCookie,
size_t size,
bool initiailizeStorage,
bool pageAligned)
: PageAligned_(pageAligned)
-{
+{
SetTagCookie(tagCookie);
- if (size == 0) {
- Reset();
- } else {
+ if (size == 0) {
+ Reset();
+ } else {
Allocate(std::max(size, InitialBlobCapacity));
Size_ = size;
- if (initiailizeStorage) {
+ if (initiailizeStorage) {
::memset(Begin_, 0, Size_);
- }
- }
-}
-
+ }
+ }
+}
+
TBlob::TBlob(
TRefCountedTypeCookie tagCookie,
TRef data,
@@ -40,80 +40,80 @@ TBlob::TBlob(
Append(data);
}
-TBlob::TBlob(const TBlob& other)
+TBlob::TBlob(const TBlob& other)
: PageAligned_(other.PageAligned_)
-{
+{
SetTagCookie(other);
- if (other.Size_ == 0) {
- Reset();
- } else {
+ if (other.Size_ == 0) {
+ Reset();
+ } else {
Allocate(std::max(InitialBlobCapacity, other.Size_));
::memcpy(Begin_, other.Begin_, other.Size_);
Size_ = other.Size_;
- }
-}
-
+ }
+}
+
TBlob::TBlob(TBlob&& other) noexcept
: Begin_(other.Begin_)
- , Size_(other.Size_)
- , Capacity_(other.Capacity_)
+ , Size_(other.Size_)
+ , Capacity_(other.Capacity_)
, PageAligned_(other.PageAligned_)
-{
+{
SetTagCookie(other);
- other.Reset();
-}
-
-TBlob::~TBlob()
-{
+ other.Reset();
+}
+
+TBlob::~TBlob()
+{
Free();
-}
-
-void TBlob::Reserve(size_t newCapacity)
-{
- if (newCapacity > Capacity_) {
+}
+
+void TBlob::Reserve(size_t newCapacity)
+{
+ if (newCapacity > Capacity_) {
Reallocate(newCapacity);
- }
-}
-
-void TBlob::Resize(size_t newSize, bool initializeStorage /*= true*/)
-{
- if (newSize > Size_) {
- if (newSize > Capacity_) {
+ }
+}
+
+void TBlob::Resize(size_t newSize, bool initializeStorage /*= true*/)
+{
+ if (newSize > Size_) {
+ if (newSize > Capacity_) {
size_t newCapacity;
- if (Capacity_ == 0) {
+ if (Capacity_ == 0) {
newCapacity = std::max(InitialBlobCapacity, newSize);
- } else {
+ } else {
newCapacity = std::max(static_cast<size_t>(Capacity_ * BlobCapacityMultiplier), newSize);
- }
+ }
Reallocate(newCapacity);
- }
- if (initializeStorage) {
+ }
+ if (initializeStorage) {
::memset(Begin_ + Size_, 0, newSize - Size_);
- }
- }
- Size_ = newSize;
-}
-
-TBlob& TBlob::operator = (const TBlob& rhs)
-{
- if (this != &rhs) {
+ }
+ }
+ Size_ = newSize;
+}
+
+TBlob& TBlob::operator = (const TBlob& rhs)
+{
+ if (this != &rhs) {
this->~TBlob();
new(this) TBlob(rhs);
- }
- return *this;
-}
-
+ }
+ return *this;
+}
+
TBlob& TBlob::operator = (TBlob&& rhs) noexcept
-{
- if (this != &rhs) {
+{
+ if (this != &rhs) {
this->~TBlob();
new(this) TBlob(std::move(rhs));
- }
- return *this;
-}
-
-void TBlob::Append(const void* data, size_t size)
-{
+ }
+ return *this;
+}
+
+void TBlob::Append(const void* data, size_t size)
+{
if (Size_ + size > Capacity_) {
Resize(Size_ + size, false);
::memcpy(Begin_ + Size_ - size, data, size);
@@ -121,13 +121,13 @@ void TBlob::Append(const void* data, size_t size)
::memcpy(Begin_ + Size_, data, size);
Size_ += size;
}
-}
-
+}
+
void TBlob::Append(TRef ref)
-{
- Append(ref.Begin(), ref.Size());
-}
-
+{
+ Append(ref.Begin(), ref.Size());
+}
+
void TBlob::Append(char ch)
{
if (Size_ + 1 > Capacity_) {
@@ -138,12 +138,12 @@ void TBlob::Append(char ch)
}
}
-void TBlob::Reset()
-{
+void TBlob::Reset()
+{
Begin_ = nullptr;
- Size_ = Capacity_ = 0;
-}
-
+ Size_ = Capacity_ = 0;
+}
+
char* TBlob::DoAllocate(size_t size)
{
return static_cast<char*>(PageAligned_
@@ -219,6 +219,6 @@ void swap(TBlob& left, TBlob& right)
}
}
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/blob.h b/library/cpp/yt/memory/blob.h
index 7d1621a09a..99441fb8c9 100644
--- a/library/cpp/yt/memory/blob.h
+++ b/library/cpp/yt/memory/blob.h
@@ -1,25 +1,25 @@
-#pragma once
-
+#pragma once
+
#include "ref.h"
#include "ref_counted.h"
-
-namespace NYT {
-
-////////////////////////////////////////////////////////////////////////////////
-
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
//! Default memory tag for TBlob.
struct TDefaultBlobTag
{ };
-//! A home-grown optimized replacement for |std::vector<char>| suitable for carrying
-//! large chunks of data.
-/*!
- * Compared to |std::vector<char>|, this class supports uninitialized allocations
- * when explicitly requested to.
- */
-class TBlob
-{
-public:
+//! A home-grown optimized replacement for |std::vector<char>| suitable for carrying
+//! large chunks of data.
+/*!
+ * Compared to |std::vector<char>|, this class supports uninitialized allocations
+ * when explicitly requested to.
+ */
+class TBlob
+{
+public:
//! Constructs a blob with a given size.
TBlob(
TRefCountedTypeCookie tagCookie,
@@ -33,13 +33,13 @@ public:
TRef data,
bool pageAligned = false);
- //! Constructs an empty blob.
+ //! Constructs an empty blob.
template <class TTag = TDefaultBlobTag>
explicit TBlob(TTag tag = {})
: TBlob(tag, 0, true, false)
{ }
-
- //! Constructs a blob with a given size.
+
+ //! Constructs a blob with a given size.
template <class TTag>
explicit TBlob(
TTag,
@@ -52,7 +52,7 @@ public:
initiailizeStorage,
pageAligned)
{ }
-
+
//! Copies a chunk of memory into a new instance.
template <class TTag>
TBlob(
@@ -73,52 +73,52 @@ public:
template <typename T, typename U>
TBlob(const T*, U) = delete;
- //! Copies the data.
- TBlob(const TBlob& other);
-
- //! Moves the data (takes the ownership).
+ //! Copies the data.
+ TBlob(const TBlob& other);
+
+ //! Moves the data (takes the ownership).
TBlob(TBlob&& other) noexcept;
-
- //! Reclaims the memory.
- ~TBlob();
-
- //! Ensures that capacity is at least #capacity.
- void Reserve(size_t newCapacity);
-
- //! Changes the size to #newSize.
- /*!
- * If #size exceeds the current capacity,
- * we make sure the new capacity grows exponentially.
- * Hence calling #Resize N times to increase the size by N only
- * takes amortized O(1) time per call.
- */
- void Resize(size_t newSize, bool initializeStorage = true);
-
- //! Returns the start pointer.
+
+ //! Reclaims the memory.
+ ~TBlob();
+
+ //! Ensures that capacity is at least #capacity.
+ void Reserve(size_t newCapacity);
+
+ //! Changes the size to #newSize.
+ /*!
+ * If #size exceeds the current capacity,
+ * we make sure the new capacity grows exponentially.
+ * Hence calling #Resize N times to increase the size by N only
+ * takes amortized O(1) time per call.
+ */
+ void Resize(size_t newSize, bool initializeStorage = true);
+
+ //! Returns the start pointer.
Y_FORCE_INLINE const char* Begin() const
- {
- return Begin_;
- }
-
- //! Returns the start pointer.
+ {
+ return Begin_;
+ }
+
+ //! Returns the start pointer.
Y_FORCE_INLINE char* Begin()
- {
- return Begin_;
- }
-
- //! Returns the end pointer.
+ {
+ return Begin_;
+ }
+
+ //! Returns the end pointer.
Y_FORCE_INLINE const char* End() const
- {
- return Begin_ + Size_;
- }
-
- //! Returns the end pointer.
+ {
+ return Begin_ + Size_;
+ }
+
+ //! Returns the end pointer.
Y_FORCE_INLINE char* End()
- {
- return Begin_ + Size_;
- }
-
- //! Returns the size.
+ {
+ return Begin_ + Size_;
+ }
+
+ //! Returns the size.
Y_FORCE_INLINE size_t size() const
{
return Size_;
@@ -126,16 +126,16 @@ public:
//! Returns the size.
Y_FORCE_INLINE size_t Size() const
- {
- return Size_;
- }
-
- //! Returns the capacity.
+ {
+ return Size_;
+ }
+
+ //! Returns the capacity.
Y_FORCE_INLINE size_t Capacity() const
- {
- return Capacity_;
- }
-
+ {
+ return Capacity_;
+ }
+
//! Returns the TStringBuf instance for the occupied part of the blob.
Y_FORCE_INLINE TStringBuf ToStringBuf() const
{
@@ -148,42 +148,42 @@ public:
return TRef(Begin_, Size_);
}
- //! Provides by-value access to the underlying storage.
+ //! Provides by-value access to the underlying storage.
Y_FORCE_INLINE char operator [] (size_t index) const
- {
- return Begin_[index];
- }
-
- //! Provides by-ref access to the underlying storage.
+ {
+ return Begin_[index];
+ }
+
+ //! Provides by-ref access to the underlying storage.
Y_FORCE_INLINE char& operator [] (size_t index)
- {
- return Begin_[index];
- }
-
- //! Clears the instance but does not reclaim the memory.
+ {
+ return Begin_[index];
+ }
+
+ //! Clears the instance but does not reclaim the memory.
Y_FORCE_INLINE void Clear()
- {
- Size_ = 0;
- }
-
- //! Returns |true| if size is zero.
+ {
+ Size_ = 0;
+ }
+
+ //! Returns |true| if size is zero.
Y_FORCE_INLINE bool IsEmpty() const
- {
- return Size_ == 0;
- }
-
- //! Overwrites the current instance.
- TBlob& operator = (const TBlob& rhs);
-
- //! Takes the ownership.
+ {
+ return Size_ == 0;
+ }
+
+ //! Overwrites the current instance.
+ TBlob& operator = (const TBlob& rhs);
+
+ //! Takes the ownership.
TBlob& operator = (TBlob&& rhs) noexcept;
-
- //! Appends a chunk of memory to the end.
- void Append(const void* data, size_t size);
-
- //! Appends a chunk of memory to the end.
+
+ //! Appends a chunk of memory to the end.
+ void Append(const void* data, size_t size);
+
+ //! Appends a chunk of memory to the end.
void Append(TRef ref);
-
+
//! Appends a single char to the end.
void Append(char ch);
@@ -192,12 +192,12 @@ public:
friend void swap(TBlob& left, TBlob& right);
-private:
+private:
char* Begin_ = nullptr;
size_t Size_ = 0;
size_t Capacity_ = 0;
bool PageAligned_ = false;
-
+
#ifdef YT_ENABLE_REF_COUNTED_TRACKING
TRefCountedTypeCookie TagCookie_ = NullRefCountedTypeCookie;
#endif
@@ -207,15 +207,15 @@ private:
void Reallocate(size_t newCapacity);
void Free();
- void Reset();
-
+ void Reset();
+
void SetTagCookie(TRefCountedTypeCookie tagCookie);
void SetTagCookie(const TBlob& other);
-};
-
+};
+
void swap(TBlob& left, TBlob& right);
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT
-
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
diff --git a/library/cpp/yt/memory/intrusive_ptr.h b/library/cpp/yt/memory/intrusive_ptr.h
index 7dd02c9c76..3dead7db1d 100644
--- a/library/cpp/yt/memory/intrusive_ptr.h
+++ b/library/cpp/yt/memory/intrusive_ptr.h
@@ -1,6 +1,6 @@
#pragma once
-#include "ref_counted.h"
+#include "ref_counted.h"
#include <util/generic/hash.h>
#include <util/generic/utility.h>
@@ -12,13 +12,13 @@ namespace NYT {
////////////////////////////////////////////////////////////////////////////////
-template <class T>
+template <class T>
class TIntrusivePtr
{
public:
typedef T TUnderlying;
- constexpr TIntrusivePtr() noexcept
+ constexpr TIntrusivePtr() noexcept
{ }
constexpr TIntrusivePtr(std::nullptr_t) noexcept
@@ -32,7 +32,7 @@ public:
* Note that it notoriously hard to make this constructor explicit
* given the current amount of code written.
*/
- TIntrusivePtr(T* obj, bool addReference = true) noexcept
+ TIntrusivePtr(T* obj, bool addReference = true) noexcept
: T_(obj)
{
if (T_ && addReference) {
@@ -41,7 +41,7 @@ public:
}
//! Copy constructor.
- TIntrusivePtr(const TIntrusivePtr& other) noexcept
+ TIntrusivePtr(const TIntrusivePtr& other) noexcept
: T_(other.Get())
{
if (T_) {
@@ -51,19 +51,19 @@ public:
//! Copy constructor with an upcast.
template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
- TIntrusivePtr(const TIntrusivePtr<U>& other) noexcept
+ TIntrusivePtr(const TIntrusivePtr<U>& other) noexcept
: T_(other.Get())
{
- static_assert(
- std::is_base_of_v<TRefCountedBase, T>,
- "Cast allowed only for types derived from TRefCountedBase");
+ static_assert(
+ std::is_base_of_v<TRefCountedBase, T>,
+ "Cast allowed only for types derived from TRefCountedBase");
if (T_) {
Ref(T_);
}
}
//! Move constructor.
- TIntrusivePtr(TIntrusivePtr&& other) noexcept
+ TIntrusivePtr(TIntrusivePtr&& other) noexcept
: T_(other.Get())
{
other.T_ = nullptr;
@@ -71,12 +71,12 @@ public:
//! Move constructor with an upcast.
template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
- TIntrusivePtr(TIntrusivePtr<U>&& other) noexcept
+ TIntrusivePtr(TIntrusivePtr<U>&& other) noexcept
: T_(other.Get())
{
- static_assert(
- std::is_base_of_v<TRefCountedBase, T>,
- "Cast allowed only for types derived from TRefCountedBase");
+ static_assert(
+ std::is_base_of_v<TRefCountedBase, T>,
+ "Cast allowed only for types derived from TRefCountedBase");
other.T_ = nullptr;
}
@@ -101,10 +101,10 @@ public:
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
- static_assert(
- std::is_base_of_v<TRefCountedBase, T>,
- "Cast allowed only for types derived from TRefCountedBase");
+ "U* must be convertible to T*");
+ static_assert(
+ std::is_base_of_v<TRefCountedBase, T>,
+ "Cast allowed only for types derived from TRefCountedBase");
TIntrusivePtr(other).Swap(*this);
return *this;
}
@@ -122,10 +122,10 @@ public:
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
- static_assert(
- std::is_base_of_v<TRefCountedBase, T>,
- "Cast allowed only for types derived from TRefCountedBase");
+ "U* must be convertible to T*");
+ static_assert(
+ std::is_base_of_v<TRefCountedBase, T>,
+ "Cast allowed only for types derived from TRefCountedBase");
TIntrusivePtr(std::move(other)).Swap(*this);
return *this;
}
@@ -196,31 +196,31 @@ TIntrusivePtr<T> MakeStrong(T* p)
return TIntrusivePtr<T>(p);
}
-//! Tries to obtain an intrusive pointer for an object that may had
-//! already lost all of its references and, thus, is about to be deleted.
-/*!
- * You may call this method at any time provided that you have a valid
- * raw pointer to an object. The call either returns an intrusive pointer
- * for the object (thus ensuring that the object won't be destroyed until
- * you're holding this pointer) or NULL indicating that the last reference
- * had already been lost and the object is on its way to heavens.
- * All these steps happen atomically.
- *
- * Under all circumstances it is caller's responsibility the make sure that
- * the object is not destroyed during the call to #DangerousGetPtr.
- * Typically this is achieved by keeping a (lock-protected) collection of
- * raw pointers, taking a lock in object's destructor, and unregistering
- * its raw pointer from the collection there.
- */
-
-template <class T>
-Y_FORCE_INLINE TIntrusivePtr<T> DangerousGetPtr(T* object)
-{
- return object->TryRef()
- ? TIntrusivePtr<T>(object, false)
- : TIntrusivePtr<T>();
-}
-
+//! Tries to obtain an intrusive pointer for an object that may had
+//! already lost all of its references and, thus, is about to be deleted.
+/*!
+ * You may call this method at any time provided that you have a valid
+ * raw pointer to an object. The call either returns an intrusive pointer
+ * for the object (thus ensuring that the object won't be destroyed until
+ * you're holding this pointer) or NULL indicating that the last reference
+ * had already been lost and the object is on its way to heavens.
+ * All these steps happen atomically.
+ *
+ * Under all circumstances it is caller's responsibility the make sure that
+ * the object is not destroyed during the call to #DangerousGetPtr.
+ * Typically this is achieved by keeping a (lock-protected) collection of
+ * raw pointers, taking a lock in object's destructor, and unregistering
+ * its raw pointer from the collection there.
+ */
+
+template <class T>
+Y_FORCE_INLINE TIntrusivePtr<T> DangerousGetPtr(T* object)
+{
+ return object->TryRef()
+ ? TIntrusivePtr<T>(object, false)
+ : TIntrusivePtr<T>();
+}
+
////////////////////////////////////////////////////////////////////////////////
template <class T, class U>
@@ -272,7 +272,7 @@ bool operator==(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<U>& rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs.Get() == rhs.Get();
}
@@ -281,7 +281,7 @@ bool operator!=(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<U>& rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs.Get() != rhs.Get();
}
@@ -290,7 +290,7 @@ bool operator==(const TIntrusivePtr<T>& lhs, U* rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs.Get() == rhs;
}
@@ -299,7 +299,7 @@ bool operator!=(const TIntrusivePtr<T>& lhs, U* rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs.Get() != rhs;
}
@@ -308,7 +308,7 @@ bool operator==(T* lhs, const TIntrusivePtr<U>& rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs == rhs.Get();
}
@@ -317,7 +317,7 @@ bool operator!=(T* lhs, const TIntrusivePtr<U>& rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs != rhs.Get();
}
diff --git a/library/cpp/yt/memory/new-inl.h b/library/cpp/yt/memory/new-inl.h
index cf6e585da3..0a84818516 100644
--- a/library/cpp/yt/memory/new-inl.h
+++ b/library/cpp/yt/memory/new-inl.h
@@ -10,87 +10,87 @@ namespace NYT {
////////////////////////////////////////////////////////////////////////////////
-struct TRefCountedCookieHolder
-{
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- TRefCountedTypeCookie Cookie = NullRefCountedTypeCookie;
-
- void InitializeTracking(TRefCountedTypeCookie cookie)
- {
- YT_ASSERT(Cookie == NullRefCountedTypeCookie);
- Cookie = cookie;
- TRefCountedTrackerFacade::AllocateInstance(Cookie);
- }
-
- ~TRefCountedCookieHolder()
- {
- if (Cookie != NullRefCountedTypeCookie) {
- TRefCountedTrackerFacade::FreeInstance(Cookie);
- }
- }
-#endif
-};
-
+struct TRefCountedCookieHolder
+{
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ TRefCountedTypeCookie Cookie = NullRefCountedTypeCookie;
+
+ void InitializeTracking(TRefCountedTypeCookie cookie)
+ {
+ YT_ASSERT(Cookie == NullRefCountedTypeCookie);
+ Cookie = cookie;
+ TRefCountedTrackerFacade::AllocateInstance(Cookie);
+ }
+
+ ~TRefCountedCookieHolder()
+ {
+ if (Cookie != NullRefCountedTypeCookie) {
+ TRefCountedTrackerFacade::FreeInstance(Cookie);
+ }
+ }
+#endif
+};
+
template <class T>
-struct TRefCountedWrapper final
- : public T
- , public TRefTracked<T>
-{
- template <class... TArgs>
- explicit TRefCountedWrapper(TArgs&&... args)
- : T(std::forward<TArgs>(args)...)
- { }
-
- ~TRefCountedWrapper() = default;
-
+struct TRefCountedWrapper final
+ : public T
+ , public TRefTracked<T>
+{
+ template <class... TArgs>
+ explicit TRefCountedWrapper(TArgs&&... args)
+ : T(std::forward<TArgs>(args)...)
+ { }
+
+ ~TRefCountedWrapper() = default;
+
void DestroyRefCounted() override
- {
- T::DestroyRefCountedImpl(this);
- }
-};
-
-template <class T, class TDeleter>
-class TRefCountedWrapperWithDeleter final
- : public T
- , public TRefTracked<T>
-{
-public:
- template <class... TArgs>
- explicit TRefCountedWrapperWithDeleter(const TDeleter& deleter, TArgs&&... args)
- : T(std::forward<TArgs>(args)...)
- , Deleter_(deleter)
- { }
-
- ~TRefCountedWrapperWithDeleter() = default;
-
+ {
+ T::DestroyRefCountedImpl(this);
+ }
+};
+
+template <class T, class TDeleter>
+class TRefCountedWrapperWithDeleter final
+ : public T
+ , public TRefTracked<T>
+{
+public:
+ template <class... TArgs>
+ explicit TRefCountedWrapperWithDeleter(const TDeleter& deleter, TArgs&&... args)
+ : T(std::forward<TArgs>(args)...)
+ , Deleter_(deleter)
+ { }
+
+ ~TRefCountedWrapperWithDeleter() = default;
+
void DestroyRefCounted() override
- {
- Deleter_(this);
- }
-
-private:
- TDeleter Deleter_;
-};
-
-template <class T>
-struct TRefCountedWrapperWithCookie final
- : public T
- , public TRefCountedCookieHolder
-{
- template <class... TArgs>
- explicit TRefCountedWrapperWithCookie(TArgs&&... args)
- : T(std::forward<TArgs>(args)...)
- { }
-
- ~TRefCountedWrapperWithCookie() = default;
-
+ {
+ Deleter_(this);
+ }
+
+private:
+ TDeleter Deleter_;
+};
+
+template <class T>
+struct TRefCountedWrapperWithCookie final
+ : public T
+ , public TRefCountedCookieHolder
+{
+ template <class... TArgs>
+ explicit TRefCountedWrapperWithCookie(TArgs&&... args)
+ : T(std::forward<TArgs>(args)...)
+ { }
+
+ ~TRefCountedWrapperWithCookie() = default;
+
void DestroyRefCounted() override
- {
- T::DestroyRefCountedImpl(this);
- }
-};
+ {
+ T::DestroyRefCountedImpl(this);
+ }
+};
-namespace NDetail {
+namespace NDetail {
Y_FORCE_INLINE void* AllignedMalloc(size_t size, size_t allignment)
{
@@ -115,180 +115,180 @@ Y_FORCE_INLINE auto CustomInitialize(T* ptr) -> decltype(&T::InitializeRefCounte
ptr->InitializeRefCounted();
}
-template <class T, class... As>
-Y_FORCE_INLINE T* NewEpilogue(void* ptr, As&& ... args)
-{
- try {
- auto* instance = static_cast<T*>(ptr);
- new (instance) T(std::forward<As>(args)...);
+template <class T, class... As>
+Y_FORCE_INLINE T* NewEpilogue(void* ptr, As&& ... args)
+{
+ try {
+ auto* instance = static_cast<T*>(ptr);
+ new (instance) T(std::forward<As>(args)...);
CustomInitialize(instance);
- return instance;
- } catch (const std::exception& ex) {
- // Do not forget to free the memory.
- TFreeMemory<T>::Do(ptr);
- throw;
- }
-}
-
-template <class T, bool = std::is_base_of_v<TRefCountedBase, T>>
-struct TConstructHelper
-{
- static constexpr size_t RefCounterSpace = (sizeof(TRefCounter) + alignof(T) - 1) & ~(alignof(T) - 1);
- static constexpr size_t RefCounterOffset = RefCounterSpace - sizeof(TRefCounter);
- static constexpr size_t Size = RefCounterSpace + sizeof(T);
- static constexpr size_t Alignment = alignof(T);
-
- template <class... As>
- Y_FORCE_INLINE static T* Construct(void* ptr, As&&... args)
- {
- auto* refCounter = reinterpret_cast<TRefCounter*>(static_cast<char*>(ptr) + RefCounterOffset);
- new (refCounter) TRefCounter();
- auto* object = reinterpret_cast<T*>(refCounter + 1);
- if constexpr (std::is_constructible_v<T, As...>) {
- new(object) T(std::forward<As>(args)...);
- } else {
- new(object) T{std::forward<As>(args)...};
- }
- CustomInitialize(object);
- return object;
- }
-};
-
-template <class T>
-struct TConstructHelper<T, true>
-{
- static constexpr size_t Size = sizeof(TRefCountedWrapper<T>);
- static constexpr size_t Alignment = alignof(TRefCountedWrapper<T>);
-
- template <class... As>
- Y_FORCE_INLINE static TRefCountedWrapper<T>* Construct(void* ptr, As&&... args)
- {
- using TDerived = TRefCountedWrapper<T>;
- auto* object = new(static_cast<TDerived*>(ptr)) TDerived(std::forward<As>(args)...);
- CustomInitialize(object);
- return object;
- }
-};
-
+ return instance;
+ } catch (const std::exception& ex) {
+ // Do not forget to free the memory.
+ TFreeMemory<T>::Do(ptr);
+ throw;
+ }
+}
+
+template <class T, bool = std::is_base_of_v<TRefCountedBase, T>>
+struct TConstructHelper
+{
+ static constexpr size_t RefCounterSpace = (sizeof(TRefCounter) + alignof(T) - 1) & ~(alignof(T) - 1);
+ static constexpr size_t RefCounterOffset = RefCounterSpace - sizeof(TRefCounter);
+ static constexpr size_t Size = RefCounterSpace + sizeof(T);
+ static constexpr size_t Alignment = alignof(T);
+
+ template <class... As>
+ Y_FORCE_INLINE static T* Construct(void* ptr, As&&... args)
+ {
+ auto* refCounter = reinterpret_cast<TRefCounter*>(static_cast<char*>(ptr) + RefCounterOffset);
+ new (refCounter) TRefCounter();
+ auto* object = reinterpret_cast<T*>(refCounter + 1);
+ if constexpr (std::is_constructible_v<T, As...>) {
+ new(object) T(std::forward<As>(args)...);
+ } else {
+ new(object) T{std::forward<As>(args)...};
+ }
+ CustomInitialize(object);
+ return object;
+ }
+};
+
+template <class T>
+struct TConstructHelper<T, true>
+{
+ static constexpr size_t Size = sizeof(TRefCountedWrapper<T>);
+ static constexpr size_t Alignment = alignof(TRefCountedWrapper<T>);
+
+ template <class... As>
+ Y_FORCE_INLINE static TRefCountedWrapper<T>* Construct(void* ptr, As&&... args)
+ {
+ using TDerived = TRefCountedWrapper<T>;
+ auto* object = new(static_cast<TDerived*>(ptr)) TDerived(std::forward<As>(args)...);
+ CustomInitialize(object);
+ return object;
+ }
+};
+
template <class T, class... As>
-Y_FORCE_INLINE TIntrusivePtr<T> SafeConstruct(void* ptr, As&&... args)
+Y_FORCE_INLINE TIntrusivePtr<T> SafeConstruct(void* ptr, As&&... args)
{
try {
- auto* instance = TConstructHelper<T>::Construct(ptr, std::forward<As>(args)...);
- return TIntrusivePtr<T>(instance, false);
+ auto* instance = TConstructHelper<T>::Construct(ptr, std::forward<As>(args)...);
+ return TIntrusivePtr<T>(instance, false);
} catch (const std::exception& ex) {
// Do not forget to free the memory.
- TFreeMemory<T>::Do(ptr);
+ TFreeMemory<T>::Do(ptr);
throw;
}
}
-template <size_t Size, size_t Alignment>
-void* AllocateConstSizeAligned()
-{
- if (Alignment <= 16) {
- return NYTAlloc::AllocateConstSize<Size>();
- } else {
+template <size_t Size, size_t Alignment>
+void* AllocateConstSizeAligned()
+{
+ if (Alignment <= 16) {
+ return NYTAlloc::AllocateConstSize<Size>();
+ } else {
return AllignedMalloc(Size, Alignment);
- }
-}
-
+ }
+}
+
} // namespace NDetail
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, class... As, class>
-Y_FORCE_INLINE TIntrusivePtr<T> New(
- As&&... args)
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class... As, class>
+Y_FORCE_INLINE TIntrusivePtr<T> New(
+ As&&... args)
+{
+ void* ptr = NDetail::AllocateConstSizeAligned<
+ NDetail::TConstructHelper<T>::Size,
+ NDetail::TConstructHelper<T>::Alignment>();
+
+ return NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
+}
+
+template <class T, class... As, class>
+Y_FORCE_INLINE TIntrusivePtr<T> New(
+ typename T::TAllocator* allocator,
+ As&&... args)
{
- void* ptr = NDetail::AllocateConstSizeAligned<
- NDetail::TConstructHelper<T>::Size,
- NDetail::TConstructHelper<T>::Alignment>();
-
- return NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
-}
-
-template <class T, class... As, class>
-Y_FORCE_INLINE TIntrusivePtr<T> New(
- typename T::TAllocator* allocator,
- As&&... args)
-{
- auto* ptr = allocator->Allocate(NDetail::TConstructHelper<T>::Size);
- if (!ptr) {
- return nullptr;
- }
- return NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
+ auto* ptr = allocator->Allocate(NDetail::TConstructHelper<T>::Size);
+ if (!ptr) {
+ return nullptr;
+ }
+ return NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
}
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, class... As, class>
-Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class... As, class>
+Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
size_t extraSpaceSize,
As&&... args)
{
auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize;
- void* ptr = nullptr;
-
+ void* ptr = nullptr;
+
if (NYT::NDetail::TConstructHelper<T>::Alignment <= 16) {
- ptr = NYTAlloc::Allocate(totalSize);
- } else {
+ ptr = NYTAlloc::Allocate(totalSize);
+ } else {
ptr = NYT::NDetail::AllignedMalloc(totalSize, NYT::NDetail::TConstructHelper<T>::Alignment);
- }
-
+ }
+
return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
-}
-
-template <class T, class... As, class>
-Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
- typename T::TAllocator* allocator,
- size_t extraSpaceSize,
- As&&... args)
-{
+}
+
+template <class T, class... As, class>
+Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
+ typename T::TAllocator* allocator,
+ size_t extraSpaceSize,
+ As&&... args)
+{
auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize;
- auto* ptr = allocator->Allocate(totalSize);
- if (!ptr) {
- return nullptr;
- }
+ auto* ptr = allocator->Allocate(totalSize);
+ if (!ptr) {
+ return nullptr;
+ }
return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Support for polymorphic only
-template <class T, class TDeleter, class... As>
-Y_FORCE_INLINE TIntrusivePtr<T> NewWithDelete(const TDeleter& deleter, As&&... args)
-{
- using TWrapper = TRefCountedWrapperWithDeleter<T, TDeleter>;
- void* ptr = NDetail::AllocateConstSizeAligned<sizeof(TWrapper), alignof(TWrapper)>();
-
- auto* instance = NDetail::NewEpilogue<TWrapper>(
- ptr,
- deleter,
- std::forward<As>(args)...);
-
- return TIntrusivePtr<T>(instance, false);
}
-////////////////////////////////////////////////////////////////////////////////
-
+////////////////////////////////////////////////////////////////////////////////
+
+// Support for polymorphic only
+template <class T, class TDeleter, class... As>
+Y_FORCE_INLINE TIntrusivePtr<T> NewWithDelete(const TDeleter& deleter, As&&... args)
+{
+ using TWrapper = TRefCountedWrapperWithDeleter<T, TDeleter>;
+ void* ptr = NDetail::AllocateConstSizeAligned<sizeof(TWrapper), alignof(TWrapper)>();
+
+ auto* instance = NDetail::NewEpilogue<TWrapper>(
+ ptr,
+ deleter,
+ std::forward<As>(args)...);
+
+ return TIntrusivePtr<T>(instance, false);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
template <class T, class TTag, int Counter, class... As>
Y_FORCE_INLINE TIntrusivePtr<T> NewWithLocation(
const TSourceLocation& location,
As&&... args)
{
- using TWrapper = TRefCountedWrapperWithCookie<T>;
- void* ptr = NDetail::AllocateConstSizeAligned<sizeof(TWrapper), alignof(TWrapper)>();
-
- auto* instance = NDetail::NewEpilogue<TWrapper>(ptr, std::forward<As>(args)...);
-
+ using TWrapper = TRefCountedWrapperWithCookie<T>;
+ void* ptr = NDetail::AllocateConstSizeAligned<sizeof(TWrapper), alignof(TWrapper)>();
+
+ auto* instance = NDetail::NewEpilogue<TWrapper>(ptr, std::forward<As>(args)...);
+
#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- instance->InitializeTracking(GetRefCountedTypeCookieWithLocation<T, TTag, Counter>(location));
+ instance->InitializeTracking(GetRefCountedTypeCookieWithLocation<T, TTag, Counter>(location));
#else
- Y_UNUSED(location);
+ Y_UNUSED(location);
#endif
-
- return TIntrusivePtr<T>(instance, false);
+
+ return TIntrusivePtr<T>(instance, false);
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/new.h b/library/cpp/yt/memory/new.h
index 1b448df993..2db45e0465 100644
--- a/library/cpp/yt/memory/new.h
+++ b/library/cpp/yt/memory/new.h
@@ -1,10 +1,10 @@
#pragma once
-#include "intrusive_ptr.h"
-#include "ref_tracked.h"
+#include "intrusive_ptr.h"
+#include "ref_tracked.h"
#include <library/cpp/yt/misc/source_location.h>
-
+
#include <util/system/defaults.h>
namespace NYT {
@@ -65,47 +65,47 @@ namespace NYT {
////////////////////////////////////////////////////////////////////////////////
-template <class T, class = void>
-struct THasAllocator
-{
- using TFalse = void;
-};
-
-template <class T>
+template <class T, class = void>
+struct THasAllocator
+{
+ using TFalse = void;
+};
+
+template <class T>
struct THasAllocator<T, std::void_t<typename T::TAllocator>>
-{
- using TTrue = void;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
+{
+ using TTrue = void;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
//! Allocates a new instance of |T|.
-template <class T, class... As, class = typename THasAllocator<T>::TFalse>
+template <class T, class... As, class = typename THasAllocator<T>::TFalse>
TIntrusivePtr<T> New(As&&... args);
-template <class T, class... As, class = typename THasAllocator<T>::TTrue>
-TIntrusivePtr<T> New(typename T::TAllocator* allocator, As&&... args);
-
-//! Allocates an instance of |T| with additional storage of #extraSpaceSize bytes.
-template <class T, class... As, class = typename THasAllocator<T>::TFalse>
-TIntrusivePtr<T> NewWithExtraSpace(size_t extraSpaceSize, As&&... args);
-
-template <class T, class... As, class = typename THasAllocator<T>::TTrue>
-TIntrusivePtr<T> NewWithExtraSpace(typename T::TAllocator* allocator, size_t extraSpaceSize, As&&... args);
-
-//! Allocates a new instance of |T| with user deleter.
-template <class T, class TDeleter, class... As>
-TIntrusivePtr<T> NewWithDelete(const TDeleter& deleter, As&&... args);
-
+template <class T, class... As, class = typename THasAllocator<T>::TTrue>
+TIntrusivePtr<T> New(typename T::TAllocator* allocator, As&&... args);
+
+//! Allocates an instance of |T| with additional storage of #extraSpaceSize bytes.
+template <class T, class... As, class = typename THasAllocator<T>::TFalse>
+TIntrusivePtr<T> NewWithExtraSpace(size_t extraSpaceSize, As&&... args);
+
+template <class T, class... As, class = typename THasAllocator<T>::TTrue>
+TIntrusivePtr<T> NewWithExtraSpace(typename T::TAllocator* allocator, size_t extraSpaceSize, As&&... args);
+
+//! Allocates a new instance of |T| with user deleter.
+template <class T, class TDeleter, class... As>
+TIntrusivePtr<T> NewWithDelete(const TDeleter& deleter, As&&... args);
+
//! Allocates a new instance of |T|.
//! The allocation is additionally marked with #location.
template <class T, class TTag, int Counter, class... As>
-TIntrusivePtr<T> NewWithLocation(const TSourceLocation& location, As&&... args);
+TIntrusivePtr<T> NewWithLocation(const TSourceLocation& location, As&&... args);
//! Enables calling #New and co for types with private ctors.
#define DECLARE_NEW_FRIEND() \
- template <class DECLARE_NEW_FRIEND_T> \
- friend struct NYT::TRefCountedWrapper;
+ template <class DECLARE_NEW_FRIEND_T> \
+ friend struct NYT::TRefCountedWrapper;
////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/range.h b/library/cpp/yt/memory/range.h
index 49ca05a61e..6c71aa9496 100644
--- a/library/cpp/yt/memory/range.h
+++ b/library/cpp/yt/memory/range.h
@@ -187,7 +187,7 @@ public:
TRange<T> Slice(size_t startOffset, size_t endOffset) const
{
- YT_ASSERT(startOffset <= endOffset && endOffset <= Size());
+ YT_ASSERT(startOffset <= endOffset && endOffset <= Size());
return TRange<T>(Begin() + startOffset, endOffset - startOffset);
}
@@ -361,7 +361,7 @@ public:
using TRange<T>::Front;
using TRange<T>::Back;
using TRange<T>::operator[];
-
+
iterator Begin() const
{
return const_cast<T*>(this->Data_);
@@ -402,12 +402,12 @@ public:
return Begin()[this->Length_ - 1];
}
- TMutableRange<T> Slice(size_t startOffset, size_t endOffset) const
- {
- YT_ASSERT(startOffset <= endOffset && endOffset <= this->Size());
- return TMutableRange<T>(Begin() + startOffset, endOffset - startOffset);
- }
-
+ TMutableRange<T> Slice(size_t startOffset, size_t endOffset) const
+ {
+ YT_ASSERT(startOffset <= endOffset && endOffset <= this->Size());
+ return TMutableRange<T>(Begin() + startOffset, endOffset - startOffset);
+ }
+
TMutableRange<T> Slice(T* begin, T* end) const
{
YT_ASSERT(begin >= Begin());
diff --git a/library/cpp/yt/memory/ref.cpp b/library/cpp/yt/memory/ref.cpp
index 10d253f16a..e8ff42e976 100644
--- a/library/cpp/yt/memory/ref.cpp
+++ b/library/cpp/yt/memory/ref.cpp
@@ -20,87 +20,87 @@ char MutableEmptyRefData[1] = {0};
////////////////////////////////////////////////////////////////////////////////
-class TBlobHolder
- : public TRefCounted
-{
-public:
- explicit TBlobHolder(TBlob&& blob)
- : Blob_(std::move(blob))
- { }
-
-private:
- const TBlob Blob_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TStringHolder
- : public TRefCounted
-{
-public:
- TStringHolder(TString&& string, TRefCountedTypeCookie cookie)
- : String_(std::move(string))
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- , Cookie_(cookie)
-#endif
- {
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- TRefCountedTrackerFacade::AllocateTagInstance(Cookie_);
- TRefCountedTrackerFacade::AllocateSpace(Cookie_, String_.length());
-#endif
- }
- ~TStringHolder()
- {
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- TRefCountedTrackerFacade::FreeTagInstance(Cookie_);
- TRefCountedTrackerFacade::FreeSpace(Cookie_, String_.length());
-#endif
- }
-
+class TBlobHolder
+ : public TRefCounted
+{
+public:
+ explicit TBlobHolder(TBlob&& blob)
+ : Blob_(std::move(blob))
+ { }
+
+private:
+ const TBlob Blob_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TStringHolder
+ : public TRefCounted
+{
+public:
+ TStringHolder(TString&& string, TRefCountedTypeCookie cookie)
+ : String_(std::move(string))
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ , Cookie_(cookie)
+#endif
+ {
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ TRefCountedTrackerFacade::AllocateTagInstance(Cookie_);
+ TRefCountedTrackerFacade::AllocateSpace(Cookie_, String_.length());
+#endif
+ }
+ ~TStringHolder()
+ {
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ TRefCountedTrackerFacade::FreeTagInstance(Cookie_);
+ TRefCountedTrackerFacade::FreeSpace(Cookie_, String_.length());
+#endif
+ }
+
const TString& String() const
{
return String_;
}
-private:
- const TString String_;
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- const TRefCountedTypeCookie Cookie_;
-#endif
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
+private:
+ const TString String_;
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ const TRefCountedTypeCookie Cookie_;
+#endif
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
template <class TDerived>
class TAllocationHolderBase
- : public TRefCounted
-{
-public:
+ : public TRefCounted
+{
+public:
TAllocationHolderBase(size_t size, TRefCountedTypeCookie cookie)
- : Size_(size)
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- , Cookie_(cookie)
-#endif
+ : Size_(size)
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ , Cookie_(cookie)
+#endif
{ }
~TAllocationHolderBase()
- {
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- TRefCountedTrackerFacade::FreeTagInstance(Cookie_);
- TRefCountedTrackerFacade::FreeSpace(Cookie_, Size_);
-#endif
- }
-
- TMutableRef GetRef()
- {
+ {
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ TRefCountedTrackerFacade::FreeTagInstance(Cookie_);
+ TRefCountedTrackerFacade::FreeSpace(Cookie_, Size_);
+#endif
+ }
+
+ TMutableRef GetRef()
+ {
return TMutableRef(static_cast<TDerived*>(this)->GetBegin(), Size_);
- }
-
+ }
+
protected:
- const size_t Size_;
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
- const TRefCountedTypeCookie Cookie_;
-#endif
+ const size_t Size_;
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+ const TRefCountedTypeCookie Cookie_;
+#endif
void Initialize(bool initializeStorage)
{
@@ -112,16 +112,16 @@ protected:
TRefCountedTrackerFacade::AllocateSpace(Cookie_, Size_);
#endif
}
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TDefaultAllocationHolder
- : public TAllocationHolderBase<TDefaultAllocationHolder>
- , public TWithExtraSpace<TDefaultAllocationHolder>
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TDefaultAllocationHolder
+ : public TAllocationHolderBase<TDefaultAllocationHolder>
+ , public TWithExtraSpace<TDefaultAllocationHolder>
{
public:
- TDefaultAllocationHolder(size_t size, bool initializeStorage, TRefCountedTypeCookie cookie)
+ TDefaultAllocationHolder(size_t size, bool initializeStorage, TRefCountedTypeCookie cookie)
: TAllocationHolderBase(size, cookie)
{
Initialize(initializeStorage);
@@ -206,12 +206,12 @@ TSharedRef TSharedRef::MakeCopy(TRef ref, TRefCountedTypeCookie tagCookie)
if (!ref) {
return {};
}
- if (ref.Empty()) {
+ if (ref.Empty()) {
return TSharedRef::MakeEmpty();
- }
- auto result = TSharedMutableRef::Allocate(ref.Size(), false, tagCookie);
- ::memcpy(result.Begin(), ref.Begin(), ref.Size());
- return result;
+ }
+ auto result = TSharedMutableRef::Allocate(ref.Size(), false, tagCookie);
+ ::memcpy(result.Begin(), ref.Begin(), ref.Size());
+ return result;
}
std::vector<TSharedRef> TSharedRef::Split(size_t partSize) const
@@ -235,7 +235,7 @@ std::vector<TSharedRef> TSharedRef::Split(size_t partSize) const
TSharedMutableRef TSharedMutableRef::Allocate(size_t size, bool initializeStorage, TRefCountedTypeCookie tagCookie)
{
- auto holder = NewWithExtraSpace<TDefaultAllocationHolder>(size, size, initializeStorage, tagCookie);
+ auto holder = NewWithExtraSpace<TDefaultAllocationHolder>(size, size, initializeStorage, tagCookie);
auto ref = holder->GetRef();
return TSharedMutableRef(ref, std::move(holder));
}
@@ -259,12 +259,12 @@ TSharedMutableRef TSharedMutableRef::MakeCopy(TRef ref, TRefCountedTypeCookie ta
if (!ref) {
return {};
}
- if (ref.Empty()) {
+ if (ref.Empty()) {
return TSharedMutableRef::MakeEmpty();
}
- auto result = Allocate(ref.Size(), false, tagCookie);
- ::memcpy(result.Begin(), ref.Begin(), ref.Size());
- return result;
+ auto result = Allocate(ref.Size(), false, tagCookie);
+ ::memcpy(result.Begin(), ref.Begin(), ref.Size());
+ return result;
}
////////////////////////////////////////////////////////////////////////////////
@@ -295,13 +295,13 @@ size_t GetPageSize()
return PageSize;
}
-size_t RoundUpToPage(size_t bytes)
-{
- static const size_t PageSize = NSystemInfo::GetPageSize();
+size_t RoundUpToPage(size_t bytes)
+{
+ static const size_t PageSize = NSystemInfo::GetPageSize();
YT_ASSERT((PageSize & (PageSize - 1)) == 0);
- return (bytes + PageSize - 1) & (~(PageSize - 1));
-}
-
+ return (bytes + PageSize - 1) & (~(PageSize - 1));
+}
+
size_t GetByteSize(const TSharedRefArray& array)
{
size_t size = 0;
@@ -362,7 +362,7 @@ TMutableRef TSharedRefArrayBuilder::AllocateAndAdd(size_t size)
YT_ASSERT(CurrentAllocationPtr_ + size <= Impl_->GetBeginAllocationPtr() + AllocationCapacity_);
TMutableRef ref(CurrentAllocationPtr_, size);
CurrentAllocationPtr_ += size;
- TRefCountedPtr holder(Impl_.Get(), false);
+ TRefCountedPtr holder(Impl_.Get(), false);
TSharedRef sharedRef(ref, std::move(holder));
Add(std::move(sharedRef));
return ref;
diff --git a/library/cpp/yt/memory/ref.h b/library/cpp/yt/memory/ref.h
index 3fde728e0f..73d19d9013 100644
--- a/library/cpp/yt/memory/ref.h
+++ b/library/cpp/yt/memory/ref.h
@@ -366,8 +366,8 @@ TString ToString(const TSharedRef& ref);
TString ToString(const TSharedMutableRef& ref);
size_t GetPageSize();
-size_t RoundUpToPage(size_t bytes);
-
+size_t RoundUpToPage(size_t bytes);
+
size_t GetByteSize(TRef ref);
size_t GetByteSize(const TSharedRefArray& array);
template <class T>
@@ -375,8 +375,8 @@ size_t GetByteSize(TRange<T> parts);
template <class T>
size_t GetByteSize(const std::vector<T>& parts);
-////////////////////////////////////////////////////////////////////////////////
-
+////////////////////////////////////////////////////////////////////////////////
+
} // namespace NYT
#define REF_INL_H_
diff --git a/library/cpp/yt/memory/ref_counted-inl.h b/library/cpp/yt/memory/ref_counted-inl.h
index 6b9bfeca8c..e6d64fec18 100644
--- a/library/cpp/yt/memory/ref_counted-inl.h
+++ b/library/cpp/yt/memory/ref_counted-inl.h
@@ -8,269 +8,269 @@ namespace NYT {
////////////////////////////////////////////////////////////////////////////////
-constexpr uint16_t PtrBits = 48;
-constexpr uintptr_t PtrMask = (1ULL << PtrBits) - 1;
-
-template <class T>
-Y_FORCE_INLINE char* PackPointer(T* ptr, uint16_t data)
+constexpr uint16_t PtrBits = 48;
+constexpr uintptr_t PtrMask = (1ULL << PtrBits) - 1;
+
+template <class T>
+Y_FORCE_INLINE char* PackPointer(T* ptr, uint16_t data)
{
- return reinterpret_cast<char*>((static_cast<uintptr_t>(data) << PtrBits) | reinterpret_cast<uintptr_t>(ptr));
+ return reinterpret_cast<char*>((static_cast<uintptr_t>(data) << PtrBits) | reinterpret_cast<uintptr_t>(ptr));
}
-template <class T>
-struct TPackedPointer
-{
- uint16_t Data;
- T* Ptr;
-};
-
-template <class T>
-Y_FORCE_INLINE TPackedPointer<T> UnpackPointer(void* packedPtr)
-{
- auto castedPtr = reinterpret_cast<uintptr_t>(packedPtr);
- return {static_cast<uint16_t>(castedPtr >> PtrBits), reinterpret_cast<T*>(castedPtr & PtrMask)};
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, class = void>
-struct TMemoryReleaser
+template <class T>
+struct TPackedPointer
+{
+ uint16_t Data;
+ T* Ptr;
+};
+
+template <class T>
+Y_FORCE_INLINE TPackedPointer<T> UnpackPointer(void* packedPtr)
+{
+ auto castedPtr = reinterpret_cast<uintptr_t>(packedPtr);
+ return {static_cast<uint16_t>(castedPtr >> PtrBits), reinterpret_cast<T*>(castedPtr & PtrMask)};
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class = void>
+struct TMemoryReleaser
{
- static void Do(void* ptr, uint16_t /*offset*/)
- {
- TFreeMemory<T>::Do(ptr);
- }
-};
-
-using TDeleter = void (*)(void*);
-
-void ScheduleObjectDeletion(void* ptr, TDeleter deleter);
-
-template <class T>
+ static void Do(void* ptr, uint16_t /*offset*/)
+ {
+ TFreeMemory<T>::Do(ptr);
+ }
+};
+
+using TDeleter = void (*)(void*);
+
+void ScheduleObjectDeletion(void* ptr, TDeleter deleter);
+
+template <class T>
struct TMemoryReleaser<T, std::enable_if_t<T::EnableHazard>>
-{
- static void Do(void* ptr, uint16_t offset)
- {
- // Base pointer is used in HazardPtr as the identity of object.
- auto* basePtr = PackPointer(static_cast<char*>(ptr) + offset, offset);
-
- ScheduleObjectDeletion(basePtr, [] (void* ptr) {
- // Base ptr and the beginning of allocated memory region may differ.
- auto [offset, basePtr] = UnpackPointer<char>(ptr);
- TFreeMemory<T>::Do(basePtr - offset);
- });
- }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-Y_FORCE_INLINE int TRefCounter::GetRefCount() const noexcept
-{
- return StrongCount_.load(std::memory_order_relaxed);
-}
-
-Y_FORCE_INLINE void TRefCounter::Ref() const noexcept
-{
+{
+ static void Do(void* ptr, uint16_t offset)
+ {
+ // Base pointer is used in HazardPtr as the identity of object.
+ auto* basePtr = PackPointer(static_cast<char*>(ptr) + offset, offset);
+
+ ScheduleObjectDeletion(basePtr, [] (void* ptr) {
+ // Base ptr and the beginning of allocated memory region may differ.
+ auto [offset, basePtr] = UnpackPointer<char>(ptr);
+ TFreeMemory<T>::Do(basePtr - offset);
+ });
+ }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+Y_FORCE_INLINE int TRefCounter::GetRefCount() const noexcept
+{
+ return StrongCount_.load(std::memory_order_relaxed);
+}
+
+Y_FORCE_INLINE void TRefCounter::Ref() const noexcept
+{
// It is safe to use relaxed here, since new reference is always created from another live reference.
- StrongCount_.fetch_add(1, std::memory_order_relaxed);
-
- YT_ASSERT(WeakCount_.load(std::memory_order_relaxed) > 0);
+ StrongCount_.fetch_add(1, std::memory_order_relaxed);
+
+ YT_ASSERT(WeakCount_.load(std::memory_order_relaxed) > 0);
}
-Y_FORCE_INLINE bool TRefCounter::TryRef() const noexcept
+Y_FORCE_INLINE bool TRefCounter::TryRef() const noexcept
{
- auto value = StrongCount_.load(std::memory_order_relaxed);
- YT_ASSERT(WeakCount_.load(std::memory_order_relaxed) > 0);
-
- while (value != 0 && !StrongCount_.compare_exchange_weak(value, value + 1));
- return value != 0;
-}
-
-Y_FORCE_INLINE bool TRefCounter::Unref() const
-{
- // We must properly synchronize last access to object with it destruction.
- // Otherwise compiler might reorder access to object past this decrement.
- //
- // See http://www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html#boost_atomic.usage_examples.example_reference_counters
- //
+ auto value = StrongCount_.load(std::memory_order_relaxed);
+ YT_ASSERT(WeakCount_.load(std::memory_order_relaxed) > 0);
+
+ while (value != 0 && !StrongCount_.compare_exchange_weak(value, value + 1));
+ return value != 0;
+}
+
+Y_FORCE_INLINE bool TRefCounter::Unref() const
+{
+ // We must properly synchronize last access to object with it destruction.
+ // Otherwise compiler might reorder access to object past this decrement.
+ //
+ // See http://www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html#boost_atomic.usage_examples.example_reference_counters
+ //
auto oldStrongCount = StrongCount_.fetch_sub(1, std::memory_order_release);
YT_ASSERT(oldStrongCount > 0);
- if (oldStrongCount == 1) {
- StrongCount_.load(std::memory_order_acquire);
- return true;
- } else {
- return false;
- }
-}
-
-Y_FORCE_INLINE int TRefCounter::GetWeakRefCount() const noexcept
-{
- return WeakCount_.load(std::memory_order_acquire);
-}
-
-Y_FORCE_INLINE void TRefCounter::WeakRef() const noexcept
-{
- auto oldWeakCount = WeakCount_.fetch_add(1, std::memory_order_relaxed);
- YT_ASSERT(oldWeakCount > 0);
+ if (oldStrongCount == 1) {
+ StrongCount_.load(std::memory_order_acquire);
+ return true;
+ } else {
+ return false;
+ }
}
-Y_FORCE_INLINE bool TRefCounter::WeakUnref() const
-{
- auto oldWeakCount = WeakCount_.fetch_sub(1, std::memory_order_release);
- YT_ASSERT(oldWeakCount > 0);
- if (oldWeakCount == 1) {
- WeakCount_.load(std::memory_order_acquire);
- return true;
- } else {
- return false;
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T, bool = std::is_base_of_v<TRefCountedBase, T>>
-struct TRefCountedHelper
+Y_FORCE_INLINE int TRefCounter::GetWeakRefCount() const noexcept
{
- static_assert(
- std::is_final_v<T>,
- "Ref-counted objects must be derived from TRefCountedBase or to be final");
-
- static constexpr size_t RefCounterSpace = (sizeof(TRefCounter) + alignof(T) - 1) & ~(alignof(T) - 1);
- static constexpr size_t RefCounterOffset = RefCounterSpace - sizeof(TRefCounter);
-
- Y_FORCE_INLINE static const TRefCounter* GetRefCounter(const T* obj)
- {
- return reinterpret_cast<const TRefCounter*>(obj) - 1;
- }
+ return WeakCount_.load(std::memory_order_acquire);
+}
+
+Y_FORCE_INLINE void TRefCounter::WeakRef() const noexcept
+{
+ auto oldWeakCount = WeakCount_.fetch_add(1, std::memory_order_relaxed);
+ YT_ASSERT(oldWeakCount > 0);
+}
+
+Y_FORCE_INLINE bool TRefCounter::WeakUnref() const
+{
+ auto oldWeakCount = WeakCount_.fetch_sub(1, std::memory_order_release);
+ YT_ASSERT(oldWeakCount > 0);
+ if (oldWeakCount == 1) {
+ WeakCount_.load(std::memory_order_acquire);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, bool = std::is_base_of_v<TRefCountedBase, T>>
+struct TRefCountedHelper
+{
+ static_assert(
+ std::is_final_v<T>,
+ "Ref-counted objects must be derived from TRefCountedBase or to be final");
+
+ static constexpr size_t RefCounterSpace = (sizeof(TRefCounter) + alignof(T) - 1) & ~(alignof(T) - 1);
+ static constexpr size_t RefCounterOffset = RefCounterSpace - sizeof(TRefCounter);
+
+ Y_FORCE_INLINE static const TRefCounter* GetRefCounter(const T* obj)
+ {
+ return reinterpret_cast<const TRefCounter*>(obj) - 1;
+ }
Y_FORCE_INLINE static void Destroy(const T* obj)
- {
- auto* refCounter = GetRefCounter(obj);
-
- // No virtual call when T is final.
- obj->~T();
-
- char* ptr = reinterpret_cast<char*>(const_cast<TRefCounter*>(refCounter));
-
- // Fast path. Weak refs cannot appear if there are neither strong nor weak refs.
- if (refCounter->GetWeakRefCount() == 1) {
- TMemoryReleaser<T>::Do(ptr - RefCounterOffset, RefCounterSpace);
- return;
- }
-
- if (refCounter->WeakUnref()) {
- TMemoryReleaser<T>::Do(ptr - RefCounterOffset, RefCounterSpace);
- }
- }
-
+ {
+ auto* refCounter = GetRefCounter(obj);
+
+ // No virtual call when T is final.
+ obj->~T();
+
+ char* ptr = reinterpret_cast<char*>(const_cast<TRefCounter*>(refCounter));
+
+ // Fast path. Weak refs cannot appear if there are neither strong nor weak refs.
+ if (refCounter->GetWeakRefCount() == 1) {
+ TMemoryReleaser<T>::Do(ptr - RefCounterOffset, RefCounterSpace);
+ return;
+ }
+
+ if (refCounter->WeakUnref()) {
+ TMemoryReleaser<T>::Do(ptr - RefCounterOffset, RefCounterSpace);
+ }
+ }
+
Y_FORCE_INLINE static void Deallocate(const T* obj)
- {
- char* ptr = reinterpret_cast<char*>(const_cast<TRefCounter*>(GetRefCounter(obj)));
- TMemoryReleaser<T>::Do(ptr - RefCounterOffset, RefCounterSpace);
- }
-};
-
-template <class T>
-struct TRefCountedHelper<T, true>
-{
- Y_FORCE_INLINE static const TRefCounter* GetRefCounter(const T* obj)
- {
- return obj;
- }
-
- Y_FORCE_INLINE static void Destroy(const TRefCountedBase* obj)
- {
- const_cast<TRefCountedBase*>(obj)->DestroyRefCounted();
- }
-
- Y_FORCE_INLINE static void Deallocate(const TRefCountedBase* obj)
- {
- auto* ptr = reinterpret_cast<void**>(const_cast<TRefCountedBase*>(obj));
- auto [offset, ptrToDeleter] = UnpackPointer<void(void*, uint16_t)>(*ptr);
-
- // The most derived type is erased here. So we cannot call TMemoryReleaser with derived type.
- ptrToDeleter(reinterpret_cast<char*>(ptr) - offset, offset);
- }
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
+ {
+ char* ptr = reinterpret_cast<char*>(const_cast<TRefCounter*>(GetRefCounter(obj)));
+ TMemoryReleaser<T>::Do(ptr - RefCounterOffset, RefCounterSpace);
+ }
+};
+
+template <class T>
+struct TRefCountedHelper<T, true>
+{
+ Y_FORCE_INLINE static const TRefCounter* GetRefCounter(const T* obj)
+ {
+ return obj;
+ }
+
+ Y_FORCE_INLINE static void Destroy(const TRefCountedBase* obj)
+ {
+ const_cast<TRefCountedBase*>(obj)->DestroyRefCounted();
+ }
+
+ Y_FORCE_INLINE static void Deallocate(const TRefCountedBase* obj)
+ {
+ auto* ptr = reinterpret_cast<void**>(const_cast<TRefCountedBase*>(obj));
+ auto [offset, ptrToDeleter] = UnpackPointer<void(void*, uint16_t)>(*ptr);
+
+ // The most derived type is erased here. So we cannot call TMemoryReleaser with derived type.
+ ptrToDeleter(reinterpret_cast<char*>(ptr) - offset, offset);
+ }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
Y_FORCE_INLINE const TRefCounter* GetRefCounter(const T* obj)
-{
- return TRefCountedHelper<T>::GetRefCounter(obj);
+{
+ return TRefCountedHelper<T>::GetRefCounter(obj);
}
-template <class T>
+template <class T>
Y_FORCE_INLINE void DestroyRefCounted(const T* obj)
{
- TRefCountedHelper<T>::Destroy(obj);
+ TRefCountedHelper<T>::Destroy(obj);
}
-template <class T>
+template <class T>
Y_FORCE_INLINE void DeallocateRefCounted(const T* obj)
-{
- TRefCountedHelper<T>::Deallocate(obj);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-Y_FORCE_INLINE void Ref(T* obj)
-{
- GetRefCounter(obj)->Ref();
-}
-
-template <class T>
-Y_FORCE_INLINE void Unref(T* obj)
-{
- if (GetRefCounter(obj)->Unref()) {
- DestroyRefCounted(obj);
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-Y_FORCE_INLINE void TRefCounted::Unref() const
{
- ::NYT::Unref(this);
+ TRefCountedHelper<T>::Deallocate(obj);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+Y_FORCE_INLINE void Ref(T* obj)
+{
+ GetRefCounter(obj)->Ref();
}
-Y_FORCE_INLINE void TRefCounted::WeakUnref() const
-{
- if (TRefCounter::WeakUnref()) {
- DeallocateRefCounted(this);
- }
-}
-
-
template <class T>
-void TRefCounted::DestroyRefCountedImpl(T* ptr)
+Y_FORCE_INLINE void Unref(T* obj)
{
- // No standard way to statically calculate the base offset even if T is final.
- // static_cast<TFinalDerived*>(virtualBasePtr) does not work.
-
- auto* basePtr = static_cast<TRefCountedBase*>(ptr);
- auto offset = reinterpret_cast<uintptr_t>(basePtr) - reinterpret_cast<uintptr_t>(ptr);
- auto* refCounter = GetRefCounter(ptr);
-
- // No virtual call when T is final.
- ptr->~T();
-
- // Fast path. Weak refs cannot appear if there are neither strong nor weak refs.
- if (refCounter->GetWeakRefCount() == 1) {
- TMemoryReleaser<T>::Do(ptr, offset);
- return;
- }
-
- YT_ASSERT(offset < std::numeric_limits<uint16_t>::max());
-
- auto* vTablePtr = reinterpret_cast<char**>(basePtr);
- *vTablePtr = PackPointer(&TMemoryReleaser<T>::Do, offset);
-
- if (refCounter->WeakUnref()) {
- TMemoryReleaser<T>::Do(ptr, offset);
- }
+ if (GetRefCounter(obj)->Unref()) {
+ DestroyRefCounted(obj);
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+Y_FORCE_INLINE void TRefCounted::Unref() const
+{
+ ::NYT::Unref(this);
+}
+
+Y_FORCE_INLINE void TRefCounted::WeakUnref() const
+{
+ if (TRefCounter::WeakUnref()) {
+ DeallocateRefCounted(this);
+ }
+}
+
+
+template <class T>
+void TRefCounted::DestroyRefCountedImpl(T* ptr)
+{
+ // No standard way to statically calculate the base offset even if T is final.
+ // static_cast<TFinalDerived*>(virtualBasePtr) does not work.
+
+ auto* basePtr = static_cast<TRefCountedBase*>(ptr);
+ auto offset = reinterpret_cast<uintptr_t>(basePtr) - reinterpret_cast<uintptr_t>(ptr);
+ auto* refCounter = GetRefCounter(ptr);
+
+ // No virtual call when T is final.
+ ptr->~T();
+
+ // Fast path. Weak refs cannot appear if there are neither strong nor weak refs.
+ if (refCounter->GetWeakRefCount() == 1) {
+ TMemoryReleaser<T>::Do(ptr, offset);
+ return;
+ }
+
+ YT_ASSERT(offset < std::numeric_limits<uint16_t>::max());
+
+ auto* vTablePtr = reinterpret_cast<char**>(basePtr);
+ *vTablePtr = PackPointer(&TMemoryReleaser<T>::Do, offset);
+
+ if (refCounter->WeakUnref()) {
+ TMemoryReleaser<T>::Do(ptr, offset);
+ }
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/ref_counted.h b/library/cpp/yt/memory/ref_counted.h
index cf03aedc1f..b683615b83 100644
--- a/library/cpp/yt/memory/ref_counted.h
+++ b/library/cpp/yt/memory/ref_counted.h
@@ -5,23 +5,23 @@
#include <library/cpp/yt/assert/assert.h>
#include <library/cpp/ytalloc/api/ytalloc.h>
-
+
#include <atomic>
namespace NYT {
////////////////////////////////////////////////////////////////////////////////
-//! A technical base class for ref-counted objects and promise states.
+//! A technical base class for ref-counted objects and promise states.
class TRefCountedBase
{
public:
TRefCountedBase() = default;
-
- // Make destructor protected
+
+ // Make destructor protected
virtual ~TRefCountedBase() noexcept = default;
- virtual void DestroyRefCounted() = 0;
+ virtual void DestroyRefCounted() = 0;
private:
TRefCountedBase(const TRefCountedBase&) = delete;
@@ -33,156 +33,156 @@ private:
////////////////////////////////////////////////////////////////////////////////
-template <class T, class = void>
-struct TFreeMemory
+template <class T, class = void>
+struct TFreeMemory
{
- static void Do(void* ptr)
- {
- NYTAlloc::FreeNonNull(ptr);
- }
-};
+ static void Do(void* ptr)
+ {
+ NYTAlloc::FreeNonNull(ptr);
+ }
+};
-template <class T>
+template <class T>
struct TFreeMemory<T, std::void_t<typename T::TAllocator>>
-{
- static void Do(void* ptr)
- {
- using TAllocator = typename T::TAllocator;
- TAllocator::Free(ptr);
- }
-};
+{
+ static void Do(void* ptr)
+ {
+ using TAllocator = typename T::TAllocator;
+ TAllocator::Free(ptr);
+ }
+};
-////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
class TRefCounter
-{
+{
public:
- //! Returns current number of strong references to the object.
+ //! Returns current number of strong references to the object.
/*!
* Note that you should never ever use this method in production code.
* This method is mainly for debugging purposes.
*/
int GetRefCount() const noexcept;
- //! Increments the strong reference counter.
- void Ref() const noexcept;
-
- //! Increments the strong reference counter if it is not null.
- bool TryRef() const noexcept;
-
- //! Decrements the strong reference counter.
- bool Unref() const;
-
- //! Returns current number of weak references to the object.
- int GetWeakRefCount() const noexcept;
-
- //! Increments the weak reference counter.
- void WeakRef() const noexcept;
-
- //! Decrements the weak reference counter.
- bool WeakUnref() const;
-
-private:
- mutable std::atomic<int> StrongCount_ = 1;
- mutable std::atomic<int> WeakCount_ = 1;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
+ //! Increments the strong reference counter.
+ void Ref() const noexcept;
+
+ //! Increments the strong reference counter if it is not null.
+ bool TryRef() const noexcept;
+
+ //! Decrements the strong reference counter.
+ bool Unref() const;
+
+ //! Returns current number of weak references to the object.
+ int GetWeakRefCount() const noexcept;
+
+ //! Increments the weak reference counter.
+ void WeakRef() const noexcept;
+
+ //! Decrements the weak reference counter.
+ bool WeakUnref() const;
+
+private:
+ mutable std::atomic<int> StrongCount_ = 1;
+ mutable std::atomic<int> WeakCount_ = 1;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
const TRefCounter* GetRefCounter(const T* obj);
-
-template <class T>
+
+template <class T>
void DestroyRefCounted(const T* obj);
-
-template <class T>
+
+template <class T>
void DeallocateRefCounted(const T* obj);
-
-////////////////////////////////////////////////////////////////////////////////
-
-// API
-
-template <class T>
-void Ref(T* obj);
-
-template <class T>
-void Unref(T* obj);
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct TRefCounted
- : public TRefCountedBase
- , public TRefCounter
-{
- void Unref() const;
-
- void WeakUnref() const;
-
- template <class T>
- static void DestroyRefCountedImpl(T* ptr);
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Forward declaration.
-template <class T>
-class TIntrusivePtr;
-
-using TRefCountedPtr = TIntrusivePtr<TRefCounted>;
-
-// A bunch of helpful macros that enable working with intrusive pointers to incomplete types.
-/*
- * Typically when you have a forward-declared type |T| and an instance
- * of |TIntrusivePtr<T>| you need the complete definition of |T| to work with
- * the pointer even if you're not actually using the members of |T|.
- * E.g. the dtor of |TIntrusivePtr<T>|, should you ever need it, must be able
- * to unref an instance of |T| and eventually destroy it.
- * This may force #inclusion of way more headers than really seems necessary.
- *
- * |DECLARE_REFCOUNTED_STRUCT|, |DECLARE_REFCOUNTED_CLASS|, and |DEFINE_REFCOUNTED_TYPE|
- * alleviate this issue by forcing TIntrusivePtr to work with the free-standing overloads
- * of |Ref| and |Unref| instead of their template version.
- * These overloads are declared together with the forward declaration of |T| and
- * are subsequently defined afterwards.
- */
-
-#define DECLARE_REFCOUNTED_TYPE(type) \
+
+////////////////////////////////////////////////////////////////////////////////
+
+// API
+
+template <class T>
+void Ref(T* obj);
+
+template <class T>
+void Unref(T* obj);
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TRefCounted
+ : public TRefCountedBase
+ , public TRefCounter
+{
+ void Unref() const;
+
+ void WeakUnref() const;
+
+ template <class T>
+ static void DestroyRefCountedImpl(T* ptr);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Forward declaration.
+template <class T>
+class TIntrusivePtr;
+
+using TRefCountedPtr = TIntrusivePtr<TRefCounted>;
+
+// A bunch of helpful macros that enable working with intrusive pointers to incomplete types.
+/*
+ * Typically when you have a forward-declared type |T| and an instance
+ * of |TIntrusivePtr<T>| you need the complete definition of |T| to work with
+ * the pointer even if you're not actually using the members of |T|.
+ * E.g. the dtor of |TIntrusivePtr<T>|, should you ever need it, must be able
+ * to unref an instance of |T| and eventually destroy it.
+ * This may force #inclusion of way more headers than really seems necessary.
+ *
+ * |DECLARE_REFCOUNTED_STRUCT|, |DECLARE_REFCOUNTED_CLASS|, and |DEFINE_REFCOUNTED_TYPE|
+ * alleviate this issue by forcing TIntrusivePtr to work with the free-standing overloads
+ * of |Ref| and |Unref| instead of their template version.
+ * These overloads are declared together with the forward declaration of |T| and
+ * are subsequently defined afterwards.
+ */
+
+#define DECLARE_REFCOUNTED_TYPE(type) \
using type ## Ptr = ::NYT::TIntrusivePtr<type>; \
- \
+ \
[[maybe_unused]] ATTRIBUTE_USED const ::NYT::TRefCounter* GetRefCounter(const type* obj); \
[[maybe_unused]] ATTRIBUTE_USED void DestroyRefCounted(const type* obj); \
[[maybe_unused]] ATTRIBUTE_USED void DeallocateRefCounted(const type* obj);
-
-//! Forward-declares a class type, defines an intrusive pointer for it, and finally
-//! declares Ref/Unref overloads. Use this macro in |public.h|-like files.
-#define DECLARE_REFCOUNTED_CLASS(type) \
- class type; \
- DECLARE_REFCOUNTED_TYPE(type)
-
-//! Forward-declares a struct type, defines an intrusive pointer for it, and finally
-//! declares Ref/Unref overloads. Use this macro in |public.h|-like files.
-#define DECLARE_REFCOUNTED_STRUCT(type) \
- struct type; \
- DECLARE_REFCOUNTED_TYPE(type)
-
-//! Provides implementations for Ref/Unref overloads. Use this macro right
-//! after the type's full definition.
-#define DEFINE_REFCOUNTED_TYPE(type) \
+
+//! Forward-declares a class type, defines an intrusive pointer for it, and finally
+//! declares Ref/Unref overloads. Use this macro in |public.h|-like files.
+#define DECLARE_REFCOUNTED_CLASS(type) \
+ class type; \
+ DECLARE_REFCOUNTED_TYPE(type)
+
+//! Forward-declares a struct type, defines an intrusive pointer for it, and finally
+//! declares Ref/Unref overloads. Use this macro in |public.h|-like files.
+#define DECLARE_REFCOUNTED_STRUCT(type) \
+ struct type; \
+ DECLARE_REFCOUNTED_TYPE(type)
+
+//! Provides implementations for Ref/Unref overloads. Use this macro right
+//! after the type's full definition.
+#define DEFINE_REFCOUNTED_TYPE(type) \
[[maybe_unused]] ATTRIBUTE_USED Y_FORCE_INLINE const ::NYT::TRefCounter* GetRefCounter(const type* obj) \
- { \
- return ::NYT::TRefCountedHelper<type>::GetRefCounter(obj); \
- } \
+ { \
+ return ::NYT::TRefCountedHelper<type>::GetRefCounter(obj); \
+ } \
[[maybe_unused]] ATTRIBUTE_USED Y_FORCE_INLINE void DestroyRefCounted(const type* obj) \
- { \
- ::NYT::TRefCountedHelper<type>::Destroy(obj); \
- } \
+ { \
+ ::NYT::TRefCountedHelper<type>::Destroy(obj); \
+ } \
[[maybe_unused]] ATTRIBUTE_USED Y_FORCE_INLINE void DeallocateRefCounted(const type* obj) \
- { \
- ::NYT::TRefCountedHelper<type>::Deallocate(obj); \
- }
-
-////////////////////////////////////////////////////////////////////////////////
-
+ { \
+ ::NYT::TRefCountedHelper<type>::Deallocate(obj); \
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
} // namespace NYT
#define REF_COUNTED_INL_H_
diff --git a/library/cpp/yt/memory/ref_tracked-inl.h b/library/cpp/yt/memory/ref_tracked-inl.h
index 438bd870a9..4bde72881d 100644
--- a/library/cpp/yt/memory/ref_tracked-inl.h
+++ b/library/cpp/yt/memory/ref_tracked-inl.h
@@ -1,49 +1,49 @@
-#ifndef REF_TRACKED_INL_H_
-#error "Direct inclusion of this file is not allowed, include ref_tracked.h"
-// For the sake of sane code completion.
-#include "ref_tracked.h"
-#endif
-
-namespace NYT {
-
-////////////////////////////////////////////////////////////////////////////////
-
-template <class T>
-TRefCountedTypeKey GetRefCountedTypeKey()
-{
- return &typeid(T);
-}
-
-template <class T>
-Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookie()
-{
- static std::atomic<TRefCountedTypeCookie> cookie{NullRefCountedTypeCookie};
- auto cookieValue = cookie.load(std::memory_order_relaxed);
- if (Y_UNLIKELY(cookieValue == NullRefCountedTypeCookie)) {
- cookieValue = TRefCountedTrackerFacade::GetCookie(
- GetRefCountedTypeKey<T>(),
- sizeof(T),
- NYT::TSourceLocation());
- cookie.store(cookieValue, std::memory_order_relaxed);
- }
- return cookieValue;
-}
-
-template <class T, class TTag, int Counter>
-Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation(const TSourceLocation& location)
-{
- static std::atomic<TRefCountedTypeCookie> cookie{NullRefCountedTypeCookie};
- auto cookieValue = cookie.load(std::memory_order_relaxed);
- if (Y_UNLIKELY(cookieValue == NullRefCountedTypeCookie)) {
- cookieValue = TRefCountedTrackerFacade::GetCookie(
- GetRefCountedTypeKey<T>(),
- sizeof(T),
- location);
- cookie.store(cookieValue, std::memory_order_relaxed);
- }
- return cookieValue;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT
+#ifndef REF_TRACKED_INL_H_
+#error "Direct inclusion of this file is not allowed, include ref_tracked.h"
+// For the sake of sane code completion.
+#include "ref_tracked.h"
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+TRefCountedTypeKey GetRefCountedTypeKey()
+{
+ return &typeid(T);
+}
+
+template <class T>
+Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookie()
+{
+ static std::atomic<TRefCountedTypeCookie> cookie{NullRefCountedTypeCookie};
+ auto cookieValue = cookie.load(std::memory_order_relaxed);
+ if (Y_UNLIKELY(cookieValue == NullRefCountedTypeCookie)) {
+ cookieValue = TRefCountedTrackerFacade::GetCookie(
+ GetRefCountedTypeKey<T>(),
+ sizeof(T),
+ NYT::TSourceLocation());
+ cookie.store(cookieValue, std::memory_order_relaxed);
+ }
+ return cookieValue;
+}
+
+template <class T, class TTag, int Counter>
+Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation(const TSourceLocation& location)
+{
+ static std::atomic<TRefCountedTypeCookie> cookie{NullRefCountedTypeCookie};
+ auto cookieValue = cookie.load(std::memory_order_relaxed);
+ if (Y_UNLIKELY(cookieValue == NullRefCountedTypeCookie)) {
+ cookieValue = TRefCountedTrackerFacade::GetCookie(
+ GetRefCountedTypeKey<T>(),
+ sizeof(T),
+ location);
+ cookie.store(cookieValue, std::memory_order_relaxed);
+ }
+ return cookieValue;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/ref_tracked.cpp b/library/cpp/yt/memory/ref_tracked.cpp
index 5eaa17bd42..4dafbc0849 100644
--- a/library/cpp/yt/memory/ref_tracked.cpp
+++ b/library/cpp/yt/memory/ref_tracked.cpp
@@ -1,38 +1,38 @@
-#include "ref_tracked.h"
-
-namespace NYT {
-
-////////////////////////////////////////////////////////////////////////////////
-
-Y_WEAK TRefCountedTypeCookie TRefCountedTrackerFacade::GetCookie(
- TRefCountedTypeKey /*typeKey*/,
- size_t /*instanceSize*/,
- const TSourceLocation& /*location*/)
-{
- return NullRefCountedTypeCookie;
-}
-
-Y_WEAK void TRefCountedTrackerFacade::AllocateInstance(TRefCountedTypeCookie /*cookie*/)
-{ }
-
-Y_WEAK void TRefCountedTrackerFacade::FreeInstance(TRefCountedTypeCookie /*cookie*/)
-{ }
-
-Y_WEAK void TRefCountedTrackerFacade::AllocateTagInstance(TRefCountedTypeCookie /*cookie*/)
-{ }
-
-Y_WEAK void TRefCountedTrackerFacade::FreeTagInstance(TRefCountedTypeCookie /*cookie*/)
-{ }
-
-Y_WEAK void TRefCountedTrackerFacade::AllocateSpace(TRefCountedTypeCookie /*cookie*/, size_t /*size*/)
-{ }
-
-Y_WEAK void TRefCountedTrackerFacade::FreeSpace(TRefCountedTypeCookie /*cookie*/, size_t /*size*/)
-{ }
-
-Y_WEAK void TRefCountedTrackerFacade::Dump()
-{ }
-
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT
+#include "ref_tracked.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+Y_WEAK TRefCountedTypeCookie TRefCountedTrackerFacade::GetCookie(
+ TRefCountedTypeKey /*typeKey*/,
+ size_t /*instanceSize*/,
+ const TSourceLocation& /*location*/)
+{
+ return NullRefCountedTypeCookie;
+}
+
+Y_WEAK void TRefCountedTrackerFacade::AllocateInstance(TRefCountedTypeCookie /*cookie*/)
+{ }
+
+Y_WEAK void TRefCountedTrackerFacade::FreeInstance(TRefCountedTypeCookie /*cookie*/)
+{ }
+
+Y_WEAK void TRefCountedTrackerFacade::AllocateTagInstance(TRefCountedTypeCookie /*cookie*/)
+{ }
+
+Y_WEAK void TRefCountedTrackerFacade::FreeTagInstance(TRefCountedTypeCookie /*cookie*/)
+{ }
+
+Y_WEAK void TRefCountedTrackerFacade::AllocateSpace(TRefCountedTypeCookie /*cookie*/, size_t /*size*/)
+{ }
+
+Y_WEAK void TRefCountedTrackerFacade::FreeSpace(TRefCountedTypeCookie /*cookie*/, size_t /*size*/)
+{ }
+
+Y_WEAK void TRefCountedTrackerFacade::Dump()
+{ }
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/ref_tracked.h b/library/cpp/yt/memory/ref_tracked.h
index c43940ea3e..75c1eb5985 100644
--- a/library/cpp/yt/memory/ref_tracked.h
+++ b/library/cpp/yt/memory/ref_tracked.h
@@ -3,67 +3,67 @@
#include <library/cpp/yt/misc/port.h>
#include <library/cpp/yt/misc/source_location.h>
-#include <util/system/defaults.h>
-
-#include <atomic>
-#include <typeinfo>
-
+#include <util/system/defaults.h>
+
+#include <atomic>
+#include <typeinfo>
+
namespace NYT {
////////////////////////////////////////////////////////////////////////////////
-using TRefCountedTypeCookie = int;
-const int NullRefCountedTypeCookie = -1;
-
-using TRefCountedTypeKey = const void*;
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Used to avoid including heavy ref_counted_tracker.h
-class TRefCountedTrackerFacade
-{
-public:
- static TRefCountedTypeCookie GetCookie(
- TRefCountedTypeKey typeKey,
- size_t instanceSize,
- const NYT::TSourceLocation& location);
-
- static void AllocateInstance(TRefCountedTypeCookie cookie);
- static void FreeInstance(TRefCountedTypeCookie cookie);
-
- static void AllocateTagInstance(TRefCountedTypeCookie cookie);
- static void FreeTagInstance(TRefCountedTypeCookie cookie);
-
- static void AllocateSpace(TRefCountedTypeCookie cookie, size_t size);
- static void FreeSpace(TRefCountedTypeCookie cookie, size_t size);
-
- // Typically invoked from GDB console.
- // Dumps the ref-counted statistics sorted by "bytes alive".
- static void Dump();
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-namespace {
-
-//! A per-translation unit tag type.
-struct TCurrentTranslationUnitTag
-{ };
-
-} // namespace
-
-template <class T>
-TRefCountedTypeKey GetRefCountedTypeKey();
-
-template <class T>
-TRefCountedTypeCookie GetRefCountedTypeCookie();
-
-template <class T, class TTag, int Counter>
-TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation(
- const TSourceLocation& location);
-
-////////////////////////////////////////////////////////////////////////////////
-
+using TRefCountedTypeCookie = int;
+const int NullRefCountedTypeCookie = -1;
+
+using TRefCountedTypeKey = const void*;
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Used to avoid including heavy ref_counted_tracker.h
+class TRefCountedTrackerFacade
+{
+public:
+ static TRefCountedTypeCookie GetCookie(
+ TRefCountedTypeKey typeKey,
+ size_t instanceSize,
+ const NYT::TSourceLocation& location);
+
+ static void AllocateInstance(TRefCountedTypeCookie cookie);
+ static void FreeInstance(TRefCountedTypeCookie cookie);
+
+ static void AllocateTagInstance(TRefCountedTypeCookie cookie);
+ static void FreeTagInstance(TRefCountedTypeCookie cookie);
+
+ static void AllocateSpace(TRefCountedTypeCookie cookie, size_t size);
+ static void FreeSpace(TRefCountedTypeCookie cookie, size_t size);
+
+ // Typically invoked from GDB console.
+ // Dumps the ref-counted statistics sorted by "bytes alive".
+ static void Dump();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+//! A per-translation unit tag type.
+struct TCurrentTranslationUnitTag
+{ };
+
+} // namespace
+
+template <class T>
+TRefCountedTypeKey GetRefCountedTypeKey();
+
+template <class T>
+TRefCountedTypeCookie GetRefCountedTypeCookie();
+
+template <class T, class TTag, int Counter>
+TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation(
+ const TSourceLocation& location);
+
+////////////////////////////////////////////////////////////////////////////////
+
//! A lightweight mix-in that integrates any class into TRefCountedTracker statistics.
/*!
* |T| must be the actual derived type.
@@ -75,7 +75,7 @@ template <class T>
class TRefTracked
{
public:
-#ifdef YT_ENABLE_REF_COUNTED_TRACKING
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
TRefTracked()
{
auto cookie = GetRefCountedTypeCookie<T>();
@@ -98,14 +98,14 @@ public:
{
auto cookie = GetRefCountedTypeCookie<T>();
TRefCountedTrackerFacade::FreeInstance(cookie);
- }
+ }
#endif
};
////////////////////////////////////////////////////////////////////////////////
} // namespace NYT
-
-#define REF_TRACKED_INL_H_
-#include "ref_tracked-inl.h"
-#undef REF_TRACKED_INL_H_
+
+#define REF_TRACKED_INL_H_
+#include "ref_tracked-inl.h"
+#undef REF_TRACKED_INL_H_
diff --git a/library/cpp/yt/memory/shared_range.h b/library/cpp/yt/memory/shared_range.h
index b50a224bc1..9841d7a0df 100644
--- a/library/cpp/yt/memory/shared_range.h
+++ b/library/cpp/yt/memory/shared_range.h
@@ -19,7 +19,7 @@ class TSharedRange
: public TRange<T>
{
public:
- using THolderPtr = TRefCountedPtr;
+ using THolderPtr = TRefCountedPtr;
//! Constructs a null TSharedRange.
TSharedRange()
@@ -104,7 +104,7 @@ protected:
//! Constructs a combined holder instance by taking ownership of a given list of holders.
template <class... THolders>
-TRefCountedPtr MakeCompositeHolder(THolders&&... holders)
+TRefCountedPtr MakeCompositeHolder(THolders&&... holders)
{
struct THolder
: public TRefCounted
@@ -185,7 +185,7 @@ class TSharedMutableRange
: public TMutableRange<T>
{
public:
- using THolderPtr = TRefCountedPtr;
+ using THolderPtr = TRefCountedPtr;
//! Constructs a null TSharedMutableRange.
TSharedMutableRange()
diff --git a/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp b/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp
index 5b19a9add8..622bed0eb0 100644
--- a/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp
+++ b/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/testing/gtest/gtest.h>
+#include <library/cpp/testing/gtest/gtest.h>
#include <library/cpp/yt/memory/new.h>
#include <library/cpp/yt/memory/ref_counted.h>
@@ -68,9 +68,9 @@ MATCHER_P3(HasRefCounts, increments, decrements, zeros,
void PrintTo(const TIntricateObject& arg, ::std::ostream* os)
{
- *os << arg.Increments << " increments, "
- << arg.Decrements << " decrements and "
- << arg.Zeros << " times vanished";
+ *os << arg.Increments << " increments, "
+ << arg.Decrements << " decrements and "
+ << arg.Zeros << " times vanished";
}
// This is an object which creates intrusive pointers to the self
@@ -480,82 +480,82 @@ TEST(TIntrusivePtrTest, ObjectAlignment)
EXPECT_TRUE(reinterpret_cast<uintptr_t>(bar.Get()) % 64 == 0);
}
-TEST(TIntrusivePtrTest, InitStruct)
-{
- struct TObj1 final
- {
- const int A;
- const int B;
- };
-
- New<TObj1>(1, 2);
-
- struct TExplicitObj final
- {
- explicit TExplicitObj(int a = 0)
- : A(a)
- { }
-
- const int A;
- };
-
- New<TExplicitObj>();
- New<TExplicitObj>(1);
-
- struct TObj2 final
- {
- TObj2(i64 a = 0)
- : A(a)
- { }
-
- const i64 A;
- };
-
- New<TObj2>(123);
-
- struct TObj3 final
- {
- TObj3(ui64 a = 0)
- : A(a)
- { }
-
- const ui64 A;
- };
-
- New<TObj3>(123);
-
- struct TObj4 final
- {
- TObj4(int a, ui64 b = 0)
- : A(a)
- , B(b)
- { }
-
- int A;
- const ui64 B;
- };
-
- New<TObj4>(123);
- New<TObj4>(123, 123);
-
- struct TObj5 final
- {
- TExplicitObj E;
- int B;
- };
-
- New<TObj5>();
-
- struct TObj6 final
- {
- TObj2 O;
- int B;
- };
-
- New<TObj6>();
- New<TObj6>(1, 2);
-}
-
+TEST(TIntrusivePtrTest, InitStruct)
+{
+ struct TObj1 final
+ {
+ const int A;
+ const int B;
+ };
+
+ New<TObj1>(1, 2);
+
+ struct TExplicitObj final
+ {
+ explicit TExplicitObj(int a = 0)
+ : A(a)
+ { }
+
+ const int A;
+ };
+
+ New<TExplicitObj>();
+ New<TExplicitObj>(1);
+
+ struct TObj2 final
+ {
+ TObj2(i64 a = 0)
+ : A(a)
+ { }
+
+ const i64 A;
+ };
+
+ New<TObj2>(123);
+
+ struct TObj3 final
+ {
+ TObj3(ui64 a = 0)
+ : A(a)
+ { }
+
+ const ui64 A;
+ };
+
+ New<TObj3>(123);
+
+ struct TObj4 final
+ {
+ TObj4(int a, ui64 b = 0)
+ : A(a)
+ , B(b)
+ { }
+
+ int A;
+ const ui64 B;
+ };
+
+ New<TObj4>(123);
+ New<TObj4>(123, 123);
+
+ struct TObj5 final
+ {
+ TExplicitObj E;
+ int B;
+ };
+
+ New<TObj5>();
+
+ struct TObj6 final
+ {
+ TObj2 O;
+ int B;
+ };
+
+ New<TObj6>();
+ New<TObj6>(1, 2);
+}
+
////////////////////////////////////////////////////////////////////////////////
} // namespace
diff --git a/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp b/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp
index c00451badd..180c16b5ca 100644
--- a/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp
+++ b/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp
@@ -1,9 +1,9 @@
-#include <library/cpp/testing/gtest/gtest.h>
+#include <library/cpp/testing/gtest/gtest.h>
#include <library/cpp/yt/memory/new.h>
#include <library/cpp/yt/memory/weak_ptr.h>
-#include <array>
+#include <array>
namespace NYT {
namespace {
@@ -91,8 +91,8 @@ MATCHER_P2(HasRefCounts, strongRefs, weakRefs,
template <class T>
void PrintExtrinsicRefCounted(const T& arg, ::std::ostream* os)
{
- *os << arg.GetRefCount() << " strong and "
- << arg.GetWeakRefCount() << " weak references";
+ *os << arg.GetRefCount() << " strong and "
+ << arg.GetWeakRefCount() << " weak references";
}
void PrintTo(const TIntricateObject& arg, ::std::ostream* os)
@@ -353,32 +353,32 @@ TEST_F(TWeakPtrTest, VirtualBase)
ptr.Reset();
}
-#if 0
-class TSlowlyDyingObject
- : public TRefCounted
-{
-public:
- TSlowlyDyingObject()
- {
- ++ConstructorShadowState;
- }
-
- virtual ~TSlowlyDyingObject()
- {
- ++DestructorShadowState;
- DeathEvent->Wait();
- ++DestructorShadowState;
- }
-};
-
-void PrintTo(const TSlowlyDyingObject& arg, ::std::ostream* os)
-{
- PrintExtrinsicRefCounted(arg, os);
-}
-
-typedef TIntrusivePtr<TSlowlyDyingObject> TSlowlyDyingObjectPtr;
-typedef TWeakPtr<TSlowlyDyingObject> TSlowlyDyingObjectWkPtr;
-
+#if 0
+class TSlowlyDyingObject
+ : public TRefCounted
+{
+public:
+ TSlowlyDyingObject()
+ {
+ ++ConstructorShadowState;
+ }
+
+ virtual ~TSlowlyDyingObject()
+ {
+ ++DestructorShadowState;
+ DeathEvent->Wait();
+ ++DestructorShadowState;
+ }
+};
+
+void PrintTo(const TSlowlyDyingObject& arg, ::std::ostream* os)
+{
+ PrintExtrinsicRefCounted(arg, os);
+}
+
+typedef TIntrusivePtr<TSlowlyDyingObject> TSlowlyDyingObjectPtr;
+typedef TWeakPtr<TSlowlyDyingObject> TSlowlyDyingObjectWkPtr;
+
static void* AsynchronousDeleter(void* param)
{
TSlowlyDyingObjectPtr* indirectObject =
@@ -388,11 +388,11 @@ static void* AsynchronousDeleter(void* param)
}
std::unique_ptr<NThreading::TEvent> DeathEvent;
-
+
TEST_F(TWeakPtrTest, DISABLED_AcquisionOfSlowlyDyingObject)
{
DeathEvent.reset(new NThreading::TEvent());
-
+
TSlowlyDyingObjectPtr object = New<TSlowlyDyingObject>();
TSlowlyDyingObjectWkPtr ptr(object);
@@ -425,8 +425,8 @@ TEST_F(TWeakPtrTest, DISABLED_AcquisionOfSlowlyDyingObject)
EXPECT_EQ(TSlowlyDyingObjectPtr(), ptr.Lock());
}
-#endif
-
+#endif
+
////////////////////////////////////////////////////////////////////////////////
} // namespace
diff --git a/library/cpp/yt/memory/unittests/ya.make b/library/cpp/yt/memory/unittests/ya.make
index 4b86574609..f09ad7d0c9 100644
--- a/library/cpp/yt/memory/unittests/ya.make
+++ b/library/cpp/yt/memory/unittests/ya.make
@@ -1,19 +1,19 @@
-GTEST(unittester-library-memory)
-
-OWNER(g:yt)
-
+GTEST(unittester-library-memory)
+
+OWNER(g:yt)
+
IF (NOT OS_WINDOWS)
ALLOCATOR(YT)
ENDIF()
-
-SRCS(
- intrusive_ptr_ut.cpp
- weak_ptr_ut.cpp
-)
-
-PEERDIR(
- library/cpp/testing/gtest
+
+SRCS(
+ intrusive_ptr_ut.cpp
+ weak_ptr_ut.cpp
+)
+
+PEERDIR(
+ library/cpp/testing/gtest
library/cpp/yt/memory
-)
-
-END()
+)
+
+END()
diff --git a/library/cpp/yt/memory/weak_ptr.h b/library/cpp/yt/memory/weak_ptr.h
index 7a789f3b0b..25a242bb8a 100644
--- a/library/cpp/yt/memory/weak_ptr.h
+++ b/library/cpp/yt/memory/weak_ptr.h
@@ -1,6 +1,6 @@
#pragma once
-#include "ref_counted.h"
+#include "ref_counted.h"
#include <util/generic/hash.h>
@@ -8,7 +8,7 @@ namespace NYT {
////////////////////////////////////////////////////////////////////////////////
-template <class T>
+template <class T>
class TWeakPtr
{
public:
@@ -28,84 +28,84 @@ public:
explicit TWeakPtr(T* p) noexcept
: T_(p)
{
-
-#if defined(_tsan_enabled_)
+
+#if defined(_tsan_enabled_)
if (T_) {
- RefCounter_ = GetRefCounter(T_);
+ RefCounter_ = GetRefCounter(T_);
}
-#endif
- AcquireRef();
+#endif
+ AcquireRef();
}
//! Constructor from a strong reference.
- TWeakPtr(const TIntrusivePtr<T>& ptr) noexcept
- : TWeakPtr(ptr.Get())
- { }
+ TWeakPtr(const TIntrusivePtr<T>& ptr) noexcept
+ : TWeakPtr(ptr.Get())
+ { }
- //! Constructor from a strong reference with an upcast.
+ //! Constructor from a strong reference with an upcast.
template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
- TWeakPtr(const TIntrusivePtr<U>& ptr) noexcept
- : TWeakPtr(ptr.Get())
- {
- static_assert(
- std::is_base_of_v<TRefCountedBase, T>,
- "Cast allowed only for types derived from TRefCountedBase");
- }
-
+ TWeakPtr(const TIntrusivePtr<U>& ptr) noexcept
+ : TWeakPtr(ptr.Get())
+ {
+ static_assert(
+ std::is_base_of_v<TRefCountedBase, T>,
+ "Cast allowed only for types derived from TRefCountedBase");
+ }
+
//! Copy constructor.
- TWeakPtr(const TWeakPtr& other) noexcept
- : TWeakPtr(other.T_)
- { }
+ TWeakPtr(const TWeakPtr& other) noexcept
+ : TWeakPtr(other.T_)
+ { }
//! Copy constructor with an upcast.
template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
- TWeakPtr(const TWeakPtr<U>& other) noexcept
- : TWeakPtr(other.Lock())
+ TWeakPtr(const TWeakPtr<U>& other) noexcept
+ : TWeakPtr(other.Lock())
{
- static_assert(
- std::is_base_of_v<TRefCountedBase, T>,
- "Cast allowed only for types derived from TRefCountedBase");
+ static_assert(
+ std::is_base_of_v<TRefCountedBase, T>,
+ "Cast allowed only for types derived from TRefCountedBase");
}
//! Move constructor.
- TWeakPtr(TWeakPtr&& other) noexcept
+ TWeakPtr(TWeakPtr&& other) noexcept
{
- other.Swap(*this);
+ other.Swap(*this);
}
//! Move constructor with an upcast.
template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
- TWeakPtr(TWeakPtr<U>&& other) noexcept
+ TWeakPtr(TWeakPtr<U>&& other) noexcept
{
- static_assert(
- std::is_base_of_v<TRefCountedBase, T>,
- "Cast allowed only for types derived from TRefCountedBase");
+ static_assert(
+ std::is_base_of_v<TRefCountedBase, T>,
+ "Cast allowed only for types derived from TRefCountedBase");
TIntrusivePtr<U> strongOther = other.Lock();
if (strongOther) {
T_ = other.T_;
- other.T_ = nullptr;
+ other.T_ = nullptr;
-#if defined(_tsan_enabled_)
- RefCounter_ = other.RefCounter_;
- other.RefCounter_ = nullptr;
-#endif
+#if defined(_tsan_enabled_)
+ RefCounter_ = other.RefCounter_;
+ other.RefCounter_ = nullptr;
+#endif
}
}
//! Destructor.
~TWeakPtr()
{
- ReleaseRef();
+ ReleaseRef();
}
//! Assignment operator from a strong reference.
template <class U>
- TWeakPtr& operator=(const TIntrusivePtr<U>& ptr) noexcept
+ TWeakPtr& operator=(const TIntrusivePtr<U>& ptr) noexcept
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
- TWeakPtr(ptr).Swap(*this);
+ "U* must be convertible to T*");
+ TWeakPtr(ptr).Swap(*this);
return *this;
}
@@ -122,7 +122,7 @@ public:
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
TWeakPtr(other).Swap(*this);
return *this;
}
@@ -130,7 +130,7 @@ public:
//! Move assignment operator.
TWeakPtr& operator=(TWeakPtr&& other) noexcept
{
- other.Swap(*this);
+ other.Swap(*this);
return *this;
}
@@ -138,9 +138,9 @@ public:
template <class U>
TWeakPtr& operator=(TWeakPtr<U>&& other) noexcept
{
- static_assert(
+ static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
TWeakPtr(std::move(other)).Swap(*this);
return *this;
}
@@ -159,73 +159,73 @@ public:
//! Replace the pointer with a specified one.
template <class U>
- void Reset(const TIntrusivePtr<U>& ptr) // noexcept
+ void Reset(const TIntrusivePtr<U>& ptr) // noexcept
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
- TWeakPtr(ptr).Swap(*this);
+ "U* must be convertible to T*");
+ TWeakPtr(ptr).Swap(*this);
+ }
+
+ //! Swap the pointer with the other one.
+ void Swap(TWeakPtr& other) noexcept
+ {
+ DoSwap(T_, other.T_);
+#if defined(_tsan_enabled_)
+ DoSwap(RefCounter_, other.RefCounter_);
+#endif
}
- //! Swap the pointer with the other one.
- void Swap(TWeakPtr& other) noexcept
- {
- DoSwap(T_, other.T_);
-#if defined(_tsan_enabled_)
- DoSwap(RefCounter_, other.RefCounter_);
-#endif
- }
-
//! Acquire a strong reference to the pointee and return a strong pointer.
TIntrusivePtr<T> Lock() const noexcept
{
- return T_ && RefCounter()->TryRef()
+ return T_ && RefCounter()->TryRef()
? TIntrusivePtr<T>(T_, false)
: TIntrusivePtr<T>();
}
- bool IsExpired() const noexcept
+ bool IsExpired() const noexcept
{
- return !T_ || (RefCounter()->GetRefCount() == 0);
+ return !T_ || (RefCounter()->GetRefCount() == 0);
}
-private:
- void AcquireRef()
+private:
+ void AcquireRef()
{
- if (T_) {
- RefCounter()->WeakRef();
- }
+ if (T_) {
+ RefCounter()->WeakRef();
+ }
+ }
+
+ void ReleaseRef()
+ {
+ if (T_) {
+ // Support incomplete type.
+ if (RefCounter()->WeakUnref()) {
+ DeallocateRefCounted(T_);
+ }
+ }
}
- void ReleaseRef()
- {
- if (T_) {
- // Support incomplete type.
- if (RefCounter()->WeakUnref()) {
- DeallocateRefCounted(T_);
- }
- }
- }
-
template <class U>
friend class TWeakPtr;
template <class U>
friend struct ::THash;
T* T_ = nullptr;
-#if defined(_tsan_enabled_)
- const TRefCounter* RefCounter_ = nullptr;
-
- const TRefCounter* RefCounter() const
- {
- return RefCounter_;
- }
-#else
- const TRefCounter* RefCounter() const
- {
- return GetRefCounter(T_);
- }
-#endif
+#if defined(_tsan_enabled_)
+ const TRefCounter* RefCounter_ = nullptr;
+
+ const TRefCounter* RefCounter() const
+ {
+ return RefCounter_;
+ }
+#else
+ const TRefCounter* RefCounter() const
+ {
+ return GetRefCounter(T_);
+ }
+#endif
};
////////////////////////////////////////////////////////////////////////////////
@@ -285,7 +285,7 @@ bool operator==(const TWeakPtr<T>& lhs, const TWeakPtr<U>& rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs.Lock().Get() == rhs.Lock().Get();
}
@@ -294,7 +294,7 @@ bool operator!=(const TWeakPtr<T>& lhs, const TWeakPtr<U>& rhs)
{
static_assert(
std::is_convertible_v<U*, T*>,
- "U* must be convertible to T*");
+ "U* must be convertible to T*");
return lhs.Lock().Get() != rhs.Lock().Get();
}
@@ -309,6 +309,6 @@ struct THash<NYT::TWeakPtr<T>>
{
size_t operator () (const NYT::TWeakPtr<T>& ptr) const
{
- return THash<const NYT::TRefCountedBase*>()(ptr.T_);
+ return THash<const NYT::TRefCountedBase*>()(ptr.T_);
}
};
diff --git a/library/cpp/yt/memory/ya.make b/library/cpp/yt/memory/ya.make
index 54e237ddee..a925c714ee 100644
--- a/library/cpp/yt/memory/ya.make
+++ b/library/cpp/yt/memory/ya.make
@@ -1,31 +1,31 @@
-LIBRARY()
-
-OWNER(g:yt)
-
-SRCS(
+LIBRARY()
+
+OWNER(g:yt)
+
+SRCS(
blob.cpp
ref.cpp
- ref_tracked.cpp
-)
-
-PEERDIR(
+ ref_tracked.cpp
+)
+
+PEERDIR(
library/cpp/yt/assert
library/cpp/yt/misc
- library/cpp/ytalloc/api
-)
-
-CHECK_DEPENDENT_DIRS(
- ALLOW_ONLY ALL
- build
- contrib
- library
- util
+ library/cpp/ytalloc/api
+)
+
+CHECK_DEPENDENT_DIRS(
+ ALLOW_ONLY ALL
+ build
+ contrib
+ library
+ util
library/cpp/yt/assert
library/cpp/yt/misc
-)
-
-END()
-
-RECURSE_FOR_TESTS(
- unittests
-)
+)
+
+END()
+
+RECURSE_FOR_TESTS(
+ unittests
+)
diff --git a/library/cpp/yt/misc/port.h b/library/cpp/yt/misc/port.h
index 3e5e7be617..b24ac50995 100644
--- a/library/cpp/yt/misc/port.h
+++ b/library/cpp/yt/misc/port.h
@@ -59,12 +59,12 @@
#if defined(__GNUC__) || defined(__clang__)
#define PER_THREAD __thread
#define ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
- // Prevent GCC from throwing out functions in release builds.
- #define ATTRIBUTE_USED __attribute__((used))
+ // Prevent GCC from throwing out functions in release builds.
+ #define ATTRIBUTE_USED __attribute__((used))
#elif defined(_MSC_VER)
#define PER_THREAD __declspec(thread)
#define ATTRIBUTE_NO_SANITIZE_ADDRESS
- #define ATTRIBUTE_USED
+ #define ATTRIBUTE_USED
#else
#error Unsupported compiler
#endif
diff --git a/library/cpp/yt/misc/source_location.cpp b/library/cpp/yt/misc/source_location.cpp
index e65a382b1b..8d22d43636 100644
--- a/library/cpp/yt/misc/source_location.cpp
+++ b/library/cpp/yt/misc/source_location.cpp
@@ -27,7 +27,7 @@ bool TSourceLocation::operator<(const TSourceLocation& other) const
const char* otherFileName = other.FileName_ ? other.FileName_ : "";
int fileNameResult = strcmp(fileName, otherFileName);
if (fileNameResult != 0) {
- return fileNameResult < 0;
+ return fileNameResult < 0;
}
if (Line_ < other.Line_) {
diff --git a/library/cpp/yt/misc/ya.make b/library/cpp/yt/misc/ya.make
index 9d75f7b9dc..bb76711ddd 100644
--- a/library/cpp/yt/misc/ya.make
+++ b/library/cpp/yt/misc/ya.make
@@ -1,26 +1,26 @@
-LIBRARY()
-
-OWNER(g:yt)
-
-SRCS(
+LIBRARY()
+
+OWNER(g:yt)
+
+SRCS(
guid.cpp
- source_location.cpp
-)
-
-PEERDIR(
+ source_location.cpp
+)
+
+PEERDIR(
library/cpp/yt/exception
-)
-
-CHECK_DEPENDENT_DIRS(
- ALLOW_ONLY ALL
- build
- contrib
- library
- util
- yt/yt/library/small_containers
-)
-
-END()
+)
+
+CHECK_DEPENDENT_DIRS(
+ ALLOW_ONLY ALL
+ build
+ contrib
+ library
+ util
+ yt/yt/library/small_containers
+)
+
+END()
RECURSE_FOR_TESTS(
unittests
diff --git a/library/cpp/yt/yson_string/string.cpp b/library/cpp/yt/yson_string/string.cpp
index 655f770482..99d45e8616 100644
--- a/library/cpp/yt/yson_string/string.cpp
+++ b/library/cpp/yt/yson_string/string.cpp
@@ -155,7 +155,7 @@ TString TYsonString::ToString() const
[] (const TNullPayload&) -> TString {
YT_ABORT();
},
- [&] (const TRefCountedPtr&) {
+ [&] (const TRefCountedPtr&) {
return TString(AsStringBuf());
},
[] (const TString& payload) {
diff --git a/library/cpp/yt/yson_string/string.h b/library/cpp/yt/yson_string/string.h
index 379b455de0..e13af37a6d 100644
--- a/library/cpp/yt/yson_string/string.h
+++ b/library/cpp/yt/yson_string/string.h
@@ -107,7 +107,7 @@ private:
struct TNullPayload
{ };
- using THolder = TRefCountedPtr;
+ using THolder = TRefCountedPtr;
std::variant<TNullPayload, THolder, TString> Payload_;
--
cgit v1.2.3