Export of internal Abseil changes

--
341670bce317dd6af8d3c066970230591a47e80c by Martijn Vels <mvels@google.com>:

Change GetStack() and GetParentStack() to return absl::Span

PiperOrigin-RevId: 368765721

--
6aaab9536d6957303c7aba100c3afaa6fb0ea2c8 by Martijn Vels <mvels@google.com>:

Remove locking from parent stack.

This change removes the need to lock all access to `parent_stack' by making the 'copy constructor' logic specify the 'copied from' CordzInfo (where available) to the TrackCord function, after which parent_stack is immutable.

PiperOrigin-RevId: 368760630

--
b19e2059cada35a8ede994833018edac94de6ddc by Martijn Vels <mvels@google.com>:

Add cordz instrumentation to Cord

PiperOrigin-RevId: 368746225

--
67b8bbf980f0f4e1db79aa32968e9a715a09b51a by Martijn Vels <mvels@google.com>:

Create ABSL_INTERNAL_CORDZ_ENABLED define controlling when Cordz code is enabled

There are specific builds and condtions under which we don't support cordz sampling, which is per this change represented by ABSL_INTERNAL_CORDZ_ENABLED being defined.

PiperOrigin-RevId: 368731603

--
8cbfe0e3169637a620f4b66ad2bc2ce340879cb0 by Martijn Vels <mvels@google.com>:

Add a `rep` property to CordzInfo to be managed by Cord logic.

This change adds a `rep` property to CordzInfo, which is intended to be used by collection logic.

Mini design:
Cord invokes TrackCord() providing the active 'root' cordrep of the newly sampled Cord, returning a CordzInfo with a weak (uncounted) reference to this root. Cord invokes `SetCordRep()` each time the root cordrep of the sampled Cord is updated while holding `mutex()`. Cord must also obtain `mutex()` _before_ removing a reference on the old root. i.e.: Cord must guarantee that the (weak) reference held in CordzInfo is at all times valid.

CordzInfo collection code can then safely obtain a (reference counted) rep pointer by adding a reference to `rep_` while holding `mutex()`. This requires only a very brief critical section inside CordzInfo logic, minimizing contention with concurrent Cord updates.

Cord code should typically obtain and hold `mutex()` for the entirety of each mutating Cord operation on a sampled cord. As Cord is thread compatible, it never competes on the lock with any other thread. The only possible concurrent access is from Cordz collection code, which should be a relatively rare event.

PiperOrigin-RevId: 368673758

--
1255120dce2bdd6b4205a34a0e555e0b74b6152f by Martijn Vels <mvels@google.com>:

Remove 'depth' from active recorded metrics.

Going forward we do not 'live' record depth (and size), but will observe these at collection time only.

PiperOrigin-RevId: 368636572

--
83e5146e35f221736b49e9f0a8805f8c159a51db by Martijn Vels <mvels@google.com>:

Make cordz targets visible in OSS

PiperOrigin-RevId: 368615010

--
dcb16a4f1239151f0a8c70a8cfeb29dabbd113b8 by Martijn Vels <mvels@google.com>:

Internal cleanup

PiperOrigin-RevId: 368514666
GitOrigin-RevId: 341670bce317dd6af8d3c066970230591a47e80c
Change-Id: I94cecfbbd441eb386f99fc5186c468a7a5538862

1 files changed, 237 insertions, 0 deletions

diff --git a/absl/strings/internal/cordz_info_test.cc b/absl/strings/internal/cordz_info_test.cc
new file mode 100644
index 00000000..be20e4a4
--- /dev/null
+++ b/absl/strings/internal/cordz_info_test.cc
@@ -0,0 +1,237 @@
+// Copyright 2019 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 "absl/strings/internal/cordz_info.h"
+
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/debugging/symbolize.h"
+#include "absl/strings/internal/cord_rep_flat.h"
+#include "absl/strings/internal/cordz_handle.h"
+#include "absl/strings/str_cat.h"
+#include "absl/types/span.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace cord_internal {
+namespace {
+
+using ::testing::ElementsAre;
+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); }
+};
+
+// Local less verbose helper
+std::vector<const CordzHandle*> DeleteQueue() {
+  return CordzHandle::DiagnosticsGetDeleteQueue();
+}
+
+std::string FormatStack(absl::Span<void* const> raw_stack) {
+  static constexpr size_t buf_size = 1 << 14;
+  std::unique_ptr<char[]> buf(new char[buf_size]);
+  std::string output;
+  for (void* stackp : raw_stack) {
+    if (absl::Symbolize(stackp, buf.get(), buf_size)) {
+      absl::StrAppend(&output, "    ", buf.get(), "\n");
+    }
+  }
+  return output;
+}
+
+TEST(CordzInfoTest, TrackCord) {
+  TestCordRep rep;
+  CordzInfo* info = CordzInfo::TrackCord(rep.rep);
+  ASSERT_THAT(info, Ne(nullptr));
+  EXPECT_FALSE(info->is_snapshot());
+  EXPECT_THAT(CordzInfo::Head(CordzSnapshot()), Eq(info));
+  EXPECT_THAT(info->GetCordRepForTesting(), Eq(rep.rep));
+  CordzInfo::UntrackCord(info);
+}
+
+TEST(CordzInfoTest, UntrackCord) {
+  TestCordRep rep;
+  CordzInfo* info = CordzInfo::TrackCord(rep.rep);
+
+  CordzSnapshot snapshot;
+  CordzInfo::UntrackCord(info);
+  EXPECT_THAT(CordzInfo::Head(CordzSnapshot()), Eq(nullptr));
+  EXPECT_THAT(info->GetCordRepForTesting(), Eq(nullptr));
+  EXPECT_THAT(DeleteQueue(), ElementsAre(info, &snapshot));
+}
+
+TEST(CordzInfoTest, SetCordRep) {
+  TestCordRep rep;
+  CordzInfo* info = CordzInfo::TrackCord(rep.rep);
+
+  TestCordRep rep2;
+  {
+    absl::MutexLock lock(&info->mutex());
+    info->SetCordRep(rep2.rep);
+  }
+  EXPECT_THAT(info->GetCordRepForTesting(), Eq(rep2.rep));
+
+  CordzInfo::UntrackCord(info);
+}
+
+#if GTEST_HAS_DEATH_TEST
+
+TEST(CordzInfoTest, SetCordRepRequiresMutex) {
+  TestCordRep rep;
+  CordzInfo* info = CordzInfo::TrackCord(rep.rep);
+  TestCordRep rep2;
+  EXPECT_DEATH(info->SetCordRep(rep2.rep), ".*");
+  CordzInfo::UntrackCord(info);
+}
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+TEST(CordzInfoTest, TrackUntrackHeadFirstV2) {
+  TestCordRep rep;
+  CordzSnapshot snapshot;
+  EXPECT_THAT(CordzInfo::Head(snapshot), Eq(nullptr));
+
+  CordzInfo* info1 = CordzInfo::TrackCord(rep.rep);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(info1));
+  EXPECT_THAT(info1->Next(snapshot), Eq(nullptr));
+
+  CordzInfo* info2 = CordzInfo::TrackCord(rep.rep);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(info2));
+  EXPECT_THAT(info2->Next(snapshot), Eq(info1));
+  EXPECT_THAT(info1->Next(snapshot), Eq(nullptr));
+
+  CordzInfo::UntrackCord(info2);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(info1));
+  EXPECT_THAT(info1->Next(snapshot), Eq(nullptr));
+
+  CordzInfo::UntrackCord(info1);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(nullptr));
+}
+
+TEST(CordzInfoTest, TrackUntrackTailFirstV2) {
+  TestCordRep rep;
+  CordzSnapshot snapshot;
+  EXPECT_THAT(CordzInfo::Head(snapshot), Eq(nullptr));
+
+  CordzInfo* info1 = CordzInfo::TrackCord(rep.rep);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(info1));
+  EXPECT_THAT(info1->Next(snapshot), Eq(nullptr));
+
+  CordzInfo* info2 = CordzInfo::TrackCord(rep.rep);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(info2));
+  EXPECT_THAT(info2->Next(snapshot), Eq(info1));
+  EXPECT_THAT(info1->Next(snapshot), Eq(nullptr));
+
+  CordzInfo::UntrackCord(info1);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(info2));
+  EXPECT_THAT(info2->Next(snapshot), Eq(nullptr));
+
+  CordzInfo::UntrackCord(info2);
+  ASSERT_THAT(CordzInfo::Head(snapshot), Eq(nullptr));
+}
+
+TEST(CordzInfoTest, StackV2) {
+  TestCordRep rep;
+  // kMaxStackDepth is intentionally less than 64 (which is the max depth that
+  // Cordz will record) because if the actual stack depth is over 64
+  // (which it is on Apple platforms) then the expected_stack will end up
+  // catching a few frames at the end that the actual_stack didn't get and
+  // it will no longer be subset. At the time of this writing 58 is the max
+  // that will allow this test to pass (with a minimum os version of iOS 9), so
+  // rounded down to 50 to hopefully not run into this in the future if Apple
+  // makes small modifications to its testing stack. 50 is sufficient to prove
+  // that we got a decent stack.
+  static constexpr int kMaxStackDepth = 50;
+  CordzInfo* info = CordzInfo::TrackCord(rep.rep);
+  std::vector<void*> local_stack;
+  local_stack.resize(kMaxStackDepth);
+  // In some environments we don't get stack traces. For example in Android
+  // absl::GetStackTrace will return 0 indicating it didn't find any stack. The
+  // resultant formatted stack will be "", but that still equals the stack
+  // recorded in CordzInfo, which is also empty. The skip_count is 1 so that the
+  // line number of the current stack isn't included in the HasSubstr check.
+  local_stack.resize(absl::GetStackTrace(local_stack.data(), kMaxStackDepth,
+                                         /*skip_count=*/1));
+
+  std::string got_stack = FormatStack(info->GetStack());
+  std::string expected_stack = FormatStack(local_stack);
+  // If TrackCord is inlined, got_stack should match expected_stack. If it isn't
+  // inlined, got_stack should include an additional frame not present in
+  // expected_stack. Either way, expected_stack should be a substring of
+  // got_stack.
+  EXPECT_THAT(got_stack, HasSubstr(expected_stack));
+
+  CordzInfo::UntrackCord(info);
+}
+
+// Local helper functions to get different stacks for child and parent.
+CordzInfo* TrackChildCord(CordRep* rep, const CordzInfo* parent) {
+  return CordzInfo::TrackCord(rep, parent);
+}
+CordzInfo* TrackParentCord(CordRep* rep) {
+  return CordzInfo::TrackCord(rep);
+}
+
+TEST(CordzInfoTest, ParentStackV2) {
+  TestCordRep rep;
+  CordzInfo* info_parent = TrackParentCord(rep.rep);
+  CordzInfo* info_child = TrackChildCord(rep.rep, info_parent);
+
+  std::string stack = FormatStack(info_parent->GetStack());
+  std::string parent_stack = FormatStack(info_child->GetParentStack());
+  EXPECT_THAT(stack, Eq(parent_stack));
+
+  CordzInfo::UntrackCord(info_parent);
+  CordzInfo::UntrackCord(info_child);
+}
+
+TEST(CordzInfoTest, ParentStackEmpty) {
+  TestCordRep rep;
+  CordzInfo* info = TrackChildCord(rep.rep, nullptr);
+  EXPECT_TRUE(info->GetParentStack().empty());
+  CordzInfo::UntrackCord(info);
+}
+
+TEST(CordzInfoTest, CordzStatisticsV2) {
+  TestCordRep rep;
+  CordzInfo* info = TrackParentCord(rep.rep);
+
+  CordzStatistics expected;
+  expected.size = 100;
+  info->RecordMetrics(expected.size);
+
+  CordzStatistics actual = info->GetCordzStatistics();
+  EXPECT_EQ(actual.size, expected.size);
+
+  CordzInfo::UntrackCord(info);
+}
+
+}  // namespace
+}  // namespace cord_internal
+ABSL_NAMESPACE_END
+}  // namespace absl