Post-meetup feature extravaganza.

runtime/vm/isolate.cc

 // Copyright (c) 2013, 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 "vm/isolate.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "lib/mirrors.h"
@@ skipping 86 matching lines @@
     // Allow the embedder to handle message notification.
     (*callback)(Api::CastIsolate(isolate_));
   }
 }
 
 
 bool IsolateMessageHandler::HandleMessage(Message* message) {
   StartIsolateScope start_scope(isolate_);
   StackZone zone(isolate_);
   HandleScope handle_scope(isolate_);
+  // TODO(turnidge): Rework collection total dart execution.  This can
+  // overcount when other things (gc, compilation) are active.
+  TIMERSCOPE(time_dart_execution);
 
   // If the message is in band we lookup the receive port to dispatch to.  If
   // the receive port is closed, we drop the message without deserializing it.
   Object& receive_port = Object::Handle();
   if (!message->IsOOB()) {
     receive_port = DartLibraryCalls::LookupReceivePort(message->dest_port());
     if (receive_port.IsError()) {
       return ProcessUnhandledException(Object::null_instance(),
                                        Error::Cast(receive_port));
     }
@@ skipping 176 matching lines @@
       single_step_(false),
       random_(),
       simulator_(NULL),
       long_jump_base_(NULL),
       timer_list_(),
       deopt_id_(0),
       mutex_(new Mutex()),
       stack_limit_(0),
       saved_stack_limit_(0),
       message_handler_(NULL),
-      spawn_data_(0),
+      spawn_state_(NULL),
       is_runnable_(false),
       gc_prologue_callbacks_(),
       gc_epilogue_callbacks_(),
       defer_finalization_count_(0),
       deopt_context_(NULL),
       stacktrace_(NULL),
       stack_frame_index_(-1),
       object_histogram_(NULL),
       object_id_ring_(NULL),
       profiler_data_(NULL),
@@ skipping 15 matching lines @@
   delete debugger_;
 #if defined(USING_SIMULATOR)
   delete simulator_;
 #endif
   delete mutex_;
   mutex_ = NULL;  // Fail fast if interrupts are scheduled on a dead isolate.
   delete message_handler_;
   message_handler_ = NULL;  // Fail fast if we send messages to a dead isolate.
   ASSERT(deopt_context_ == NULL);  // No deopt in progress when isolate deleted.
   delete object_histogram_;
+  delete spawn_state_;
 }
 
 void Isolate::SetCurrent(Isolate* current) {
   Isolate* old_current = Current();
   if (old_current != current) {
     Profiler::EndExecution(old_current);
     Thread::SetThreadLocal(isolate_key, reinterpret_cast<uword>(current));
     Profiler::BeginExecution(current);
   }
 }
@@ skipping 142 matching lines @@
   // a StackResource, which requires a current isolate.
   mutex_->Lock();
   // Check if we are in a valid state to make the isolate runnable.
   if (is_runnable_ == true) {
     mutex_->Unlock();
     return false;  // Already runnable.
   }
   // Set the isolate as runnable and if we are being spawned schedule
   // isolate on thread pool for execution.
   is_runnable_ = true;
-  IsolateSpawnState* state = reinterpret_cast<IsolateSpawnState*>(spawn_data());
+  IsolateSpawnState* state = spawn_state();
   if (state != NULL) {
     ASSERT(this == state->isolate());
     Run();
   }
   mutex_->Unlock();
   return true;
 }
 
 
 static void StoreError(Isolate* isolate, const Object& obj) {
   ASSERT(obj.IsError());
   isolate->object_store()->set_sticky_error(Error::Cast(obj));
 }
 
 
 static bool RunIsolate(uword parameter) {
   Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
   IsolateSpawnState* state = NULL;
   {
+    // TODO(turnidge): Is this locking required here at all anymore?
     MutexLocker ml(isolate->mutex());
-    state = reinterpret_cast<IsolateSpawnState*>(isolate->spawn_data());
-    isolate->set_spawn_data(0);
+    state = isolate->spawn_state();
   }
   {
     StartIsolateScope start_scope(isolate);
     StackZone zone(isolate);
     HandleScope handle_scope(isolate);
     if (!ClassFinalizer::ProcessPendingClasses()) {
       // Error is in sticky error already.
       return false;
     }
 
     // Set up specific unhandled exception handler.
     const String& callback_name = String::Handle(
         isolate, String::New(state->exception_callback_name()));
     isolate->object_store()->
         set_unhandled_exception_handler(callback_name);
 
     Object& result = Object::Handle();
     result = state->ResolveFunction();
     bool is_spawn_uri = state->is_spawn_uri();
-    delete state;
-    state = NULL;
     if (result.IsError()) {
       StoreError(isolate, result);
       return false;
     }
     ASSERT(result.IsFunction());
     Function& func = Function::Handle(isolate);
     func ^= result.raw();
     func = func.ImplicitClosureFunction();
 
     // Instead of directly invoking the entry point we call '_startIsolate' with
@@ skipping 566 matching lines @@
   return func.raw();
 }
 
 
 void IsolateSpawnState::Cleanup() {
   SwitchIsolateScope switch_scope(isolate());
   Dart::ShutdownIsolate();
 }
 
 }  // namespace dart