Make TimelineEventBlocks reclaimable

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"
 
@@ skipping 27 matching lines @@
   // Shutdown timeline system. Not thread safe.
   static void Shutdown();
 
   // Access the global recorder. Not thread safe.
   static TimelineEventRecorder* recorder();
 
   static bool EnableStreamByDefault(const char* stream_name);
 
   static TimelineStream* GetVMStream();
 
+  // Reclaim all |TimelineEventBlock|s that are owned by the current isolate.
+  static void ReclaimIsolateBlocks();
+
+  // Reclaim all |TimelineEventBlocks|s that are owned by all isolates and
+  // the global block owned by the VM.
+  static void ReclaimAllBlocks();
+
 #define ISOLATE_TIMELINE_STREAM_FLAGS(name, not_used)                          \
   static const bool* Stream##name##EnabledFlag() {                             \
     return &stream_##name##_enabled_;                                          \
   }                                                                            \
   static void SetStream##name##Enabled(bool enabled) {                         \
     stream_##name##_enabled_ = enabled;                                        \
   }
   ISOLATE_TIMELINE_STREAM_LIST(ISOLATE_TIMELINE_STREAM_FLAGS)
 #undef ISOLATE_TIMELINE_STREAM_FLAGS
 
  private:
+  static void ReclaimBlocksForIsolate(Isolate* isolate);
+
   static TimelineEventRecorder* recorder_;
   static TimelineStream* vm_stream_;
 
 #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;
 };
 
 
 // You should get a |TimelineEvent| from a |TimelineStream|.
 class TimelineEvent {
  public:
   // Keep in sync with StateBits below.
   enum EventType {
     kNone,
     kDuration,
@@ skipping 307 matching lines @@
 
   // Returns false if |this| violates any of the following invariants:
   // - events in the block come from one thread.
   // - events have monotonically increasing timestamps.
   bool CheckBlock();
 
   // Call Reset on all events and set length to 0.
   void Reset();
 
   // Only safe to access under the recorder's lock.
-  bool open() const {
-    return open_;
+  bool in_use() const {
+    return in_use_;
   }
 
   // Only safe to access under the recorder's lock.
   Isolate* isolate() const {
     return isolate_;
   }
 
  protected:
   TimelineEvent* StartEvent();
 
   TimelineEvent events_[kBlockSize];
   TimelineEventBlock* next_;
   intptr_t length_;
   intptr_t block_index_;
 
   // Only accessed under the recorder's lock.
   Isolate* isolate_;
-  bool open_;
+  bool in_use_;
 
   void Open(Isolate* isolate);
   void Finish();
 
   friend class Thread;
   friend class ThreadRegistry;
   friend class TimelineEventRecorder;
   friend class TimelineEventRingRecorder;
   friend class TimelineEventEndlessRecorder;
   friend class TimelineTestHelper;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventBlock);
 };
 
 
 class TimelineEventFilter : public ValueObject {
  public:
   TimelineEventFilter();
   virtual ~TimelineEventFilter();
 
   virtual bool IncludeBlock(TimelineEventBlock* block) {
     if (block == NULL) {
       return false;
     }
-    // Not empty and not open.
-    return !block->IsEmpty() && !block->open();
+    // Not empty and not in use.
+    return !block->IsEmpty() && !block->in_use();
   }
 
   virtual bool IncludeEvent(TimelineEvent* event) {
     if (event == NULL) {
       return false;
     }
     return event->IsValid();
   }
 
  private:
 };
 
 
 class IsolateTimelineEventFilter : public TimelineEventFilter {
  public:
   explicit IsolateTimelineEventFilter(Isolate* isolate);
 
   bool IncludeBlock(TimelineEventBlock* block) {
     if (block == NULL) {
       return false;
     }
-    // Not empty, not open, and isolate match.
-    return !block->IsEmpty() &&
+    // Not empty, not in use, and isolate match.
+    return !block->IsEmpty() && !block->in_use() &&
            (block->isolate() == isolate_);
   }
 
  private:
   Isolate* isolate_;
 };
 
 
 // Recorder of |TimelineEvent|s.
 class TimelineEventRecorder {
  public:
   TimelineEventRecorder();
   virtual ~TimelineEventRecorder() {}
 
   TimelineEventBlock* GetNewBlock();
 
   // Interface method(s) which must be implemented.
   virtual void PrintJSON(JSONStream* js, TimelineEventFilter* filter) = 0;
 
   int64_t GetNextAsyncId();
 
+  void FinishBlock(TimelineEventBlock* block);
+
  protected:
   void WriteTo(const char* directory);
 
   // Interface method(s) which must be implemented.
   virtual TimelineEvent* StartEvent() = 0;
   virtual void CompleteEvent(TimelineEvent* event) = 0;
   virtual TimelineEventBlock* GetHeadBlockLocked() = 0;
   virtual TimelineEventBlock* GetNewBlockLocked(Isolate* isolate) = 0;
 
   // Utility method(s).
   void PrintJSONMeta(JSONArray* array) const;
   TimelineEvent* ThreadBlockStartEvent();
   TimelineEvent* GlobalBlockStartEvent();
 
   Mutex lock_;
   // Only accessed under |lock_|.
   TimelineEventBlock* global_block_;
-  void FinishGlobalBlock();
+  void ReclaimGlobalBlock();
 
   uintptr_t async_id_;
 
-  friend class ThreadRegistry;
   friend class TimelineEvent;
   friend class TimelineEventBlockIterator;
   friend class TimelineStream;
   friend class TimelineTestHelper;
   friend class Timeline;
-  friend class Isolate;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TimelineEventRecorder);
 };
 
 
 // A recorder that stores events in a ring buffer of fixed capacity.
 class TimelineEventRingRecorder : public TimelineEventRecorder {
  public:
   static const intptr_t kDefaultCapacity = 8192;
@@ skipping 88 matching lines @@
   TimelineEventBlock* Next();
 
  private:
   TimelineEventBlock* current_;
   TimelineEventRecorder* recorder_;
 };
 
 }  // namespace dart
 
 #endif  // VM_TIMELINE_H_