add classes trace_analyzer::Query and TraceAnalyzer to make it easy to search through trace data

base/debug/trace_event_test_utils.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 <algorithm>
+
+#include "base/debug/trace_event_test_utils.h"
+
+namespace base {
+namespace debug {
+
+namespace trace {
+
+QueryNode::QueryNode(const Query& query) : query_(query) {
+}
+
+QueryNode::~QueryNode() {
+}
+
+Query::Query(TraceEventMember member)
+    : type_(QUERY_EVENT_MEMBER),
+      operator_(OP_INVALID),
+      member_(member),
+      number_(0),
+      is_pattern_(false) {
+}
+
+Query::Query(TraceEventMember member, const std::string& arg_name)
+    : type_(QUERY_EVENT_MEMBER),
+      operator_(OP_INVALID),
+      member_(member),
+      number_(0),
+      string_(arg_name),
+      is_pattern_(false) {
+}
+
+Query::Query(const std::string& str)
+    : type_(QUERY_STRING),
+      operator_(OP_INVALID),
+      member_(EVENT_INVALID),
+      number_(0),
+      string_(str),
+      is_pattern_(false) {
+}
+
+Query::Query(const char* str) {
+  *this = Query(std::string(str));
+}
+
+Query::Query(double num)
+    : type_(QUERY_NUMBER),
+      operator_(OP_INVALID),
+      member_(EVENT_INVALID),
+      number_(num),
+      is_pattern_(false) {
+}
+
+Query::Query(float num) {
+  *this = Query(static_cast<double>(num));
+}
+
+Query::Query(int num) {
+  *this = Query(static_cast<double>(num));
+}
+
+Query::Query(uint32 num) {
+  *this = Query(static_cast<double>(num));
+}
+
+Query::Query(bool boolean) {
+  *this = Query(static_cast<double>(boolean ? 1 : 0));
+}
+
+Query::Query(TraceEventPhase phase) {
+  *this = Query(static_cast<double>(phase));
+}
+
+Query::Query(const Query& query)
+    : type_(query.type_),
+      operator_(query.operator_),
+      left_(query.left_),
+      right_(query.right_),
+      member_(query.member_),
+      number_(query.number_),
+      string_(query.string_),
+      is_pattern_(query.is_pattern_) {
+}
+
+Query::~Query() {
+}
+
+// static
+Query Query::Pattern(const std::string& pattern) {
+  Query query(pattern);
+  query.is_pattern_ = true;
+  return query;
+}
+
+bool Query::Evaluate(const TestTraceEvent& event) const {
+  // First check for values that can convert to bool.
+
+  // double is true if != 0:
+  double bool_value = 0.0;
+  bool is_bool = GetAsDouble(event, &bool_value);
+  if (is_bool)
+    return (bool_value != 0.0);
+
+  // string is true if it is non-empty:
+  std::string str_value;
+  bool is_str = GetAsString(event, &str_value);
+  if (is_str)
+    return !str_value.empty();
+
+  CHECK(type_ == QUERY_BOOLEAN_OPERATOR)
+      << "Invalid query: missing boolean expression";
+  CHECK(left_.get() && (right_.get() || is_unary_operator()));
+
+  if (operator_ < OP_AND) {
+    CHECK(left().is_value() && right().is_value())
+        << "Invalid query: comparison operator used between event member and "
+           "value.";
+    bool compare_result = false;
+    if (CompareAsDouble(event, &compare_result))
+      return compare_result;
+    else if (CompareAsString(event, &compare_result))
+      return compare_result;
+    return false;
+  } else {
+    switch (operator_) {
+      case OP_AND:
+        return left().Evaluate(event) && right().Evaluate(event);
+      case OP_OR:
+        return left().Evaluate(event) || right().Evaluate(event);
+      case OP_NOT:
+        return !left().Evaluate(event);
+      default:
+        NOTREACHED();
+    }
+  }
+
+  NOTREACHED();
+  return false;
+}
+
+bool Query::CompareAsDouble(const TestTraceEvent& event, bool* result) const {
+  double lhs, rhs;
+  if (!left().GetAsDouble(event, &lhs) || !right().GetAsDouble(event, &rhs))
+    return false;
+  switch (operator_) {
+    case OP_EQ:
+      *result = (lhs == rhs);
+      return true;
+    case OP_NE:
+      *result = (lhs != rhs);
+      return true;
+    case OP_LT:
+      *result = (lhs < rhs);
+      return true;
+    case OP_LE:
+      *result = (lhs <= rhs);
+      return true;
+    case OP_GT:
+      *result = (lhs > rhs);
+      return true;
+    case OP_GE:
+      *result = (lhs >= rhs);
+      return true;
+    default:
+      NOTREACHED();
+      return false;
+  }
+  return true;
+}
+
+bool Query::CompareAsString(const TestTraceEvent& event, bool* result) const {
+  std::string lhs, rhs;
+  if (!left().GetAsString(event, &lhs) || !right().GetAsString(event, &rhs))
+    return false;
+  switch (operator_) {
+    case OP_EQ:
+      if (right().is_pattern_)
+        *result = MatchPattern(lhs, rhs);
+      else if (left().is_pattern_)
+        *result = MatchPattern(rhs, lhs);
+      else
+        *result = (lhs == rhs);
+      return true;
+    case OP_NE:
+      if (right().is_pattern_)
+        *result = !MatchPattern(lhs, rhs);
+      else if (left().is_pattern_)
+        *result = !MatchPattern(rhs, lhs);
+      else
+        *result = (lhs != rhs);
+      return true;
+    case OP_LT:
+      *result = (lhs < rhs);
+      return true;
+    case OP_LE:
+      *result = (lhs <= rhs);
+      return true;
+    case OP_GT:
+      *result = (lhs > rhs);
+      return true;
+    case OP_GE:
+      *result = (lhs >= rhs);
+      return true;
+    default:
+      NOTREACHED();
+      return false;
+  }
+  return true;
+}
+
+bool Query::EvaluateArithmeticOperator(const TestTraceEvent& event,
+                                       double* num) const {
+  CHECK(type_ == QUERY_ARITHMETIC_OPERATOR);
+  CHECK(left_.get() && (right_.get() || is_unary_operator()));
+
+  double lhs = 0, rhs = 0;
+  if (!left().GetAsDouble(event, &lhs))
+    return false;
+  if (!is_unary_operator() && !right().GetAsDouble(event, &rhs))
+    return false;
+
+  switch (operator_) {
+    case OP_ADD:
+      *num = lhs + rhs;
+      break;
+    case OP_SUB:
+      *num = lhs - rhs;
+      break;
+    case OP_MUL:
+      *num = lhs * rhs;
+      break;
+    case OP_DIV:
+      *num = lhs / rhs;
+      break;
+    case OP_MOD:
+      *num = static_cast<double>(static_cast<int64>(lhs) %
+                                 static_cast<int64>(rhs));
+      break;
+    case OP_NEGATE:
+      *num = -lhs;
+      break;
+    default:
+      NOTREACHED();
+      return false;
+  }
+
+  return true;
+}
+
+bool Query::GetAsDouble(const TestTraceEvent& event, double* num) const {
+  TraceValue value;
+  switch (type_) {
+    case QUERY_ARITHMETIC_OPERATOR:
+      return EvaluateArithmeticOperator(event, num);
+    case QUERY_EVENT_MEMBER:
+      value = GetMemberValue(event);
+      if(value.type() == TraceValue::TRACE_TYPE_DOUBLE) {
+        *num = value.as_double();
+        return true;
+      }
+      return false;
+    case QUERY_NUMBER:
+      *num = number_;
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool Query::GetAsString(const TestTraceEvent& event, std::string* str) const {
+  TraceValue value;
+  switch (type_) {
+    case QUERY_EVENT_MEMBER:
+      value = GetMemberValue(event);
+      if(value.is_string()) {
+        *str = value.as_string();
+        return true;
+      }
+      return false;
+    case QUERY_STRING:
+      *str = string_;
+      return true;
+    default:
+      return false;
+  }
+}
+
+TraceValue Query::GetMemberValue(const TestTraceEvent& event) const {
+  CHECK(type_ == QUERY_EVENT_MEMBER);
+
+  // This could be a request for a member of |event| or a member of |event|'s
+  // associated event. Store the target event in the_event:
+  const TestTraceEvent* the_event = (member_ < OTHER_PID) ?
+      &event : event.other_event;
+
+  // Request for member of associated event, but there is no associated event.
+  if (!the_event)
+    return TraceValue();
+
+  switch (member_) {
+    case EVENT_PID:
+    case OTHER_PID:
+      return static_cast<double>(the_event->pid_tid.pid);
+    case EVENT_TID:
+    case OTHER_TID:
+      return static_cast<double>(the_event->pid_tid.tid);
+    case EVENT_TIME:
+    case OTHER_TIME:
+      return the_event->timestamp;
+    case EVENT_DURATION:
+      {
+        double duration;
+        if (the_event->GetDuration(&duration))
+          return duration;
+        else
+          return TraceValue();
+      }
+    case EVENT_PHASE:
+    case OTHER_PHASE:
+      return static_cast<double>(the_event->phase);
+    case EVENT_CATEGORY:
+    case OTHER_CATEGORY:
+      return the_event->category;
+    case EVENT_NAME:
+    case OTHER_NAME:
+      return the_event->name;
+    case EVENT_HAS_ARG:
+    case OTHER_HAS_ARG:
+      // Search for the argument name and return true if found.
+      return static_cast<double>((the_event->arg_strings.find(string_) !=
+                                  the_event->arg_strings.end()) ||
+                                 (the_event->arg_numbers.find(string_) !=
+                                  the_event->arg_numbers.end()) ? 1 : 0);
+    case EVENT_ARG:
+    case OTHER_ARG:
+      {
+        // Search for the argument name and return its value if found.
+
+        std::map<std::string, std::string>::const_iterator str_i =
+            the_event->arg_strings.find(string_);
+        if (str_i != the_event->arg_strings.end())
+          return str_i->second;
+
+        std::map<std::string, double>::const_iterator num_i =
+            the_event->arg_numbers.find(string_);
+        if (num_i != the_event->arg_numbers.end())
+          return num_i->second;
+
+        return TraceValue();
+      }
+    case EVENT_HAS_OTHER:
+      {
+        // return 1.0 (true) if the other event exists
+        double result = event.other_event ? 1.0 : 0.0;
+        return result;
+      }
+    default:
+      NOTREACHED();
+      return TraceValue();
+  }
+}
+
+const Query& Query::left() const {
+  return left_->query();
+}
+
+const Query& Query::right() const {
+  return right_->query();
+}
+
+Query Query::operator==(const Query& rhs) const {
+  return Query(*this, rhs, OP_EQ);
+}
+
+Query Query::operator!=(const Query& rhs) const {
+  return Query(*this, rhs, OP_NE);
+}
+
+Query Query::operator<(const Query& rhs) const {
+  return Query(*this, rhs, OP_LT);
+}
+
+Query Query::operator<=(const Query& rhs) const {
+  return Query(*this, rhs, OP_LE);
+}
+
+Query Query::operator>(const Query& rhs) const {
+  return Query(*this, rhs, OP_GT);
+}
+
+Query Query::operator>=(const Query& rhs) const {
+  return Query(*this, rhs, OP_GE);
+}
+
+Query Query::operator&&(const Query& rhs) const {
+  return Query(*this, rhs, OP_AND);
+}
+
+Query Query::operator||(const Query& rhs) const {
+  return Query(*this, rhs, OP_OR);
+}
+
+Query Query::operator!() const {
+  return Query(*this, OP_NOT);
+}
+
+Query Query::operator+(const Query& rhs) const {
+  return Query(*this, rhs, OP_ADD);
+}
+
+Query Query::operator-(const Query& rhs) const {
+  return Query(*this, rhs, OP_SUB);
+}
+
+Query Query::operator*(const Query& rhs) const {
+  return Query(*this, rhs, OP_MUL);
+}
+
+Query Query::operator/(const Query& rhs) const {
+  return Query(*this, rhs, OP_DIV);
+}
+
+Query Query::operator%(const Query& rhs) const {
+  return Query(*this, rhs, OP_MOD);
+}
+
+Query Query::operator-() const {
+  return Query(*this, OP_NEGATE);
+}
+
+
+Query::Query(const Query& left, const Query& right, Operator binary_op)
+    : operator_(binary_op),
+      left_(new QueryNode(left)),
+      right_(new QueryNode(right)),
+      member_(EVENT_INVALID),
+      number_(0) {
+  type_ = (binary_op < OP_ADD ?
+           QUERY_BOOLEAN_OPERATOR : QUERY_ARITHMETIC_OPERATOR);
+}
+
+Query::Query(const Query& left, Operator unary_op)
+    : operator_(unary_op),
+      left_(new QueryNode(left)),
+      member_(EVENT_INVALID),
+      number_(0) {
+  type_ = (unary_op < OP_ADD ?
+           QUERY_BOOLEAN_OPERATOR : QUERY_ARITHMETIC_OPERATOR);
+}
+
+}  // namespace trace
+
+namespace {
+
+// Search |events| for |query| and add matches to |output|.
+size_t FindMatchingEvents(const TraceAnalyzer::EventVector& events,
+                          const trace::Query& query,
+                          TraceAnalyzer::ConstEventPtrVector* output) {
+  for (size_t i = 0; i < events.size(); ++i) {
+    if (query.Evaluate(events[i]))
+      output->push_back(&events[i]);
+  }
+  return output->size();
+}
+
+}  // namespace
+
+TraceAnalyzer::TraceAnalyzer() {
+}
+
+TraceAnalyzer::TraceAnalyzer(const std::string& json_events) {
+  SetEvents(json_events);
+}
+
+TraceAnalyzer::TraceAnalyzer(const EventVector& events) {
+  SetEvents(events);
+}
+
+TraceAnalyzer::~TraceAnalyzer() {
+}
+
+void TraceAnalyzer::SetEvents(const std::string& json_events) {
+  TestTraceEvent::ParseEventsFromJson(json_events, &raw_events_);
+  std::stable_sort(raw_events_.begin(), raw_events_.end());
+  ParseMetadata();
+  SetDefaultAssociations();
+}
+
+void TraceAnalyzer::SetEvents(const EventVector& events) {
+  raw_events_ = events;
+  std::stable_sort(raw_events_.begin(), raw_events_.end());
+  ParseMetadata();
+  SetDefaultAssociations();
+}
+
+void TraceAnalyzer::SetDefaultAssociations() {
+  using namespace base::debug::trace;
+
+  Query begin(Query(EVENT_PHASE) == TRACE_EVENT_PHASE_BEGIN);
+  Query end(Query(EVENT_PHASE) == TRACE_EVENT_PHASE_END);
+  Query match(Query(EVENT_NAME) == Query(OTHER_NAME) &&
+              Query(EVENT_CATEGORY) == Query(OTHER_CATEGORY) &&
+              Query(EVENT_TID) == Query(OTHER_TID) &&
+              Query(EVENT_PID) == Query(OTHER_PID));
+
+  AssociateEvents(begin, end, match);
+}
+
+void TraceAnalyzer::ClearAssociations() {
+  for (size_t input_i = 0; input_i < raw_events_.size(); ++input_i)
+    raw_events_[input_i].other_event = NULL;
+}
+
+void TraceAnalyzer::AssociateEvents(const trace::Query& begin,
+                                    const trace::Query& end,
+                                    const trace::Query& match) {
+  // Search for matching begin/end event pairs. When a matching end is found,
+  // it is associated with the begin event.
+  std::vector<TestTraceEvent*> begin_stack;
+  for (size_t input_i = 0; input_i < raw_events_.size(); ++input_i) {
+
+    TestTraceEvent& this_event = raw_events_[input_i];
+
+    if (begin.Evaluate(this_event)) {
+      begin_stack.push_back(&this_event);
+    } else if (end.Evaluate(this_event)) {
+      // Search stack for matching begin, starting from end.
+      for (int si = static_cast<int>(begin_stack.size()) - 1; si >= 0; --si) {
+        TestTraceEvent& begin_event = *begin_stack[si];
+
+        // Temporarily set other to test against the match query.
+        const TestTraceEvent* other_backup = begin_event.other_event;
+        begin_event.set_other_event(&this_event);
+        if (match.Evaluate(begin_event)) {
+          // Found a matching begin/end pair.
+          // Set event association:
+          this_event.set_other_event(&begin_event);
+          // Erase the matching begin event index from the stack.
+          begin_stack.erase(begin_stack.begin() + si);
+          break;
+        }
+
+        // Not a match, restore original other and continue.
+        begin_event.set_other_event(other_backup);
+      }
+    }
+  }
+}
+
+const std::string& TraceAnalyzer::GetThreadName(
+    const base::debug::TestTraceEvent::PidTid& pid_tid) {
+  // If pid_tid is not found, just add and return empty string.
+  return thread_names_[pid_tid];
+}
+
+size_t TraceAnalyzer::FindEvents(const trace::Query& query,
+                                 ConstEventPtrVector* output) const {
+  output->clear();
+  return FindMatchingEvents(raw_events_, query, output);
+}
+
+const base::debug::TestTraceEvent* TraceAnalyzer::FindEvent(
+    const trace::Query& query) const {
+  ConstEventPtrVector output;
+  if (FindEvents(query, &output) > 0)
+    return output.front();
+  return NULL;
+}
+
+void TraceAnalyzer::ParseMetadata() {
+  for (size_t i = 0; i < raw_events_.size(); ++i) {
+    TestTraceEvent& this_event = raw_events_[i];
+    if (this_event.phase == TRACE_EVENT_PHASE_METADATA) {
+      // Check for thread name metadata.
+      if (this_event.name == "thread_name") {
+        std::map<std::string, std::string>::const_iterator string_i =
+            this_event.arg_strings.find("name");
+        if (string_i != this_event.arg_strings.end())
+          thread_names_[this_event.pid_tid] = string_i->second;
+      }
+    }
+  }
+}
+
+}  // namespace debug
+}  // namespace base
+