Make TimelineRingRecorder use TimelineEventBlocks

runtime/vm/timeline.cc

 // 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.
 
 #include <cstdlib>
 
 #include "vm/isolate.h"
 #include "vm/json_stream.h"
 #include "vm/lockers.h"
 #include "vm/object.h"
@@ skipping 314 matching lines @@
 
 
 TimelineEventRecorder::TimelineEventRecorder() {
 }
 
 
 void TimelineEventRecorder::PrintJSONMeta(JSONArray* events) const {
 }
 
 
+TimelineEvent* TimelineEventRecorder::ThreadBlockStartEvent() {
+  // Grab the thread's timeline event block.
+  Thread* thread = Thread::Current();
+  TimelineEventBlock* thread_block = thread->timeline_block();
+  if ((thread_block == NULL) || thread_block->IsFull()) {
+    // If it is full, request a new block.
+    thread_block = GetNewBlock();
+    thread->set_timeline_block(thread_block);
+  }
+  if (thread_block == NULL) {
+    // Could not allocate block.
+    return NULL;
+  }
+  ASSERT(thread_block != NULL);
+  ASSERT(!thread_block->IsFull());
+  return thread_block->StartEvent();
+}
+
+
 void TimelineEventRecorder::WriteTo(const char* directory) {
   Isolate* isolate = Isolate::Current();
 
   Dart_FileOpenCallback file_open = Isolate::file_open_callback();
   Dart_FileWriteCallback file_write = Isolate::file_write_callback();
   Dart_FileCloseCallback file_close = Isolate::file_close_callback();
   if ((file_open == NULL) || (file_write == NULL) || (file_close == NULL)) {
     return;
   }
 
@@ skipping 10 matching lines @@
   void* file = (*file_open)(filename, true);
   if (file == NULL) {
     OS::Print("Failed to write timeline file: %s\n", filename);
     return;
   }
   (*file_write)(js.buffer()->buf(), js.buffer()->length(), file);
   (*file_close)(file);
 }
 
 
-intptr_t TimelineEventRingRecorder::SizeForCapacity(intptr_t capacity) {
-  return sizeof(TimelineEvent) * capacity;
-}
-
 
 TimelineEventRingRecorder::TimelineEventRingRecorder(intptr_t capacity)
-    : events_(NULL),
+    : blocks_(NULL),
       event_objects_(Array::null()),
-      cursor_(0),
-      capacity_(capacity) {
-  if (FLAG_trace_timeline) {
-    // 32-bit: 262,144 bytes per isolate.
-    // 64-bit: 393,216 bytes per isolate.
-    // NOTE: Internal isolates (vm and service) do not have a timeline
-    // event buffer.
-    OS::Print("TimelineEventRingRecorder is %" Pd " bytes (%" Pd " events)\n",
-              SizeForCapacity(capacity),
-              capacity);
+      capacity_(capacity),
+      num_blocks_(0),
+      block_cursor_(0) {
+  // Capacity must be a multiple of TimelineEventBlock::kBlockSize
+  ASSERT((capacity % TimelineEventBlock::kBlockSize) == 0);
+  // Allocate blocks array.
+  num_blocks_ = capacity / TimelineEventBlock::kBlockSize;
+  blocks_ =
+      reinterpret_cast<TimelineEventBlock**>(
+          calloc(num_blocks_, sizeof(TimelineEventBlock*)));
+  // Allocate each block.
+  for (intptr_t i = 0; i < num_blocks_; i++) {
+    blocks_[i] = new TimelineEventBlock(i);
   }
-  events_ =
-      reinterpret_cast<TimelineEvent*>(calloc(capacity, sizeof(TimelineEvent)));
+  // Chain blocks together.
+  for (intptr_t i = 0; i < num_blocks_ - 1; i++) {
+    blocks_[i]->set_next(blocks_[i + 1]);
+  }
   const Array& array = Array::Handle(Array::New(capacity, Heap::kOld));
   event_objects_ = array.raw();
 }
 
 
 TimelineEventRingRecorder::~TimelineEventRingRecorder() {
-  for (intptr_t i = 0; i < capacity_; i++) {
-    // Clear any extra data.
-    events_[i].Reset();
+  // Delete all blocks.
+  for (intptr_t i = 0; i < num_blocks_; i++) {
+    TimelineEventBlock* block = blocks_[i];
+    delete block;
   }
-  free(events_);
+  free(blocks_);
   event_objects_ = Array::null();
 }
 
 
 void TimelineEventRingRecorder::PrintJSONEvents(JSONArray* events) const {
-  for (intptr_t i = 0; i < capacity_; i++) {
-    if (events_[i].IsValid()) {
-      events->AddValue(&events_[i]);
+  // TODO(johnmccutchan): This output needs to start with the oldest block
+  // first.
+  for (intptr_t block_idx = 0; block_idx < num_blocks_; block_idx++) {
+    TimelineEventBlock* block = blocks_[block_idx];
+    if (block->IsEmpty()) {
+      // Skip empty blocks.
+      continue;
+    }
+    for (intptr_t event_idx = 0; event_idx < block->length(); event_idx++) {
+      TimelineEvent* event = block->At(event_idx);
+      if (event->IsValid()) {
+        events->AddValue(event);
+      }
     }
   }
 }
 
 
 void TimelineEventRingRecorder::PrintJSON(JSONStream* js) {
+  MutexLocker ml(&lock_);
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
     PrintJSONEvents(&events);
   }
 }
 
 
-intptr_t TimelineEventRingRecorder::GetNextIndex() {
-  uintptr_t cursor = AtomicOperations::FetchAndIncrement(&cursor_);
-  return cursor % capacity_;
+TimelineEventBlock* TimelineEventRingRecorder::GetNewBlock() {
+  MutexLocker ml(&lock_);
+  return GetNewBlockLocked();
 }
 
 
+TimelineEventBlock* TimelineEventRingRecorder::GetNewBlockLocked() {
+  if (block_cursor_ == num_blocks_) {
+    block_cursor_ = 0;
+  }
+  TimelineEventBlock* block = blocks_[block_cursor_++];
+  block->Reset();
+  return block;
+}
+
+
 void TimelineEventRingRecorder::VisitObjectPointers(
     ObjectPointerVisitor* visitor) {
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&event_objects_));
 }
 
 
 TimelineEvent* TimelineEventRingRecorder::StartEvent(const Object& obj) {
-  ASSERT(events_ != NULL);
-  uintptr_t index = GetNextIndex();
+  TimelineEvent* event = StartEvent();
+  if (event == NULL) {
+    return NULL;
+  }
+  // Grab the thread's timeline event block which contains |event|.
+  Thread* thread = Thread::Current();
+  TimelineEventBlock* thread_block = thread->timeline_block();
+  ASSERT(thread_block != NULL);
+  ASSERT(thread_block->length() > 0);
+  const intptr_t block_index = thread_block->block_index();
+  const intptr_t event_objects_index =
+      block_index * TimelineEventBlock::kBlockSize + thread_block->length() - 1;
   const Array& event_objects = Array::Handle(event_objects_);
-  event_objects.SetAt(index, obj);
-  return &events_[index];
+  event_objects.SetAt(event_objects_index, obj);
+  return event;
 }
 
 
 TimelineEvent* TimelineEventRingRecorder::StartEvent() {
-  ASSERT(events_ != NULL);
-  uintptr_t index = GetNextIndex();
-  return &events_[index];
+  return ThreadBlockStartEvent();
 }
 
+
 void TimelineEventRingRecorder::CompleteEvent(TimelineEvent* event) {
-  ASSERT(events_ != NULL);
   // no-op.
 }
 
 
 TimelineEventStreamingRecorder::TimelineEventStreamingRecorder() {
 }
 
 
 TimelineEventStreamingRecorder::~TimelineEventStreamingRecorder() {
 }
 
 
 void TimelineEventStreamingRecorder::PrintJSON(JSONStream* js) {
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
     PrintJSONMeta(&events);
   }
 }
 
+
 void TimelineEventStreamingRecorder::VisitObjectPointers(
     ObjectPointerVisitor* visitor) {
   // no-op.
 }
 
 
 TimelineEvent* TimelineEventStreamingRecorder::StartEvent(
     const Object& object) {
   // The streaming recorder does not track Dart objects.
   return StartEvent();
 }
 
 
 TimelineEvent* TimelineEventStreamingRecorder::StartEvent() {
   TimelineEvent* event = new TimelineEvent();
   return event;
 }
 
 
 void TimelineEventStreamingRecorder::CompleteEvent(TimelineEvent* event) {
   StreamEvent(event);
   delete event;
 }
 
 
 TimelineEventEndlessRecorder::TimelineEventEndlessRecorder()
-    : head_(NULL) {
+    : head_(NULL),
+      block_index_(0) {
   GetNewBlock();
 }
 
 
 void TimelineEventEndlessRecorder::PrintJSON(JSONStream* js) {
   MutexLocker ml(&lock_);
   JSONObject topLevel(js);
   topLevel.AddProperty("type", "_Timeline");
   {
     JSONArray events(&topLevel, "traceEvents");
@@ skipping 14 matching lines @@
   // no-op.
 }
 
 
 TimelineEvent* TimelineEventEndlessRecorder::StartEvent(const Object& object) {
   return StartEvent();
 }
 
 
 TimelineEvent* TimelineEventEndlessRecorder::StartEvent() {
-  // Grab the thread's timeline event block.
-  Thread* thread = Thread::Current();
-  TimelineEventBlock* thread_block = thread->timeline_block();
-  if (thread_block == NULL) {
-    return NULL;
-  }
-  ASSERT(thread_block != NULL);
-  if (thread_block->IsFull()) {
-    // If it is full, request a new block.
-    thread_block = GetNewBlock();
-    thread->set_timeline_block(thread_block);
-  }
-  ASSERT(!thread_block->IsFull());
-  return thread_block->StartEvent();
+  return ThreadBlockStartEvent();
 }
 
 
 void TimelineEventEndlessRecorder::CompleteEvent(TimelineEvent* event) {
   // no-op.
 }
 
 
 TimelineEventBlock* TimelineEventEndlessRecorder::GetNewBlockLocked() {
-  TimelineEventBlock* block = new TimelineEventBlock();
+  TimelineEventBlock* block = new TimelineEventBlock(block_index_++);
   block->set_next(head_);
   head_ = block;
   return head_;
 }
 
 
 void TimelineEventEndlessRecorder::PrintJSONEvents(JSONArray* events) const {
   TimelineEventBlock* current = head_;
   while (current != NULL) {
     intptr_t length = current->length();
     for (intptr_t i = 0; i < length; i++) {
       TimelineEvent* event = current->At(i);
       if (!event->IsValid()) {
         continue;
       }
       events->AddValue(event);
     }
     current = current->next();
   }
 }
 
 
-TimelineEventBlock::TimelineEventBlock()
+TimelineEventBlock::TimelineEventBlock(intptr_t block_index)
     : next_(NULL),
-      length_(0) {
+      length_(0),
+      block_index_(block_index) {
 }
 
 
+TimelineEventBlock::~TimelineEventBlock() {
+  Reset();
+}
+
+
 TimelineEvent* TimelineEventBlock::StartEvent() {
   ASSERT(!IsFull());
   return &events_[length_++];
 }
 
 
 ThreadId TimelineEventBlock::thread() const {
   ASSERT(length_ > 0);
   return events_[0].thread();
 }
@@ skipping 24 matching lines @@
     if (last_time > At(i)->TimeOrigin()) {
       return false;
     }
     last_time = At(i)->TimeOrigin();
   }
 
   return true;
 }
 
 
+void TimelineEventBlock::Reset() {
+  for (intptr_t i = 0; i < kBlockSize; i++) {
+    // Clear any extra data.
+    events_[i].Reset();
+  }
+  length_ = 0;
+}
+
+
 TimelineEventBlockIterator::TimelineEventBlockIterator(
     TimelineEventEndlessRecorder* recorder)
     : current_(NULL),
       recorder_(recorder) {
   if (recorder_ == NULL) {
     return;
   }
   recorder->lock_.Lock();
 }
 
@@ skipping 17 matching lines @@
   }
   if (current_ == NULL) {
     current_ = recorder_->head_;
   } else {
     current_ = current_->next();
   }
   return current_ != NULL;
 }
 
 }  // namespace dart