summaryrefslogtreecommitdiff
path: root/absl
diff options
context:
space:
mode:
Diffstat (limited to 'absl')
-rw-r--r--absl/strings/BUILD.bazel58
-rw-r--r--absl/strings/CMakeLists.txt54
-rw-r--r--absl/strings/cord.cc55
-rw-r--r--absl/strings/cord.h35
-rw-r--r--absl/strings/cord_test.cc2
-rw-r--r--absl/strings/cord_test_helpers.h1
-rw-r--r--absl/strings/cordz_test.cc92
-rw-r--r--absl/strings/cordz_test_helpers.h129
-rw-r--r--absl/strings/internal/cordz_info_test.cc20
-rw-r--r--absl/strings/internal/cordz_sample_token_test.cc33
-rw-r--r--absl/strings/internal/cordz_update_scope_test.cc21
-rw-r--r--absl/time/duration_test.cc4
-rw-r--r--absl/time/time.h2
13 files changed, 422 insertions, 84 deletions
diff --git a/absl/strings/BUILD.bazel b/absl/strings/BUILD.bazel
index 874dd390..5d4ad7e3 100644
--- a/absl/strings/BUILD.bazel
+++ b/absl/strings/BUILD.bazel
@@ -399,6 +399,7 @@ cc_test(
deps = [
":cord_internal",
":cordz_info",
+ ":cordz_test_helpers",
":cordz_update_scope",
":cordz_update_tracker",
"//absl/base:config",
@@ -447,8 +448,8 @@ cc_test(
"internal/cordz_functions_test.cc",
],
deps = [
- ":cord_test_helpers",
":cordz_functions",
+ ":cordz_test_helpers",
"//absl/base:config",
"@com_google_googletest//:gtest_main",
],
@@ -482,6 +483,7 @@ cc_test(
":cordz_handle",
":cordz_info",
":cordz_statistics",
+ ":cordz_test_helpers",
":cordz_update_tracker",
":strings",
"//absl/base:config",
@@ -502,6 +504,7 @@ cc_test(
":cordz_handle",
":cordz_info",
":cordz_sample_token",
+ ":cordz_test_helpers",
"//absl/base:config",
"//absl/memory",
"//absl/random",
@@ -521,6 +524,25 @@ cc_library(
copts = ABSL_DEFAULT_COPTS,
deps = [
":cord",
+ ":cord_internal",
+ ],
+)
+
+cc_library(
+ name = "cordz_test_helpers",
+ testonly = 1,
+ hdrs = ["cordz_test_helpers.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":cord",
+ ":cord_internal",
+ ":cordz_info",
+ ":cordz_sample_token",
+ ":cordz_statistics",
+ ":cordz_update_tracker",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest",
],
)
@@ -533,6 +555,8 @@ cc_test(
deps = [
":cord",
":cord_test_helpers",
+ ":cordz_functions",
+ ":cordz_test_helpers",
":str_format",
":strings",
"//absl/base",
@@ -546,6 +570,38 @@ cc_test(
)
cc_test(
+ name = "cordz_test",
+ size = "medium",
+ srcs = ["cordz_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ tags = [
+ "benchmark",
+ "no_test_android_arm",
+ "no_test_android_arm64",
+ "no_test_android_x86",
+ "no_test_darwin_x86_64",
+ "no_test_ios_x86_64",
+ "no_test_loonix",
+ "no_test_msvc_x64",
+ ],
+ visibility = ["//visibility:private"],
+ deps = [
+ ":cord",
+ ":cordz_functions",
+ ":cordz_info",
+ ":cordz_sample_token",
+ ":cordz_statistics",
+ ":cordz_test_helpers",
+ ":cordz_update_tracker",
+ ":strings",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/base:raw_logging_internal",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
name = "cord_ring_test",
size = "medium",
srcs = ["cord_ring_test.cc"],
diff --git a/absl/strings/CMakeLists.txt b/absl/strings/CMakeLists.txt
index f48584e0..2a8e3df2 100644
--- a/absl/strings/CMakeLists.txt
+++ b/absl/strings/CMakeLists.txt
@@ -626,8 +626,8 @@ absl_cc_test(
"internal/cordz_functions_test.cc"
DEPS
absl::config
- absl::cord_test_helpers
absl::cordz_functions
+ absl::cordz_test_helpers
gmock_main
)
@@ -667,8 +667,8 @@ absl_cc_test(
"internal/cordz_handle_test.cc"
DEPS
absl::config
- absl::cord_test_helpers
absl::cordz_handle
+ absl::cordz_test_helpers
absl::memory
absl::random_random
absl::random_distributions
@@ -707,10 +707,11 @@ absl_cc_test(
DEPS
absl::config
absl::cord_internal
- absl::cord_test_helpers
+ absl::cordz_test_helpers
absl::cordz_handle
absl::cordz_info
absl::cordz_statistics
+ absl::cordz_test_helpers
absl::cordz_update_tracker
absl::span
absl::stacktrace
@@ -747,6 +748,7 @@ absl_cc_test(
absl::cordz_info
absl::cordz_info
absl::cordz_sample_token
+ absl::cordz_test_helpers
absl::memory
absl::random_random
absl::synchronization
@@ -781,6 +783,7 @@ absl_cc_test(
absl::config
absl::cord_internal
absl::cordz_info
+ absl::cordz_test_helpers
absl::cordz_update_scope
absl::cordz_update_tracker
absl::core_headers
@@ -825,6 +828,26 @@ absl_cc_library(
${ABSL_TEST_COPTS}
DEPS
absl::cord
+ absl::cord_internal
+ TESTONLY
+)
+
+absl_cc_library(
+ NAME
+ cordz_test_helpers
+ HDRS
+ "cordz_test_helpers.h"
+ COPTS
+ ${ABSL_TEST_COPTS}
+ DEPS
+ absl::config
+ absl::cord
+ absl::cord_internal
+ absl::cordz_info
+ absl::cordz_sample_token
+ absl::cordz_statistics
+ absl::cordz_update_tracker
+ absl::core_headers
TESTONLY
)
@@ -841,6 +864,8 @@ absl_cc_test(
absl::strings
absl::base
absl::config
+ absl::cord_test_helpers
+ absl::cordz_test_helpers
absl::core_headers
absl::endian
absl::raw_logging_internal
@@ -879,3 +904,26 @@ absl_cc_test(
absl::strings
gmock_main
)
+
+absl_cc_test(
+ NAME
+ cordz_test
+ SRCS
+ "cordz_test.cc"
+ COPTS
+ ${ABSL_TEST_COPTS}
+ DEPS
+ absl::cord
+ absl::cordz_test_helpers
+ absl::cordz_functions
+ absl::cordz_info
+ absl::cordz_sample_token
+ absl::cordz_statistics
+ absl::cordz_update_tracker
+ absl::base
+ absl::config
+ absl::core_headers
+ absl::raw_logging_internal
+ absl::strings
+ gmock_main
+)
diff --git a/absl/strings/cord.cc b/absl/strings/cord.cc
index 44e4d464..768106d4 100644
--- a/absl/strings/cord.cc
+++ b/absl/strings/cord.cc
@@ -342,14 +342,37 @@ static CordRepRing* ForceRing(CordRep* rep, size_t extra) {
return (rep->tag == RING) ? rep->ring() : CordRepRing::Create(rep, extra);
}
-void Cord::InlineRep::AppendTree(CordRep* tree) {
+void Cord::InlineRep::AppendTreeToInlined(CordRep* tree,
+ MethodIdentifier method) {
+ assert(!is_tree());
+ if (!data_.is_empty()) {
+ CordRepFlat* flat = MakeFlat(data_);
+ if (cord_ring_enabled()) {
+ tree = CordRepRing::Append(CordRepRing::Create(flat, 1), tree);
+ } else {
+ tree = Concat(flat, tree);
+ }
+ }
+ EmplaceTree(tree, method);
+}
+
+void Cord::InlineRep::AppendTreeToTree(CordRep* tree, MethodIdentifier method) {
+ assert(is_tree());
+ const CordzUpdateScope scope(data_.cordz_info(), method);
+ if (cord_ring_enabled()) {
+ tree = CordRepRing::Append(ForceRing(data_.as_tree(), 1), tree);
+ } else {
+ tree = Concat(data_.as_tree(), tree);
+ }
+ SetTree(tree, scope);
+}
+
+void Cord::InlineRep::AppendTree(CordRep* tree, MethodIdentifier method) {
if (tree == nullptr) return;
- if (data_.is_empty()) {
- set_tree(tree);
- } else if (cord_ring_enabled()) {
- set_tree(CordRepRing::Append(ForceRing(force_tree(0), 1), tree));
+ if (data_.is_tree()) {
+ AppendTreeToTree(tree, method);
} else {
- set_tree(Concat(force_tree(0), tree));
+ AppendTreeToInlined(tree, method);
}
}
@@ -533,9 +556,8 @@ Cord::Cord(absl::string_view src) : contents_(InlineData::kDefaultInit) {
if (n <= InlineRep::kMaxInline) {
contents_.set_data(src.data(), n, true);
} else {
- contents_.data_.make_tree(NewTree(src.data(), n, 0));
- CordzInfo::MaybeTrackCord(contents_.data_,
- CordzUpdateTracker::kConstructorString);
+ CordRep* rep = NewTree(src.data(), n, 0);
+ contents_.EmplaceTree(rep, CordzUpdateTracker::kConstructorString);
}
}
@@ -713,9 +735,15 @@ inline CordRep* Cord::TakeRep() && {
template <typename C>
inline void Cord::AppendImpl(C&& src) {
if (empty()) {
- // In case of an empty destination avoid allocating a new node, do not copy
- // data.
- *this = std::forward<C>(src);
+ // Since destination is empty, we can avoid allocating a node,
+ if (src.contents_.is_tree()) {
+ // by taking the tree directly
+ CordRep* rep = std::forward<C>(src).TakeRep();
+ contents_.EmplaceTree(rep, CordzUpdateTracker::kAppendCord);
+ } else {
+ // or copying over inline data
+ contents_.data_ = src.contents_.data_;
+ }
return;
}
@@ -746,7 +774,8 @@ inline void Cord::AppendImpl(C&& src) {
}
// Guaranteed to be a tree (kMaxBytesToCopy > kInlinedSize)
- contents_.AppendTree(std::forward<C>(src).TakeRep());
+ CordRep* rep = std::forward<C>(src).TakeRep();
+ contents_.AppendTree(rep, CordzUpdateTracker::kAppendCord);
}
void Cord::Append(const Cord& src) { AppendImpl(src); }
diff --git a/absl/strings/cord.h b/absl/strings/cord.h
index bca20981..dd6c3bca 100644
--- a/absl/strings/cord.h
+++ b/absl/strings/cord.h
@@ -670,6 +670,7 @@ class Cord {
explicit constexpr Cord(strings_internal::StringConstant<T>);
private:
+ using CordRep = absl::cord_internal::CordRep;
using CordzInfo = cord_internal::CordzInfo;
using CordzUpdateScope = cord_internal::CordzUpdateScope;
using CordzUpdateTracker = cord_internal::CordzUpdateTracker;
@@ -680,6 +681,8 @@ class Cord {
friend bool operator==(const Cord& lhs, const Cord& rhs);
friend bool operator==(const Cord& lhs, absl::string_view rhs);
+ friend const CordzInfo* GetCordzInfoForTesting(const Cord& cord);
+
// Calls the provided function once for each cord chunk, in order. Unlike
// Chunks(), this API will not allocate memory.
void ForEachChunk(absl::FunctionRef<void(absl::string_view)>) const;
@@ -730,7 +733,23 @@ class Cord {
void remove_prefix(size_t n); // REQUIRES: holding data
void AppendArray(const char* src_data, size_t src_size);
absl::string_view FindFlatStartPiece() const;
- void AppendTree(absl::cord_internal::CordRep* tree);
+
+ // Sets the tree value for this instance. `rep` must not be null.
+ // Requires the current instance to hold a tree, and a lock to be held on
+ // any CordzInfo referenced by this instance. The latter is enforced through
+ // the CordzUpdateScope argument. If the current instance is sampled, then
+ // the CordzInfo instance is updated to reference the new `rep` value.
+ void SetTree(CordRep* rep, const CordzUpdateScope& scope);
+
+ // Sets the tree value for this instance, and randomly samples this cord.
+ // This function disregards existing contents in `data_`, and should be
+ // called when a Cord is 'promoted' from an 'uninitialized' or 'inlined'
+ // value to a non-inlined (tree / ring) value.
+ void EmplaceTree(CordRep* rep, MethodIdentifier method);
+
+ void AppendTreeToInlined(CordRep* tree, MethodIdentifier method);
+ void AppendTreeToTree(CordRep* tree, MethodIdentifier method);
+ void AppendTree(CordRep* tree, MethodIdentifier method);
void PrependTree(absl::cord_internal::CordRep* tree);
void GetAppendRegion(char** region, size_t* size, size_t max_length);
void GetAppendRegion(char** region, size_t* size);
@@ -1022,6 +1041,20 @@ inline size_t Cord::InlineRep::size() const {
return is_tree() ? as_tree()->length : inline_size();
}
+inline void Cord::InlineRep::EmplaceTree(CordRep* rep,
+ MethodIdentifier method) {
+ data_.make_tree(rep);
+ CordzInfo::MaybeTrackCord(data_, method);
+}
+
+inline void Cord::InlineRep::SetTree(CordRep* rep,
+ const CordzUpdateScope& scope) {
+ assert(rep);
+ assert(data_.is_tree());
+ data_.set_tree(rep);
+ scope.SetCordRep(rep);
+}
+
inline void Cord::InlineRep::set_tree(absl::cord_internal::CordRep* rep) {
if (rep == nullptr) {
if (ABSL_PREDICT_FALSE(is_profiled())) {
diff --git a/absl/strings/cord_test.cc b/absl/strings/cord_test.cc
index 710a1b40..74a90863 100644
--- a/absl/strings/cord_test.cc
+++ b/absl/strings/cord_test.cc
@@ -35,6 +35,7 @@
#include "absl/base/macros.h"
#include "absl/container/fixed_array.h"
#include "absl/strings/cord_test_helpers.h"
+#include "absl/strings/cordz_test_helpers.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_format.h"
#include "absl/strings/string_view.h"
@@ -239,7 +240,6 @@ TEST(GigabyteCord, FromExternal) {
// caused crashes in production. We grow exponentially so that the code will
// execute in a reasonable amount of time.
absl::Cord c;
- ABSL_RAW_LOG(INFO, "Made a Cord with %zu bytes!", c.size());
c.Append(from);
while (c.size() < max_size) {
c.Append(c);
diff --git a/absl/strings/cord_test_helpers.h b/absl/strings/cord_test_helpers.h
index f1036e3b..3815df81 100644
--- a/absl/strings/cord_test_helpers.h
+++ b/absl/strings/cord_test_helpers.h
@@ -18,6 +18,7 @@
#define ABSL_STRINGS_CORD_TEST_HELPERS_H_
#include "absl/strings/cord.h"
+#include "absl/strings/internal/cord_internal.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
diff --git a/absl/strings/cordz_test.cc b/absl/strings/cordz_test.cc
new file mode 100644
index 00000000..6e8deefd
--- /dev/null
+++ b/absl/strings/cordz_test.cc
@@ -0,0 +1,92 @@
+// Copyright 2021 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/macros.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/cordz_test_helpers.h"
+#include "absl/strings/internal/cordz_functions.h"
+#include "absl/strings/internal/cordz_info.h"
+#include "absl/strings/internal/cordz_sample_token.h"
+#include "absl/strings/internal/cordz_statistics.h"
+#include "absl/strings/internal/cordz_update_tracker.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+
+#ifdef ABSL_INTERNAL_CORDZ_ENABLED
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+using cord_internal::CordzInfo;
+using cord_internal::CordzSampleToken;
+using cord_internal::CordzStatistics;
+using cord_internal::CordzUpdateTracker;
+using Method = CordzUpdateTracker::MethodIdentifier;
+
+namespace {
+
+std::string MakeString(int length) {
+ std::string s(length, '.');
+ for (int i = 4; i < length; i += 2) {
+ s[i] = '\b';
+ }
+ return s;
+}
+
+TEST(CordzTest, ConstructSmallStringView) {
+ CordzSamplingIntervalHelper sample_every(1);
+ Cord cord(absl::string_view(MakeString(50)));
+ EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
+}
+
+TEST(CordzTest, ConstructLargeStringView) {
+ CordzSamplingIntervalHelper sample_every(1);
+ Cord cord(absl::string_view(MakeString(5000)));
+ EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
+}
+
+TEST(CordzTest, CopyConstruct) {
+ CordzSamplingIntervalHelper sample_every(1);
+ Cord src = UnsampledCord(MakeString(5000));
+ Cord cord(src);
+ EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorCord));
+}
+
+TEST(CordzTest, AppendLargeCordToEmpty) {
+ CordzSamplingIntervalHelper sample_every(1);
+ Cord cord;
+ Cord src = UnsampledCord(MakeString(5000));
+ cord.Append(src);
+ EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kAppendCord));
+}
+
+TEST(CordzTest, MoveAppendLargeCordToEmpty) {
+ CordzSamplingIntervalHelper sample_every(1);
+ Cord cord;
+ cord.Append(UnsampledCord(MakeString(5000)));
+ EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kAppendCord));
+}
+
+} // namespace
+
+ABSL_NAMESPACE_END
+} // namespace absl
+
+#endif // ABSL_INTERNAL_CORDZ_ENABLED
diff --git a/absl/strings/cordz_test_helpers.h b/absl/strings/cordz_test_helpers.h
new file mode 100644
index 00000000..453c2f9d
--- /dev/null
+++ b/absl/strings/cordz_test_helpers.h
@@ -0,0 +1,129 @@
+// Copyright 2021 The Abseil Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
+#define ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/internal/cord_internal.h"
+#include "absl/strings/internal/cordz_info.h"
+#include "absl/strings/internal/cordz_sample_token.h"
+#include "absl/strings/internal/cordz_statistics.h"
+#include "absl/strings/internal/cordz_update_tracker.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+// Returns the CordzInfo for the cord, or nullptr if the cord is not sampled.
+inline const cord_internal::CordzInfo* GetCordzInfoForTesting(
+ const Cord& cord) {
+ return cord.contents_.cordz_info();
+}
+
+// Returns true if the provided cordz_info is in the list of sampled cords.
+inline bool CordzInfoIsListed(const cord_internal::CordzInfo* cordz_info,
+ cord_internal::CordzSampleToken token = {}) {
+ for (const cord_internal::CordzInfo& info : token) {
+ if (cordz_info == &info) return true;
+ }
+ return false;
+}
+
+// Matcher on Cord that verifies all of:
+// - the cord is sampled
+// - the CordzInfo of the cord is listed / discoverable.
+// - the reported CordzStatistics match the cord's actual properties
+// - the cord has an (initial) UpdateTracker count of 1 for `method`
+MATCHER_P(HasValidCordzInfoOf, method, "CordzInfo matches cord") {
+ const cord_internal::CordzInfo* cord_info = GetCordzInfoForTesting(arg);
+ if (cord_info == nullptr) {
+ *result_listener << "cord is not sampled";
+ return false;
+ }
+ if (!CordzInfoIsListed(cord_info)) {
+ *result_listener << "cord is sampled, but not listed";
+ return false;
+ }
+ cord_internal::CordzStatistics stat = cord_info->GetCordzStatistics();
+ if (stat.size != arg.size()) {
+ *result_listener << "cordz size " << stat.size
+ << " does not match cord size " << arg.size();
+ return false;
+ }
+ if (stat.update_tracker.Value(method) != 1) {
+ *result_listener << "Expected method count 1 for " << method << ", found "
+ << stat.update_tracker.Value(method);
+ return false;
+ }
+ return true;
+}
+
+// Cordz will only update with a new rate once the previously scheduled event
+// has fired. When we disable Cordz, a long delay takes place where we won't
+// consider profiling new Cords. CordzSampleIntervalHelper will burn through
+// that interval and allow for testing that assumes that the average sampling
+// interval is a particular value.
+class CordzSamplingIntervalHelper {
+ public:
+ explicit CordzSamplingIntervalHelper(int32_t interval)
+ : orig_mean_interval_(absl::cord_internal::get_cordz_mean_interval()) {
+ absl::cord_internal::set_cordz_mean_interval(interval);
+ absl::cord_internal::cordz_set_next_sample_for_testing(interval);
+ }
+
+ ~CordzSamplingIntervalHelper() {
+ absl::cord_internal::set_cordz_mean_interval(orig_mean_interval_);
+ absl::cord_internal::cordz_set_next_sample_for_testing(orig_mean_interval_);
+ }
+
+ private:
+ int32_t orig_mean_interval_;
+};
+
+// Wrapper struct managing a small CordRep `rep`
+struct TestCordRep {
+ cord_internal::CordRepFlat* rep;
+
+ TestCordRep() {
+ rep = cord_internal::CordRepFlat::New(100);
+ rep->length = 100;
+ memset(rep->Data(), 1, 100);
+ }
+ ~TestCordRep() { cord_internal::CordRep::Unref(rep); }
+};
+
+// Wrapper struct managing a small CordRep `rep`, and
+// an InlineData `data` initialized with that CordRep.
+struct TestCordData {
+ TestCordRep rep;
+ cord_internal::InlineData data{rep.rep};
+};
+
+// Creates a Cord that is not sampled
+template <typename... Args>
+Cord UnsampledCord(Args... args) {
+ CordzSamplingIntervalHelper never(9999);
+ Cord cord(std::forward<Args>(args)...);
+ ABSL_ASSERT(GetCordzInfoForTesting(cord) == nullptr);
+ return cord;
+}
+
+ABSL_NAMESPACE_END
+} // namespace absl
+
+#endif // ABSL_STRINGS_CORDZ_TEST_HELPERS_H_
diff --git a/absl/strings/internal/cordz_info_test.cc b/absl/strings/internal/cordz_info_test.cc
index 89e5fae5..76aa20b0 100644
--- a/absl/strings/internal/cordz_info_test.cc
+++ b/absl/strings/internal/cordz_info_test.cc
@@ -21,8 +21,10 @@
#include "absl/base/config.h"
#include "absl/debugging/stacktrace.h"
#include "absl/debugging/symbolize.h"
+#include "absl/strings/cordz_test_helpers.h"
#include "absl/strings/internal/cord_rep_flat.h"
#include "absl/strings/internal/cordz_handle.h"
+#include "absl/strings/internal/cordz_statistics.h"
#include "absl/strings/internal/cordz_update_tracker.h"
#include "absl/strings/str_cat.h"
#include "absl/types/span.h"
@@ -37,24 +39,6 @@ using ::testing::Eq;
using ::testing::HasSubstr;
using ::testing::Ne;
-struct TestCordRep {
- CordRepFlat* rep;
-
- TestCordRep() {
- rep = CordRepFlat::New(100);
- rep->length = 100;
- memset(rep->Data(), 1, 100);
- }
- ~TestCordRep() { CordRepFlat::Delete(rep); }
-};
-
-struct TestCordData {
- TestCordRep rep;
- InlineData data;
-
- TestCordData() { data.make_tree(rep.rep); }
-};
-
// Used test values
auto constexpr kUnknownMethod = CordzUpdateTracker::kUnknown;
auto constexpr kTrackCordMethod = CordzUpdateTracker::kConstructorString;
diff --git a/absl/strings/internal/cordz_sample_token_test.cc b/absl/strings/internal/cordz_sample_token_test.cc
index 5fbfd01c..80f41ca1 100644
--- a/absl/strings/internal/cordz_sample_token_test.cc
+++ b/absl/strings/internal/cordz_sample_token_test.cc
@@ -22,6 +22,7 @@
#include "gtest/gtest.h"
#include "absl/memory/memory.h"
#include "absl/random/random.h"
+#include "absl/strings/cordz_test_helpers.h"
#include "absl/strings/internal/cord_rep_flat.h"
#include "absl/strings/internal/cordz_handle.h"
#include "absl/strings/internal/cordz_info.h"
@@ -39,24 +40,6 @@ using ::testing::ElementsAre;
using ::testing::Eq;
using ::testing::Ne;
-struct TestCordRep {
- CordRepFlat* rep;
-
- TestCordRep() {
- rep = CordRepFlat::New(100);
- rep->length = 100;
- memset(rep->Data(), 1, 100);
- }
- ~TestCordRep() { CordRepFlat::Delete(rep); }
-};
-
-struct TestCord {
- TestCordRep rep;
- InlineData data;
-
- TestCord() { data.make_tree(rep.rep); }
-};
-
// Used test values
auto constexpr kTrackCordMethod = CordzUpdateTracker::kConstructorString;
@@ -97,7 +80,7 @@ TEST(CordzSampleTokenTest, IteratorEmpty) {
}
TEST(CordzSampleTokenTest, Iterator) {
- TestCord cord1, cord2, cord3;
+ TestCordData cord1, cord2, cord3;
CordzInfo::TrackCord(cord1.data, kTrackCordMethod);
CordzInfo* info1 = cord1.data.cordz_info();
CordzInfo::TrackCord(cord2.data, kTrackCordMethod);
@@ -119,9 +102,9 @@ TEST(CordzSampleTokenTest, Iterator) {
}
TEST(CordzSampleTokenTest, IteratorEquality) {
- TestCord cord1;
- TestCord cord2;
- TestCord cord3;
+ TestCordData cord1;
+ TestCordData cord2;
+ TestCordData cord3;
CordzInfo::TrackCord(cord1.data, kTrackCordMethod);
CordzInfo* info1 = cord1.data.cordz_info();
@@ -167,7 +150,7 @@ TEST(CordzSampleTokenTest, MultiThreaded) {
for (int i = 0; i < kNumThreads; ++i) {
pool.Schedule([&stop]() {
absl::BitGen gen;
- TestCord cords[kNumCords];
+ TestCordData cords[kNumCords];
std::unique_ptr<CordzSampleToken> tokens[kNumTokens];
while (!stop.HasBeenNotified()) {
@@ -179,7 +162,7 @@ TEST(CordzSampleTokenTest, MultiThreaded) {
// 5) Sample
int index = absl::Uniform(gen, 0, kNumCords);
if (absl::Bernoulli(gen, 0.5)) {
- TestCord& cord = cords[index];
+ TestCordData& cord = cords[index];
// Track/untrack.
if (cord.data.is_profiled()) {
// 1) Untrack
@@ -208,7 +191,7 @@ TEST(CordzSampleTokenTest, MultiThreaded) {
}
}
}
- for (TestCord& cord : cords) {
+ for (TestCordData& cord : cords) {
if (cord.data.is_profiled()) {
CordzInfo::UntrackCord(cord.data.cordz_info());
}
diff --git a/absl/strings/internal/cordz_update_scope_test.cc b/absl/strings/internal/cordz_update_scope_test.cc
index 4bdc78d3..3d08c622 100644
--- a/absl/strings/internal/cordz_update_scope_test.cc
+++ b/absl/strings/internal/cordz_update_scope_test.cc
@@ -17,6 +17,7 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "absl/base/config.h"
+#include "absl/strings/cordz_test_helpers.h"
#include "absl/strings/internal/cord_rep_flat.h"
#include "absl/strings/internal/cordz_info.h"
#include "absl/strings/internal/cordz_update_tracker.h"
@@ -27,24 +28,6 @@ namespace cord_internal {
namespace {
-struct TestCordRep {
- CordRepFlat* rep;
-
- TestCordRep() {
- rep = CordRepFlat::New(100);
- rep->length = 100;
- memset(rep->Data(), 1, 100);
- }
- ~TestCordRep() { CordRepFlat::Delete(rep); }
-};
-
-struct TestCord {
- TestCordRep rep;
- InlineData data;
-
- TestCord() { data.make_tree(rep.rep); }
-};
-
// Used test values
auto constexpr kTrackCordMethod = CordzUpdateTracker::kConstructorString;
@@ -53,7 +36,7 @@ TEST(CordzUpdateScopeTest, ScopeNullptr) {
}
TEST(CordzUpdateScopeTest, ScopeSampledCord) {
- TestCord cord;
+ TestCordData cord;
CordzInfo::TrackCord(cord.data, kTrackCordMethod);
CordzUpdateScope scope(cord.data.cordz_info(), kTrackCordMethod);
cord.data.cordz_info()->SetCordRep(nullptr);
diff --git a/absl/time/duration_test.cc b/absl/time/duration_test.cc
index fb28fa98..a3617e74 100644
--- a/absl/time/duration_test.cc
+++ b/absl/time/duration_test.cc
@@ -1320,7 +1320,7 @@ TEST(Duration, SmallConversions) {
EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(0));
// TODO(bww): Is the next one OK?
- EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(0.124999999e-9));
+ EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(std::nextafter(0.125e-9, 0)));
EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.125e-9));
EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.250e-9));
EXPECT_EQ(absl::Nanoseconds(1) / 2, absl::Seconds(0.375e-9));
@@ -1330,7 +1330,7 @@ TEST(Duration, SmallConversions) {
EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(0.875e-9));
EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(1.000e-9));
- EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(-0.124999999e-9));
+ EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(std::nextafter(-0.125e-9, 0)));
EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.125e-9));
EXPECT_EQ(-absl::Nanoseconds(1) / 4, absl::Seconds(-0.250e-9));
EXPECT_EQ(-absl::Nanoseconds(1) / 2, absl::Seconds(-0.375e-9));
diff --git a/absl/time/time.h b/absl/time/time.h
index 2df68581..48982df4 100644
--- a/absl/time/time.h
+++ b/absl/time/time.h
@@ -1352,7 +1352,7 @@ constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
inline Duration MakePosDoubleDuration(double n) {
const int64_t int_secs = static_cast<int64_t>(n);
const uint32_t ticks = static_cast<uint32_t>(
- (n - static_cast<double>(int_secs)) * kTicksPerSecond + 0.5);
+ std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond));
return ticks < kTicksPerSecond
? MakeDuration(int_secs, ticks)
: MakeDuration(int_secs + 1, ticks - kTicksPerSecond);
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-02 20:44:40 +0000