From caa2605a283c784ebc6f83778c04a9d841c954f9 Mon Sep 17 00:00:00 2001 From: David Garcia Quintas Date: Wed, 21 Mar 2018 18:25:22 -0700 Subject: Don't capture unnecessary or unused variables --- test/core/gprpp/inlined_vector_test.cc | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'test/core/gprpp') diff --git a/test/core/gprpp/inlined_vector_test.cc b/test/core/gprpp/inlined_vector_test.cc index b900afaf3d..2a357420f3 100644 --- a/test/core/gprpp/inlined_vector_test.cc +++ b/test/core/gprpp/inlined_vector_test.cc @@ -87,14 +87,17 @@ TEST(InlinedVectorTest, ClearAndRepopulate) { } TEST(InlinedVectorTest, ConstIndexOperator) { - const int kNumElements = 10; + constexpr int kNumElements = 10; InlinedVector v; EXPECT_EQ(0UL, v.size()); for (int i = 0; i < kNumElements; ++i) { v.push_back(i); EXPECT_EQ(i + 1UL, v.size()); } - auto const_func = [kNumElements](const InlinedVector& v) { + // The following lambda function is exceptionally allowed to use an anonymous + // capture due to the erroneous behavior of the MSVC compiler, that refuses to + // capture the kNumElements constexpr, something allowed by the standard. + auto const_func = [&](const InlinedVector& v) { for (int i = 0; i < kNumElements; ++i) { EXPECT_EQ(i, v[i]); } -- cgit v1.2.3 From 62d2ca77db80a48adaaf163135bd01841faeb0f1 Mon Sep 17 00:00:00 2001 From: "Mark D. Roth" Date: Wed, 28 Mar 2018 08:54:03 -0700 Subject: Change InlinedVector to keep elements stored contiguously. --- src/core/lib/gprpp/inlined_vector.h | 65 ++++++++++++++++------------------ test/core/gprpp/inlined_vector_test.cc | 1 + 2 files changed, 32 insertions(+), 34 deletions(-) (limited to 'test/core/gprpp') diff --git a/src/core/lib/gprpp/inlined_vector.h b/src/core/lib/gprpp/inlined_vector.h index ca95aecddc..0a19542ab4 100644 --- a/src/core/lib/gprpp/inlined_vector.h +++ b/src/core/lib/gprpp/inlined_vector.h @@ -54,43 +54,44 @@ class InlinedVector { InlinedVector(const InlinedVector&) = delete; InlinedVector& operator=(const InlinedVector&) = delete; + T* data() { + return dynamic_ != nullptr ? dynamic_ : reinterpret_cast(inline_); + } + + const T* data() const { + return dynamic_ != nullptr ? dynamic_ : reinterpret_cast(inline_); + } + T& operator[](size_t offset) { assert(offset < size_); - if (offset < N) { - return *reinterpret_cast(inline_ + offset); - } else { - return dynamic_[offset - N]; - } + return data()[offset]; } const T& operator[](size_t offset) const { assert(offset < size_); - if (offset < N) { - return *reinterpret_cast(inline_ + offset); - } else { - return dynamic_[offset - N]; + return data()[offset]; + } + + void reserve(size_t capacity) { + if (capacity > capacity_) { + T* new_dynamic = static_cast(gpr_malloc(sizeof(T) * capacity)); + for (size_t i = 0; i < size_; ++i) { + new (&new_dynamic[i]) T(std::move(data()[i])); + data()[i].~T(); + } + gpr_free(dynamic_); + dynamic_ = new_dynamic; + capacity_ = capacity; } } template void emplace_back(Args&&... args) { - if (size_ < N) { - new (&inline_[size_]) T(std::forward(args)...); - } else { - if (size_ - N == dynamic_capacity_) { - size_t new_capacity = - dynamic_capacity_ == 0 ? 2 : dynamic_capacity_ * 2; - T* new_dynamic = static_cast(gpr_malloc(sizeof(T) * new_capacity)); - for (size_t i = 0; i < dynamic_capacity_; ++i) { - new (&new_dynamic[i]) T(std::move(dynamic_[i])); - dynamic_[i].~T(); - } - gpr_free(dynamic_); - dynamic_ = new_dynamic; - dynamic_capacity_ = new_capacity; - } - new (&dynamic_[size_ - N]) T(std::forward(args)...); + if (size_ == capacity_) { + const size_t new_capacity = capacity_ == 0 ? 2 : capacity_ * 2; + reserve(new_capacity); } + new (&(data()[size_])) T(std::forward(args)...); ++size_; } @@ -99,6 +100,7 @@ class InlinedVector { void push_back(T&& value) { emplace_back(std::move(value)); } size_t size() const { return size_; } + size_t capacity() const { return capacity_; } void clear() { destroy_elements(); @@ -109,26 +111,21 @@ class InlinedVector { void init_data() { dynamic_ = nullptr; size_ = 0; - dynamic_capacity_ = 0; + capacity_ = N; } void destroy_elements() { - for (size_t i = 0; i < size_ && i < N; ++i) { - T& value = *reinterpret_cast(inline_ + i); + for (size_t i = 0; i < size_; ++i) { + T& value = data()[i]; value.~T(); } - if (size_ > N) { // Avoid subtracting two signed values. - for (size_t i = 0; i < size_ - N; ++i) { - dynamic_[i].~T(); - } - } gpr_free(dynamic_); } typename std::aligned_storage::type inline_[N]; T* dynamic_; size_t size_; - size_t dynamic_capacity_; + size_t capacity_; }; } // namespace grpc_core diff --git a/test/core/gprpp/inlined_vector_test.cc b/test/core/gprpp/inlined_vector_test.cc index 2a357420f3..ae34947718 100644 --- a/test/core/gprpp/inlined_vector_test.cc +++ b/test/core/gprpp/inlined_vector_test.cc @@ -33,6 +33,7 @@ TEST(InlinedVectorTest, CreateAndIterate) { EXPECT_EQ(static_cast(kNumElements), v.size()); for (int i = 0; i < kNumElements; ++i) { EXPECT_EQ(i, v[i]); + EXPECT_EQ(i, &v[i] - &v[0]); // Ensure contiguous allocation. } } -- cgit v1.2.3 From 908a2173fe7d3ec5e9c37275651a9fd1b272c0b7 Mon Sep 17 00:00:00 2001 From: "Mark D. Roth" Date: Wed, 18 Apr 2018 08:04:11 -0700 Subject: Avoid warnings from LLVM -Wself-assign. --- test/core/gprpp/ref_counted_ptr_test.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'test/core/gprpp') diff --git a/test/core/gprpp/ref_counted_ptr_test.cc b/test/core/gprpp/ref_counted_ptr_test.cc index 2e398a7722..c810345166 100644 --- a/test/core/gprpp/ref_counted_ptr_test.cc +++ b/test/core/gprpp/ref_counted_ptr_test.cc @@ -88,7 +88,7 @@ TEST(RefCountedPtr, CopyAssignmentWhenEmpty) { TEST(RefCountedPtr, CopyAssignmentToSelf) { RefCountedPtr foo(New()); - foo = foo; + foo = *&foo; // The "*&" avoids warnings from LLVM -Wself-assign. } TEST(RefCountedPtr, EnclosedScope) { -- cgit v1.2.3