Add searching features to new TraceEventVector class for tests.

base/test/trace_event_analyzer.cc

 // Copyright (c) 2011 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 "base/test/trace_event_analyzer.h"
 
 #include <algorithm>
 #include <math.h>
 
 #include "base/json/json_reader.h"
@@ skipping 597 matching lines @@
       number_(0) {
   type_ = (unary_op < OP_ADD ?
            QUERY_BOOLEAN_OPERATOR : QUERY_ARITHMETIC_OPERATOR);
 }
 
 namespace {
 
 // Search |events| for |query| and add matches to |output|.
 size_t FindMatchingEvents(const std::vector<TraceEvent>& events,
                           const Query& query,
-                          TraceAnalyzer::TraceEventVector* output) {
+                          TraceEventVector* output) {
   for (size_t i = 0; i < events.size(); ++i) {
     if (query.Evaluate(events[i]))
       output->push_back(&events[i]);
   }
   return output->size();
 }
 
 bool ParseEventsFromJson(const std::string& json,
                          std::vector<TraceEvent>* output) {
   scoped_ptr<base::Value> root;
@@ skipping 12 matching lines @@
       else
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace
 
+// TraceEventVector
+
+bool TraceEventVector::GetRateStats(RateStats* stats) {
+  // Need at least 3 events to calculate rate stats.
+  if (size() < 3) {
+    LOG(ERROR) << "Not enough events: " << size();
+    return false;
+  }
+
+  std::vector<double> deltas;
+  double delta_sum = 0.0;
+  size_t num_deltas = size() - 1;
+  for (size_t i = 0; i < num_deltas; ++i) {
+    double delta = at(i + 1)->timestamp - at(i)->timestamp;
+    if (delta < 0.0) {
+      LOG(ERROR) << "Events are out of order";
+      return false;
+    }
+    deltas.push_back(delta);
+    delta_sum += delta;
+  }
+
+  stats->min_us = *std::min_element(deltas.begin(), deltas.end());
+  stats->max_us = *std::max_element(deltas.begin(), deltas.end());
+  stats->mean_us = delta_sum / static_cast<double>(num_deltas);
+
+  double sum_mean_offsets_squared = 0.0;
+  for (size_t i = 0; i < num_deltas; ++i) {
+    double offset = fabs(deltas[i] - stats->mean_us);
+    sum_mean_offsets_squared += offset * offset;
+  }
+  stats->standard_deviation_us =

[Paweł Hajdan Jr., 2011/12/12 17:21:51]

Isn't this standard deviation code being duplicated? If so, please extract the
common parts.

[jbates, 2011/12/12 22:00:32]

This is just a code move, so no duplication.

+      sum_mean_offsets_squared / static_cast<double>(num_deltas - 1);
+
+  return true;
+}
+
+bool TraceEventVector::FindFirstOf(Query query,
+                                   size_t position,
+                                   size_t* return_index) const {
+  for (size_t i = position; i < size(); ++i) {
+    if (query.Evaluate(*at(i))) {
+      *return_index = i;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool TraceEventVector::FindLastOf(Query query,
+                                  size_t position,
+                                  size_t* return_index) const {
+  if (empty())
+    return false;
+  position = (position < size()) ? position : size() - 1;
+  for (;;) {

[Paweł Hajdan Jr., 2011/12/12 17:21:51]

nit: Why not "while (true)"? It's generally more descriptive.

[jbates, 2011/12/12 22:00:32]

Grepping base/ for 'for (;;)' turns up slightly more occurrences than 'while
(true)' although both are used throughout our code. I guess this is left to
personal preference. I've read that MSVC can generate better code with for (;;).
It also is possible to get compiler warnings with while (true) (see
http://msdn.microsoft.com/en-us/library/6t66728h(v=vs.80).aspx), but I guess we
disable that warning.

+    if (query.Evaluate(*at(position))) {
+      *return_index = position;
+      return true;
+    }
+    if (position == 0)
+      return false;
+    --position;
+  }
+  return false;
+}
+
+bool TraceEventVector::FindClosest(Query query,
+                                   size_t position,
+                                   size_t* return_closest,
+                                   size_t* return_second_closest) const {
+  if (empty() || position >= size())
+    return false;
+  size_t closest = size();
+  size_t second_closest = size();
+  for (size_t i = 0; i < size(); ++i) {
+    if (!query.Evaluate(*at(i)))
+      continue;
+    if (closest == size()) {
+      closest = i;
+      continue;
+    }
+    if (fabs(at(i)->timestamp - at(position)->timestamp) <
+        fabs(at(closest)->timestamp - at(position)->timestamp)) {
+      second_closest = closest;
+      closest = i;
+    } else if (second_closest == size()) {
+      second_closest = i;
+    }
+  }
+
+  if (closest < size() &&
+      (!return_second_closest || second_closest < size())) {
+    *return_closest = closest;
+    if (return_second_closest)
+      *return_second_closest = second_closest;
+    return true;
+  }
+
+  return false;
+}
+
+int TraceEventVector::CountMatches(Query query,
+                                   size_t begin_position,
+                                   size_t end_position) const {
+  if (begin_position >= size())
+    return 0;
+  end_position = (end_position < size()) ? end_position : size();
+  int count = 0;
+  for (size_t i = begin_position; i < end_position; ++i) {
+    if (query.Evaluate(*at(i)))
+      ++count;
+  }
+  return count;
+}
+
 // TraceAnalyzer
 
 TraceAnalyzer::TraceAnalyzer() : allow_assocation_changes_(true) {
 }
 
 TraceAnalyzer::~TraceAnalyzer() {
 }
 
 // static
 TraceAnalyzer* TraceAnalyzer::Create(const std::string& json_events) {
@@ skipping 71 matching lines @@
           break;
         }
 
         // Not a match, restore original other and continue.
         begin_event.other_event = other_backup;
       }
     }
   }
 }
 
+void TraceAnalyzer::MergeAssociatedEventArgs() {
+  for (size_t i = 0; i < raw_events_.size(); ++i) {
+    if (raw_events_[i].other_event) {
+      raw_events_[i].arg_numbers.insert(
+          raw_events_[i].other_event->arg_numbers.begin(),
+          raw_events_[i].other_event->arg_numbers.end());
+      raw_events_[i].arg_strings.insert(
+          raw_events_[i].other_event->arg_strings.begin(),
+          raw_events_[i].other_event->arg_strings.end());
+    }
+  }
+}
+
 size_t TraceAnalyzer::FindEvents(const Query& query, TraceEventVector* output) {
   allow_assocation_changes_ = false;
   output->clear();
   return FindMatchingEvents(raw_events_, query, output);
 }
 
 const TraceEvent* TraceAnalyzer::FindOneEvent(const Query& query) {
   TraceEventVector output;
   if (FindEvents(query, &output) > 0)
     return output.front();
   return NULL;
 }
 
 const std::string& TraceAnalyzer::GetThreadName(
     const TraceEvent::ProcessThreadID& thread) {
   // If thread is not found, just add and return empty string.
   return thread_names_[thread];
 }
 
-bool TraceAnalyzer::GetRateStats(const TraceEventVector& events, Stats* stats) {
-  // Need at least 3 events to calculate rate stats.
-  if (events.size() < 3) {
-    LOG(ERROR) << "Not enough events: " << events.size();
-    return false;
-  }
-
-  std::vector<double> deltas;
-  double delta_sum = 0.0;
-  size_t num_deltas = events.size() - 1;
-  for (size_t i = 0; i < num_deltas; ++i) {
-    double delta = events[i + 1]->timestamp - events[i]->timestamp;
-    if (delta < 0.0) {
-      LOG(ERROR) << "Events are out of order";
-      return false;
-    }
-    deltas.push_back(delta);
-    delta_sum += delta;
-  }
-
-  stats->min_us = *std::min_element(deltas.begin(), deltas.end());
-  stats->max_us = *std::max_element(deltas.begin(), deltas.end());
-  stats->mean_us = delta_sum / static_cast<double>(num_deltas);
-
-  double sum_mean_offsets_squared = 0.0;
-  for (size_t i = 0; i < num_deltas; ++i) {
-    double offset = fabs(deltas[i] - stats->mean_us);
-    sum_mean_offsets_squared += offset * offset;
-  }
-  stats->standard_deviation_us =
-      sum_mean_offsets_squared / static_cast<double>(num_deltas - 1);
-
-  return true;
-}
-
 void TraceAnalyzer::ParseMetadata() {
   for (size_t i = 0; i < raw_events_.size(); ++i) {
     TraceEvent& this_event = raw_events_[i];
     // Check for thread name metadata.
     if (this_event.phase != TRACE_EVENT_PHASE_METADATA ||
         this_event.name != "thread_name")
       continue;
     std::map<std::string, std::string>::const_iterator string_it =
         this_event.arg_strings.find("name");
     if (string_it != this_event.arg_strings.end())
       thread_names_[this_event.thread] = string_it->second;
   }
 }
 
 }  // namespace trace_analyzer