Add process lifetime annotations to stack samples.

components/metrics/call_stack_profile_metrics_provider.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/metrics/call_stack_profile_metrics_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 15 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
 
 using base::StackSamplingProfiler;
 
 namespace metrics {
 
 namespace {
 
+// Provide a mapping from the C++ "enum" definition of various process phases
+// to the equivalent protobuf "enum" definition. This table-lookup conversion
+// allows for the implementation to evolve and still be compatible with the
+// protobuf -- even if there are ever more than 32 defined proto values, though
+// never more than 32 could be in-use in a given C++ version of the code.
+const ProcessPhase
+    kProtoPhases[CallStackProfileMetricsProvider::PHASES_MAX_VALUE] = {
+        ProcessPhase::MAIN_LOOP_START,
+        ProcessPhase::MAIN_NAVIGATION_START,
+        ProcessPhase::MAIN_NAVIGATION_FINISHED,
+        ProcessPhase::FIRST_NONEMPTY_PAINT,
+
+        ProcessPhase::SHUTDOWN_START,
+};
+
 // ProfilesState --------------------------------------------------------------
 
 // A set of profiles and the CallStackProfileMetricsProvider state associated
 // with them.
 struct ProfilesState {
   ProfilesState(const CallStackProfileParams& params,
                 base::StackSamplingProfiler::CallStackProfiles profiles,
                 base::TimeTicks start_timestamp);
   ProfilesState(ProfilesState&&);
   ProfilesState& operator=(ProfilesState&&);
@@ skipping 170 matching lines @@
   memcpy(&name_bytes[0], &basename[0], basename_length_in_bytes);
   return base::HashMetricName(name_bytes);
 }
 
 // Transcode |sample| into |proto_sample|, using base addresses in |modules| to
 // compute module instruction pointer offsets.
 void CopySampleToProto(
     const StackSamplingProfiler::Sample& sample,
     const std::vector<StackSamplingProfiler::Module>& modules,
     CallStackProfile::Sample* proto_sample) {
-  for (const StackSamplingProfiler::Frame& frame : sample) {
+  for (const StackSamplingProfiler::Frame& frame : sample.frames) {
     CallStackProfile::Entry* entry = proto_sample->add_entry();
     // A frame may not have a valid module. If so, we can't compute the
     // instruction pointer offset, and we don't want to send bare pointers, so
     // leave call_stack_entry empty.
     if (frame.module_index == StackSamplingProfiler::Frame::kUnknownModuleIndex)
       continue;
     int64_t module_offset =
         reinterpret_cast<const char*>(frame.instruction_pointer) -
         reinterpret_cast<const char*>(modules[frame.module_index].base_address);
     DCHECK_GE(module_offset, 0);
     entry->set_address(static_cast<uint64_t>(module_offset));
     entry->set_module_id_index(frame.module_index);
   }
 }
 
+// Transcode Sample annotations into protobuf fields. The C++ code uses a bit-
+// field with each bit correspondirg to an entry in an enumeration while the

[Mike Wittman, 2016/11/16 22:36:09]

nit: corresponding

[bcwhite, 2016/11/16 23:10:49]

Done.

+// protobuf uses a repeated field of individual values. Conversion tables
+// allow for arbitrary mapping, though no more than 32 in any given version
+// of the code.
+void CopyAnnotationsToProto(uint32_t new_phases,
+                            CallStackProfile::Sample* sample_proto) {
+  for (size_t bit = 0; new_phases != 0 && bit < sizeof(new_phases) * 8; ++bit) {
+    const uint32_t flag = 1U << bit;
+    if (new_phases & flag) {
+      if (bit >= arraysize(kProtoPhases)) {
+        NOTREACHED();
+        continue;
+      }
+      sample_proto->add_process_phase(kProtoPhases[bit]);
+      new_phases ^= flag;  // Bit is set so XOR will clear it.
+    }
+  }
+}
+
 // Transcode |profile| into |proto_profile|.
 void CopyProfileToProto(
     const StackSamplingProfiler::CallStackProfile& profile,
     CallStackProfileParams::SampleOrderingSpec ordering_spec,
     CallStackProfile* proto_profile) {
   if (profile.samples.empty())
     return;
 
   if (ordering_spec == CallStackProfileParams::PRESERVE_ORDER) {
     // Collapse only consecutive repeated samples together.
     CallStackProfile::Sample* current_sample_proto = nullptr;
+    uint32_t phases = 0;
     for (auto it = profile.samples.begin(); it != profile.samples.end(); ++it) {
       if (!current_sample_proto || *it != *(it - 1)) {
         current_sample_proto = proto_profile->add_sample();
         CopySampleToProto(*it, profile.modules, current_sample_proto);
         current_sample_proto->set_count(1);
+        CopyAnnotationsToProto(it->process_phases & ~phases,
+                               current_sample_proto);
+        phases = it->process_phases;
       } else {
         current_sample_proto->set_count(current_sample_proto->count() + 1);
       }
     }
   } else {
     // Collapse all repeated samples together.
     std::map<StackSamplingProfiler::Sample, int> sample_index;
     for (auto it = profile.samples.begin(); it != profile.samples.end(); ++it) {
       auto location = sample_index.find(*it);

[Alexei Svitkine (slow), 2016/11/16 19:10:24]

This doesn't need any extra logic to split samples based on process_phases
because that logic lives in the iterator == functions, is that right? Please add
a comment to that extent both here on above line 290.

[Mike Wittman, 2016/11/16 22:36:09]

I believe this does need to split samples based on process_phases. The
server-side decoding of the process phases must be the same for both MAY_SHUFFLE
and PRESERVE_ORDER, since the ordering spec is not encoded in the protobuf. I
don't think a single decoding algorithm is feasible unless the MAY_SHUFFLE
stacks are encoded in the same manner.

[bcwhite, 2016/11/16 23:10:49]

Done.

[bcwhite, 2016/11/16 23:10:49]

Splitting on phase is already done because, as Alexei said, the comparator for
Sample checks it.

However, the decoding algorithm for phases does need to be consistent so I'll do
that.

       if (location == sample_index.end()) {
         CallStackProfile::Sample* sample_proto = proto_profile->add_sample();
         CopySampleToProto(*it, profile.modules, sample_proto);
         sample_proto->set_count(1);
+        CopyAnnotationsToProto(it->process_phases, sample_proto);
         sample_index.insert(
             std::make_pair(
                 *it, static_cast<int>(proto_profile->sample().size()) - 1));
       } else {
         CallStackProfile::Sample* sample_proto =
             proto_profile->mutable_sample()->Mutable(location->second);
         sample_proto->set_count(sample_proto->count() + 1);
       }
     }
   }
@@ skipping 162 matching lines @@
 
 // static
 bool CallStackProfileMetricsProvider::IsReportingEnabledByFieldTrial() {
   const std::string group_name = base::FieldTrialList::FindFullName(
       CallStackProfileMetricsProvider::kFieldTrialName);
   return group_name ==
       CallStackProfileMetricsProvider::kReportProfilesGroupName;
 }
 
 }  // namespace metrics