1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Use trace_analyzer::Query and trace_analyzer::TraceAnalyzer to search for 6 // specific trace events that were generated by the trace_event.h API. 7 // 8 // Basic procedure: 9 // - Get trace events JSON string from base::debug::TraceLog. 10 // - Create TraceAnalyzer with JSON string. 11 // - Call TraceAnalyzer::AssociateBeginEndEvents (optional). 12 // - Call TraceAnalyzer::AssociateEvents (zero or more times). 13 // - Call TraceAnalyzer::FindEvents with queries to find specific events. 14 // 15 // A Query is a boolean expression tree that evaluates to true or false for a 16 // given trace event. Queries can be combined into a tree using boolean, 17 // arithmetic and comparison operators that refer to data of an individual trace 18 // event. 19 // 20 // The events are returned as trace_analyzer::TraceEvent objects. 21 // TraceEvent contains a single trace event's data, as well as a pointer to 22 // a related trace event. The related trace event is typically the matching end 23 // of a begin event or the matching begin of an end event. 24 // 25 // The following examples use this basic setup code to construct TraceAnalyzer 26 // with the json trace string retrieved from TraceLog and construct an event 27 // vector for retrieving events: 28 // 29 // TraceAnalyzer analyzer(json_events); 30 // TraceEventVector events; 31 // 32 // EXAMPLE 1: Find events named "my_event". 33 // 34 // analyzer.FindEvents(Query(EVENT_NAME) == "my_event", &events); 35 // 36 // EXAMPLE 2: Find begin events named "my_event" with duration > 1 second. 37 // 38 // Query q = (Query(EVENT_NAME) == Query::String("my_event") && 39 // Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN) && 40 // Query(EVENT_DURATION) > Query::Double(1000000.0)); 41 // analyzer.FindEvents(q, &events); 42 // 43 // EXAMPLE 3: Associating event pairs across threads. 44 // 45 // If the test needs to analyze something that starts and ends on different 46 // threads, the test needs to use INSTANT events. The typical procedure is to 47 // specify the same unique ID as a TRACE_EVENT argument on both the start and 48 // finish INSTANT events. Then use the following procedure to associate those 49 // events. 50 // 51 // Step 1: instrument code with custom begin/end trace events. 52 // [Thread 1 tracing code] 53 // TRACE_EVENT_INSTANT1("test_latency", "timing1_begin", "id", 3); 54 // [Thread 2 tracing code] 55 // TRACE_EVENT_INSTANT1("test_latency", "timing1_end", "id", 3); 56 // 57 // Step 2: associate these custom begin/end pairs. 58 // Query begin(Query(EVENT_NAME) == Query::String("timing1_begin")); 59 // Query end(Query(EVENT_NAME) == Query::String("timing1_end")); 60 // Query match(Query(EVENT_ARG, "id") == Query(OTHER_ARG, "id")); 61 // analyzer.AssociateEvents(begin, end, match); 62 // 63 // Step 3: search for "timing1_begin" events with existing other event. 64 // Query q = (Query(EVENT_NAME) == Query::String("timing1_begin") && 65 // Query(EVENT_HAS_OTHER)); 66 // analyzer.FindEvents(q, &events); 67 // 68 // Step 4: analyze events, such as checking durations. 69 // for (size_t i = 0; i < events.size(); ++i) { 70 // double duration; 71 // EXPECT_TRUE(events[i].GetAbsTimeToOtherEvent(&duration)); 72 // EXPECT_LT(duration, 1000000.0/60.0); // expect less than 1/60 second. 73 // } 74 75 76 #ifndef BASE_TEST_TRACE_EVENT_ANALYZER_H_ 77 #define BASE_TEST_TRACE_EVENT_ANALYZER_H_ 78 79 #include <map> 80 81 #include "base/debug/trace_event.h" 82 #include "base/memory/ref_counted.h" 83 84 namespace base { 85 class Value; 86 } 87 88 namespace trace_analyzer { 89 class QueryNode; 90 91 // trace_analyzer::TraceEvent is a more convenient form of the 92 // base::debug::TraceEvent class to make tracing-based tests easier to write. 93 struct TraceEvent { 94 // ProcessThreadID contains a Process ID and Thread ID. 95 struct ProcessThreadID { 96 ProcessThreadID() : process_id(0), thread_id(0) {} 97 ProcessThreadID(int process_id, int thread_id) 98 : process_id(process_id), thread_id(thread_id) {} 99 bool operator< (const ProcessThreadID& rhs) const { 100 if (process_id != rhs.process_id) 101 return process_id < rhs.process_id; 102 return thread_id < rhs.thread_id; 103 } 104 int process_id; 105 int thread_id; 106 }; 107 108 TraceEvent(); 109 ~TraceEvent(); 110 111 bool SetFromJSON(const base::Value* event_value) WARN_UNUSED_RESULT; 112 113 bool operator< (const TraceEvent& rhs) const { 114 return timestamp < rhs.timestamp; 115 } 116 117 bool has_other_event() const { return other_event; } 118 119 // Returns absolute duration in microseconds between this event and other 120 // event. Must have already verified that other_event exists by 121 // Query(EVENT_HAS_OTHER) or by calling has_other_event(). 122 double GetAbsTimeToOtherEvent() const; 123 124 // Return the argument value if it exists and it is a string. 125 bool GetArgAsString(const std::string& name, std::string* arg) const; 126 // Return the argument value if it exists and it is a number. 127 bool GetArgAsNumber(const std::string& name, double* arg) const; 128 129 // Check if argument exists and is string. 130 bool HasStringArg(const std::string& name) const; 131 // Check if argument exists and is number (double, int or bool). 132 bool HasNumberArg(const std::string& name) const; 133 134 // Get known existing arguments as specific types. 135 // Useful when you have already queried the argument with 136 // Query(HAS_NUMBER_ARG) or Query(HAS_STRING_ARG). 137 std::string GetKnownArgAsString(const std::string& name) const; 138 double GetKnownArgAsDouble(const std::string& name) const; 139 int GetKnownArgAsInt(const std::string& name) const; 140 bool GetKnownArgAsBool(const std::string& name) const; 141 142 // Process ID and Thread ID. 143 ProcessThreadID thread; 144 145 // Time since epoch in microseconds. 146 // Stored as double to match its JSON representation. 147 double timestamp; 148 149 double duration; 150 151 char phase; 152 153 std::string category; 154 155 std::string name; 156 157 std::string id; 158 159 // All numbers and bool values from TraceEvent args are cast to double. 160 // bool becomes 1.0 (true) or 0.0 (false). 161 std::map<std::string, double> arg_numbers; 162 163 std::map<std::string, std::string> arg_strings; 164 165 // The other event associated with this event (or NULL). 166 const TraceEvent* other_event; 167 }; 168 169 typedef std::vector<const TraceEvent*> TraceEventVector; 170 171 class Query { 172 public: 173 Query(const Query& query); 174 175 ~Query(); 176 177 //////////////////////////////////////////////////////////////// 178 // Query literal values 179 180 // Compare with the given string. 181 static Query String(const std::string& str); 182 183 // Compare with the given number. 184 static Query Double(double num); 185 static Query Int(int32 num); 186 static Query Uint(uint32 num); 187 188 // Compare with the given bool. 189 static Query Bool(bool boolean); 190 191 // Compare with the given phase. 192 static Query Phase(char phase); 193 194 // Compare with the given string pattern. Only works with == and != operators. 195 // Example: Query(EVENT_NAME) == Query::Pattern("MyEvent*") 196 static Query Pattern(const std::string& pattern); 197 198 //////////////////////////////////////////////////////////////// 199 // Query event members 200 201 static Query EventPid() { return Query(EVENT_PID); } 202 203 static Query EventTid() { return Query(EVENT_TID); } 204 205 // Return the timestamp of the event in microseconds since epoch. 206 static Query EventTime() { return Query(EVENT_TIME); } 207 208 // Return the absolute time between event and other event in microseconds. 209 // Only works if Query::EventHasOther() == true. 210 static Query EventDuration() { return Query(EVENT_DURATION); } 211 212 // Return the duration of a COMPLETE event. 213 static Query EventCompleteDuration() { 214 return Query(EVENT_COMPLETE_DURATION); 215 } 216 217 static Query EventPhase() { return Query(EVENT_PHASE); } 218 219 static Query EventCategory() { return Query(EVENT_CATEGORY); } 220 221 static Query EventName() { return Query(EVENT_NAME); } 222 223 static Query EventId() { return Query(EVENT_ID); } 224 225 static Query EventPidIs(int process_id) { 226 return Query(EVENT_PID) == Query::Int(process_id); 227 } 228 229 static Query EventTidIs(int thread_id) { 230 return Query(EVENT_TID) == Query::Int(thread_id); 231 } 232 233 static Query EventThreadIs(const TraceEvent::ProcessThreadID& thread) { 234 return EventPidIs(thread.process_id) && EventTidIs(thread.thread_id); 235 } 236 237 static Query EventTimeIs(double timestamp) { 238 return Query(EVENT_TIME) == Query::Double(timestamp); 239 } 240 241 static Query EventDurationIs(double duration) { 242 return Query(EVENT_DURATION) == Query::Double(duration); 243 } 244 245 static Query EventPhaseIs(char phase) { 246 return Query(EVENT_PHASE) == Query::Phase(phase); 247 } 248 249 static Query EventCategoryIs(const std::string& category) { 250 return Query(EVENT_CATEGORY) == Query::String(category); 251 } 252 253 static Query EventNameIs(const std::string& name) { 254 return Query(EVENT_NAME) == Query::String(name); 255 } 256 257 static Query EventIdIs(const std::string& id) { 258 return Query(EVENT_ID) == Query::String(id); 259 } 260 261 // Evaluates to true if arg exists and is a string. 262 static Query EventHasStringArg(const std::string& arg_name) { 263 return Query(EVENT_HAS_STRING_ARG, arg_name); 264 } 265 266 // Evaluates to true if arg exists and is a number. 267 // Number arguments include types double, int and bool. 268 static Query EventHasNumberArg(const std::string& arg_name) { 269 return Query(EVENT_HAS_NUMBER_ARG, arg_name); 270 } 271 272 // Evaluates to arg value (string or number). 273 static Query EventArg(const std::string& arg_name) { 274 return Query(EVENT_ARG, arg_name); 275 } 276 277 // Return true if associated event exists. 278 static Query EventHasOther() { return Query(EVENT_HAS_OTHER); } 279 280 // Access the associated other_event's members: 281 282 static Query OtherPid() { return Query(OTHER_PID); } 283 284 static Query OtherTid() { return Query(OTHER_TID); } 285 286 static Query OtherTime() { return Query(OTHER_TIME); } 287 288 static Query OtherPhase() { return Query(OTHER_PHASE); } 289 290 static Query OtherCategory() { return Query(OTHER_CATEGORY); } 291 292 static Query OtherName() { return Query(OTHER_NAME); } 293 294 static Query OtherId() { return Query(OTHER_ID); } 295 296 static Query OtherPidIs(int process_id) { 297 return Query(OTHER_PID) == Query::Int(process_id); 298 } 299 300 static Query OtherTidIs(int thread_id) { 301 return Query(OTHER_TID) == Query::Int(thread_id); 302 } 303 304 static Query OtherThreadIs(const TraceEvent::ProcessThreadID& thread) { 305 return OtherPidIs(thread.process_id) && OtherTidIs(thread.thread_id); 306 } 307 308 static Query OtherTimeIs(double timestamp) { 309 return Query(OTHER_TIME) == Query::Double(timestamp); 310 } 311 312 static Query OtherPhaseIs(char phase) { 313 return Query(OTHER_PHASE) == Query::Phase(phase); 314 } 315 316 static Query OtherCategoryIs(const std::string& category) { 317 return Query(OTHER_CATEGORY) == Query::String(category); 318 } 319 320 static Query OtherNameIs(const std::string& name) { 321 return Query(OTHER_NAME) == Query::String(name); 322 } 323 324 static Query OtherIdIs(const std::string& id) { 325 return Query(OTHER_ID) == Query::String(id); 326 } 327 328 // Evaluates to true if arg exists and is a string. 329 static Query OtherHasStringArg(const std::string& arg_name) { 330 return Query(OTHER_HAS_STRING_ARG, arg_name); 331 } 332 333 // Evaluates to true if arg exists and is a number. 334 // Number arguments include types double, int and bool. 335 static Query OtherHasNumberArg(const std::string& arg_name) { 336 return Query(OTHER_HAS_NUMBER_ARG, arg_name); 337 } 338 339 // Evaluates to arg value (string or number). 340 static Query OtherArg(const std::string& arg_name) { 341 return Query(OTHER_ARG, arg_name); 342 } 343 344 //////////////////////////////////////////////////////////////// 345 // Common queries: 346 347 // Find BEGIN events that have a corresponding END event. 348 static Query MatchBeginWithEnd() { 349 return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN)) && 350 Query(EVENT_HAS_OTHER); 351 } 352 353 // Find COMPLETE events. 354 static Query MatchComplete() { 355 return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_COMPLETE)); 356 } 357 358 // Find ASYNC_BEGIN events that have a corresponding ASYNC_END event. 359 static Query MatchAsyncBeginWithNext() { 360 return (Query(EVENT_PHASE) == 361 Query::Phase(TRACE_EVENT_PHASE_ASYNC_BEGIN)) && 362 Query(EVENT_HAS_OTHER); 363 } 364 365 // Find BEGIN events of given |name| which also have associated END events. 366 static Query MatchBeginName(const std::string& name) { 367 return (Query(EVENT_NAME) == Query(name)) && MatchBeginWithEnd(); 368 } 369 370 // Find COMPLETE events of given |name|. 371 static Query MatchCompleteName(const std::string& name) { 372 return (Query(EVENT_NAME) == Query(name)) && MatchComplete(); 373 } 374 375 // Match given Process ID and Thread ID. 376 static Query MatchThread(const TraceEvent::ProcessThreadID& thread) { 377 return (Query(EVENT_PID) == Query::Int(thread.process_id)) && 378 (Query(EVENT_TID) == Query::Int(thread.thread_id)); 379 } 380 381 // Match event pair that spans multiple threads. 382 static Query MatchCrossThread() { 383 return (Query(EVENT_PID) != Query(OTHER_PID)) || 384 (Query(EVENT_TID) != Query(OTHER_TID)); 385 } 386 387 //////////////////////////////////////////////////////////////// 388 // Operators: 389 390 // Boolean operators: 391 Query operator==(const Query& rhs) const; 392 Query operator!=(const Query& rhs) const; 393 Query operator< (const Query& rhs) const; 394 Query operator<=(const Query& rhs) const; 395 Query operator> (const Query& rhs) const; 396 Query operator>=(const Query& rhs) const; 397 Query operator&&(const Query& rhs) const; 398 Query operator||(const Query& rhs) const; 399 Query operator!() const; 400 401 // Arithmetic operators: 402 // Following operators are applied to double arguments: 403 Query operator+(const Query& rhs) const; 404 Query operator-(const Query& rhs) const; 405 Query operator*(const Query& rhs) const; 406 Query operator/(const Query& rhs) const; 407 Query operator-() const; 408 // Mod operates on int64 args (doubles are casted to int64 beforehand): 409 Query operator%(const Query& rhs) const; 410 411 // Return true if the given event matches this query tree. 412 // This is a recursive method that walks the query tree. 413 bool Evaluate(const TraceEvent& event) const; 414 415 private: 416 enum TraceEventMember { 417 EVENT_INVALID, 418 EVENT_PID, 419 EVENT_TID, 420 EVENT_TIME, 421 EVENT_DURATION, 422 EVENT_COMPLETE_DURATION, 423 EVENT_PHASE, 424 EVENT_CATEGORY, 425 EVENT_NAME, 426 EVENT_ID, 427 EVENT_HAS_STRING_ARG, 428 EVENT_HAS_NUMBER_ARG, 429 EVENT_ARG, 430 EVENT_HAS_OTHER, 431 OTHER_PID, 432 OTHER_TID, 433 OTHER_TIME, 434 OTHER_PHASE, 435 OTHER_CATEGORY, 436 OTHER_NAME, 437 OTHER_ID, 438 OTHER_HAS_STRING_ARG, 439 OTHER_HAS_NUMBER_ARG, 440 OTHER_ARG, 441 }; 442 443 enum Operator { 444 OP_INVALID, 445 // Boolean operators: 446 OP_EQ, 447 OP_NE, 448 OP_LT, 449 OP_LE, 450 OP_GT, 451 OP_GE, 452 OP_AND, 453 OP_OR, 454 OP_NOT, 455 // Arithmetic operators: 456 OP_ADD, 457 OP_SUB, 458 OP_MUL, 459 OP_DIV, 460 OP_MOD, 461 OP_NEGATE 462 }; 463 464 enum QueryType { 465 QUERY_BOOLEAN_OPERATOR, 466 QUERY_ARITHMETIC_OPERATOR, 467 QUERY_EVENT_MEMBER, 468 QUERY_NUMBER, 469 QUERY_STRING 470 }; 471 472 // Compare with the given member. 473 explicit Query(TraceEventMember member); 474 475 // Compare with the given member argument value. 476 Query(TraceEventMember member, const std::string& arg_name); 477 478 // Compare with the given string. 479 explicit Query(const std::string& str); 480 481 // Compare with the given number. 482 explicit Query(double num); 483 484 // Construct a boolean Query that returns (left <binary_op> right). 485 Query(const Query& left, const Query& right, Operator binary_op); 486 487 // Construct a boolean Query that returns (<binary_op> left). 488 Query(const Query& left, Operator unary_op); 489 490 // Try to compare left_ against right_ based on operator_. 491 // If either left or right does not convert to double, false is returned. 492 // Otherwise, true is returned and |result| is set to the comparison result. 493 bool CompareAsDouble(const TraceEvent& event, bool* result) const; 494 495 // Try to compare left_ against right_ based on operator_. 496 // If either left or right does not convert to string, false is returned. 497 // Otherwise, true is returned and |result| is set to the comparison result. 498 bool CompareAsString(const TraceEvent& event, bool* result) const; 499 500 // Attempt to convert this Query to a double. On success, true is returned 501 // and the double value is stored in |num|. 502 bool GetAsDouble(const TraceEvent& event, double* num) const; 503 504 // Attempt to convert this Query to a string. On success, true is returned 505 // and the string value is stored in |str|. 506 bool GetAsString(const TraceEvent& event, std::string* str) const; 507 508 // Evaluate this Query as an arithmetic operator on left_ and right_. 509 bool EvaluateArithmeticOperator(const TraceEvent& event, 510 double* num) const; 511 512 // For QUERY_EVENT_MEMBER Query: attempt to get the double value of the Query. 513 bool GetMemberValueAsDouble(const TraceEvent& event, double* num) const; 514 515 // For QUERY_EVENT_MEMBER Query: attempt to get the string value of the Query. 516 bool GetMemberValueAsString(const TraceEvent& event, std::string* num) const; 517 518 // Does this Query represent a value? 519 bool is_value() const { return type_ != QUERY_BOOLEAN_OPERATOR; } 520 521 bool is_unary_operator() const { 522 return operator_ == OP_NOT || operator_ == OP_NEGATE; 523 } 524 525 bool is_comparison_operator() const { 526 return operator_ != OP_INVALID && operator_ < OP_AND; 527 } 528 529 const Query& left() const; 530 const Query& right() const; 531 532 QueryType type_; 533 Operator operator_; 534 scoped_refptr<QueryNode> left_; 535 scoped_refptr<QueryNode> right_; 536 TraceEventMember member_; 537 double number_; 538 std::string string_; 539 bool is_pattern_; 540 }; 541 542 // Implementation detail: 543 // QueryNode allows Query to store a ref-counted query tree. 544 class QueryNode : public base::RefCounted<QueryNode> { 545 public: 546 explicit QueryNode(const Query& query); 547 const Query& query() const { return query_; } 548 549 private: 550 friend class base::RefCounted<QueryNode>; 551 ~QueryNode(); 552 553 Query query_; 554 }; 555 556 // TraceAnalyzer helps tests search for trace events. 557 class TraceAnalyzer { 558 public: 559 ~TraceAnalyzer(); 560 561 // Use trace events from JSON string generated by tracing API. 562 // Returns non-NULL if the JSON is successfully parsed. 563 static TraceAnalyzer* Create(const std::string& json_events) 564 WARN_UNUSED_RESULT; 565 566 // Associate BEGIN and END events with each other. This allows Query(OTHER_*) 567 // to access the associated event and enables Query(EVENT_DURATION). 568 // An end event will match the most recent begin event with the same name, 569 // category, process ID and thread ID. This matches what is shown in 570 // about:tracing. After association, the BEGIN event will point to the 571 // matching END event, but the END event will not point to the BEGIN event. 572 void AssociateBeginEndEvents(); 573 574 // Associate ASYNC_BEGIN, ASYNC_STEP and ASYNC_END events with each other. 575 // An ASYNC_END event will match the most recent ASYNC_BEGIN or ASYNC_STEP 576 // event with the same name, category, and ID. This creates a singly linked 577 // list of ASYNC_BEGIN->ASYNC_STEP...->ASYNC_END. 578 void AssociateAsyncBeginEndEvents(); 579 580 // AssociateEvents can be used to customize event associations by setting the 581 // other_event member of TraceEvent. This should be used to associate two 582 // INSTANT events. 583 // 584 // The assumptions are: 585 // - |first| events occur before |second| events. 586 // - the closest matching |second| event is the correct match. 587 // 588 // |first| - Eligible |first| events match this query. 589 // |second| - Eligible |second| events match this query. 590 // |match| - This query is run on the |first| event. The OTHER_* EventMember 591 // queries will point to an eligible |second| event. The query 592 // should evaluate to true if the |first|/|second| pair is a match. 593 // 594 // When a match is found, the pair will be associated by having the first 595 // event's other_event member point to the other. AssociateEvents does not 596 // clear previous associations, so it is possible to associate multiple pairs 597 // of events by calling AssociateEvents more than once with different queries. 598 // 599 // NOTE: AssociateEvents will overwrite existing other_event associations if 600 // the queries pass for events that already had a previous association. 601 // 602 // After calling any Find* method, it is not allowed to call AssociateEvents 603 // again. 604 void AssociateEvents(const Query& first, 605 const Query& second, 606 const Query& match); 607 608 // For each event, copy its arguments to the other_event argument map. If 609 // argument name already exists, it will not be overwritten. 610 void MergeAssociatedEventArgs(); 611 612 // Find all events that match query and replace output vector. 613 size_t FindEvents(const Query& query, TraceEventVector* output); 614 615 // Find first event that matches query or NULL if not found. 616 const TraceEvent* FindFirstOf(const Query& query); 617 618 // Find last event that matches query or NULL if not found. 619 const TraceEvent* FindLastOf(const Query& query); 620 621 const std::string& GetThreadName(const TraceEvent::ProcessThreadID& thread); 622 623 private: 624 TraceAnalyzer(); 625 626 bool SetEvents(const std::string& json_events) WARN_UNUSED_RESULT; 627 628 // Read metadata (thread names, etc) from events. 629 void ParseMetadata(); 630 631 std::map<TraceEvent::ProcessThreadID, std::string> thread_names_; 632 std::vector<TraceEvent> raw_events_; 633 bool allow_assocation_changes_; 634 635 DISALLOW_COPY_AND_ASSIGN(TraceAnalyzer); 636 }; 637 638 // Utility functions for TraceEventVector. 639 640 struct RateStats { 641 double min_us; 642 double max_us; 643 double mean_us; 644 double standard_deviation_us; 645 }; 646 647 struct RateStatsOptions { 648 RateStatsOptions() : trim_min(0u), trim_max(0u) {} 649 // After the times between events are sorted, the number of specified elements 650 // will be trimmed before calculating the RateStats. This is useful in cases 651 // where extreme outliers are tolerable and should not skew the overall 652 // average. 653 size_t trim_min; // Trim this many minimum times. 654 size_t trim_max; // Trim this many maximum times. 655 }; 656 657 // Calculate min/max/mean and standard deviation from the times between 658 // adjacent events. 659 bool GetRateStats(const TraceEventVector& events, 660 RateStats* stats, 661 const RateStatsOptions* options); 662 663 // Starting from |position|, find the first event that matches |query|. 664 // Returns true if found, false otherwise. 665 bool FindFirstOf(const TraceEventVector& events, 666 const Query& query, 667 size_t position, 668 size_t* return_index); 669 670 // Starting from |position|, find the last event that matches |query|. 671 // Returns true if found, false otherwise. 672 bool FindLastOf(const TraceEventVector& events, 673 const Query& query, 674 size_t position, 675 size_t* return_index); 676 677 // Find the closest events to |position| in time that match |query|. 678 // return_second_closest may be NULL. Closeness is determined by comparing 679 // with the event timestamp. 680 // Returns true if found, false otherwise. If both return parameters are 681 // requested, both must be found for a successful result. 682 bool FindClosest(const TraceEventVector& events, 683 const Query& query, 684 size_t position, 685 size_t* return_closest, 686 size_t* return_second_closest); 687 688 // Count matches, inclusive of |begin_position|, exclusive of |end_position|. 689 size_t CountMatches(const TraceEventVector& events, 690 const Query& query, 691 size_t begin_position, 692 size_t end_position); 693 694 // Count all matches. 695 static inline size_t CountMatches(const TraceEventVector& events, 696 const Query& query) { 697 return CountMatches(events, query, 0u, events.size()); 698 } 699 700 } // namespace trace_analyzer 701 702 #endif // BASE_TEST_TRACE_EVENT_ANALYZER_H_ 703