Stop holding onto TimelineEvents

runtime/vm/timeline.h

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_TIMELINE_H_
 #define VM_TIMELINE_H_
 
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
+#include "vm/os.h"
 
 namespace dart {
 
 class JSONArray;
 class JSONObject;
 class JSONStream;
 class Object;
 class ObjectPointerVisitor;
 class Isolate;
 class RawArray;
@@ skipping 54 matching lines @@
 #define ISOLATE_TIMELINE_STREAM_DECLARE_FLAG(name, not_used)                   \
   static bool stream_##name##_enabled_;
   ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_DECLARE_FLAG)
 #undef ISOLATE_TIMELINE_STREAM_DECLARE_FLAG
 
   friend class TimelineRecorderOverride;
   friend class ReclaimBlocksIsolateVisitor;
 };
 
 
+struct TimelineEventArgument {
+  const char* name;
+  char* value;
+};
+
+
 // You should get a |TimelineEvent| from a |TimelineStream|.
 class TimelineEvent {
  public:
   // Keep in sync with StateBits below.
   enum EventType {
     kNone,
     kBegin,
     kEnd,
     kDuration,
     kInstant,
@@ skipping 23 matching lines @@
 
   void DurationBegin(const char* label);
   void DurationEnd();
   void Instant(const char* label);
 
   void Duration(const char* label,
                 int64_t start_micros,
                 int64_t end_micros);
 
   void Begin(const char* label,
-             int64_t micros);
+             int64_t micros = OS::GetCurrentTraceMicros());
 
   void End(const char* label,
-           int64_t micros);
+           int64_t micros = OS::GetCurrentTraceMicros());
 
   // Set the number of arguments in the event.
   void SetNumArguments(intptr_t length);
   // |name| must be a compile time constant. Takes ownership of |argumentp|.
   void SetArgument(intptr_t i, const char* name, char* argument);
   // |name| must be a compile time constant. Copies |argument|.
   void CopyArgument(intptr_t i, const char* name, const char* argument);
   // |name| must be a compile time constant.
   void FormatArgument(intptr_t i,
                       const char* name,
                       const char* fmt, ...) PRINTF_ATTRIBUTE(4, 5);
 
+  void StealArguments(intptr_t arguments_length,
+                      TimelineEventArgument* arguments);
   // Mandatory to call when this event is completely filled out.
   void Complete();
 
   EventType event_type() const {
     return EventTypeField::decode(state_);
   }
 
   bool IsFinishedDuration() const {
     return (event_type() == kDuration) && (timestamp1_ > timestamp0_);
   }
@@ skipping 61 matching lines @@
         return false;
       }
       if (other->TimeEnd() > TimeEnd()) {
         return false;
       }
       return true;
     }
   }
 
  private:
-  struct TimelineEventArgument {
-    const char* name;
-    char* value;
-  };
-
   int64_t timestamp0_;
   int64_t timestamp1_;
   TimelineEventArgument* arguments_;
   intptr_t arguments_length_;
   uword state_;
   const char* label_;
   const char* category_;
   ThreadId thread_;
   Isolate* isolate_;
 
   void FreeArguments();
 
   void StreamInit(TimelineStream* stream);
   void Init(EventType event_type, const char* label);
 
   void set_event_type(EventType event_type) {
     // We only reserve 4 bits to hold the event type.
     COMPILE_ASSERT(kNumEventTypes < 16);
     state_ = EventTypeField::update(event_type, state_);
   }
 
+  void set_global_block(bool global_block) {
+    state_ = GlobalBlockField::update(global_block, state_);
+  }
+
+  bool global_block() const {
+    return GlobalBlockField::decode(state_);
+  }
+
   enum StateBits {
-    kEventTypeBit = 0,
-    // reserve 4 bits for type.
-    kNextBit = 4,
+    kEventTypeBit = 0,  // reserve 4 bits for type.
+    // Was this event allocated from the global block?
+    kGlobalBlockBit = 4,
+    kNextBit = 5,
   };
 
   class EventTypeField : public BitField<EventType, kEventTypeBit, 4> {};
+  class GlobalBlockField : public BitField<bool, kGlobalBlockBit, 1> {};
 
+  friend class TimelineEventRecorder;
+  friend class TimelineEventEndlessRecorder;
+  friend class TimelineEventRingRecorder;
+  friend class TimelineStream;
   friend class TimelineTestHelper;
-  friend class TimelineStream;
   DISALLOW_COPY_AND_ASSIGN(TimelineEvent);
 };
 
 
 // A stream of timeline events. A stream has a name and can be enabled or
 // disabled (globally and per isolate).
 class TimelineStream {
  public:
   TimelineStream();
 
@@ skipping 13 matching lines @@
   bool enabled() const {
     return enabled_;
   }
 
   void set_enabled(bool enabled) {
     enabled_ = enabled;
   }
 
   // Records an event. Will return |NULL| if not enabled. The returned
   // |TimelineEvent| is in an undefined state and must be initialized.
+  // NOTE: It is not allowed to call StartEvent again without completing
+  // the first event.
   TimelineEvent* StartEvent();
 
  private:
   const char* name_;
   bool enabled_;
   const bool* globally_enabled_;
 };
 
 #define TIMELINE_FUNCTION_COMPILATION_DURATION(thread, suffix, function)       \
   TimelineDurationScope tds(thread,                                            \
                             thread->isolate()->GetCompilerStream(),            \
                             "Compile" suffix);                                 \
   if (tds.enabled()) {                                                         \
     tds.SetNumArguments(1);                                                    \
     tds.CopyArgument(                                                          \
         0,                                                                     \
         "function",                                                            \
         const_cast<char*>(function.ToLibNamePrefixedQualifiedCString()));      \
   }
 
 
-// TODO(johnmccutchan): TimelineDurationScope should only allocate the
-// event when complete.
 class TimelineDurationScope : public StackResource {
  public:
-  TimelineDurationScope(Isolate* isolate,
-                        TimelineStream* stream,
-                        const char* label)
-      : StackResource(isolate) {
-    Init(stream, label);
-  }
+  TimelineDurationScope(TimelineStream* stream,
+                        const char* label);
 
   TimelineDurationScope(Thread* thread,
                         TimelineStream* stream,
-                        const char* label)
-      : StackResource(thread) {
-    Init(stream, label);
+                        const char* label);
+
+  ~TimelineDurationScope();
+
+  bool enabled() const {
+    return enabled_;
   }
 
-  TimelineDurationScope(TimelineStream* stream,
-                        const char* label)
-      : StackResource(reinterpret_cast<Thread*>(NULL)) {
-    Init(stream, label);
-  }
+  void SetNumArguments(intptr_t length);
 
-  void Init(TimelineStream* stream, const char* label) {
-    event_ = stream->StartEvent();
-    if (event_ == NULL) {
-      return;
-    }
-    event_->DurationBegin(label);
-  }
+  void SetArgument(intptr_t i, const char* name, char* argument);
 
-  bool enabled() const {
-    return event_ != NULL;
-  }
-
-  void SetNumArguments(intptr_t length) {
-    if (event_ == NULL) {
-      return;
-    }
-    event_->SetNumArguments(length);
-  }
-
-  void SetArgument(intptr_t i, const char* name, char* argument) {
-    if (event_ == NULL) {
-      return;
-    }
-    event_->SetArgument(i, name, argument);
-  }
-
-  void CopyArgument(intptr_t i, const char* name, const char* argument) {
-    if (event_ == NULL) {
-      return;
-    }
-    event_->CopyArgument(i, name, argument);
-  }
+  void CopyArgument(intptr_t i, const char* name, const char* argument);
 
   void FormatArgument(intptr_t i,
                       const char* name,
                       const char* fmt, ...)  PRINTF_ATTRIBUTE(4, 5);
 
-  ~TimelineDurationScope() {
-    if (event_ == NULL) {
-      return;
-    }
-    event_->DurationEnd();
-    event_->Complete();
-  }
+ private:
+  void Init();
+  void FreeArguments();
 
- private:
-  TimelineEvent* event_;
+  int64_t timestamp_;
+  TimelineStream* stream_;
+  const char* label_;
+  TimelineEventArgument* arguments_;
+  intptr_t arguments_length_;
+  bool enabled_;
+
+  DISALLOW_COPY_AND_ASSIGN(TimelineDurationScope);
 };
 
 
 // A block of |TimelineEvent|s. Not thread safe.
 class TimelineEventBlock {
  public:
   static const intptr_t kBlockSize = 64;
 
   explicit TimelineEventBlock(intptr_t index);
   ~TimelineEventBlock();
@@ skipping 185 matching lines @@
   virtual void CompleteEvent(TimelineEvent* event) = 0;
   virtual TimelineEventBlock* GetHeadBlockLocked() = 0;
   virtual TimelineEventBlock* GetNewBlockLocked(Isolate* isolate) = 0;
   virtual intptr_t NumDartEventsLocked() = 0;
   virtual DartTimelineEvent* DartEventAtLocked(intptr_t i) = 0;
 
   // Utility method(s).
   void PrintJSONMeta(JSONArray* array) const;
   TimelineEvent* ThreadBlockStartEvent();
   TimelineEvent* GlobalBlockStartEvent();
+  void ThreadBlockCompleteEvent(TimelineEvent* event);
+  void GlobalBlockCompleteEvent(TimelineEvent* event);
 
   Mutex lock_;
   // Only accessed under |lock_|.
   TimelineEventBlock* global_block_;
   void ReclaimGlobalBlock();
 
   uintptr_t async_id_;
 
   friend class DartTimelineEventIterator;
   friend class TimelineEvent;
@@ skipping 150 matching lines @@
 
  private:
   intptr_t cursor_;
   intptr_t num_events_;
   TimelineEventRecorder* recorder_;
 };
 
 }  // namespace dart
 
 #endif  // VM_TIMELINE_H_