Add more timing information in the VM to track time spent is dart code Vs native code.

runtime/vm/dart_api_impl.h

 // Copyright (c) 2011, 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_DART_API_IMPL_H_
 #define VM_DART_API_IMPL_H_
 
 #include "vm/allocation.h"
 #include "vm/native_arguments.h"
 #include "vm/object.h"
+#include "vm/timer.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, trace_api);
 
 class ApiLocalScope;
 class ApiState;
 class FinalizablePersistentHandle;
 class LocalHandle;
 class PersistentHandle;
@@ skipping 37 matching lines @@
 #define CHECK_ISOLATE_SCOPE(isolate)                                           \
   do {                                                                         \
     Isolate* tmp = (isolate);                                                  \
     CHECK_ISOLATE(tmp);                                                        \
     ApiState* state = tmp->api_state();                                        \
     ASSERT(state);                                                             \
     if (state->top_scope() == NULL) {                                          \
       FATAL1("%s expects to find a current scope. Did you forget to call "     \
            "Dart_EnterScope?", CURRENT_FUNC);                                  \
     }                                                                          \
-  } while (0)
+  } while (0);                                                                 \
+  NativeToVmTimerScope __temp_isolate_timer__(isolate);
 
 #define DARTSCOPE(isolate)                                                     \
   Isolate* __temp_isolate__ = (isolate);                                       \
   CHECK_ISOLATE_SCOPE(__temp_isolate__);                                       \
   HANDLESCOPE(__temp_isolate__);
 
 
 #define RETURN_TYPE_ERROR(isolate, dart_handle, type)                          \
   do {                                                                         \
     const Object& tmp =                                                        \
@@ skipping 174 matching lines @@
   }
   ~IsolateSaver() {
     Isolate::SetCurrent(saved_isolate_);
   }
  private:
   Isolate* saved_isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateSaver);
 };
 
+class VmToNativeTimerScope : public ValueObject {
+ public:
+  explicit VmToNativeTimerScope(Isolate* isolate) {
+    native_timer_ = &(isolate->timer_list().time_native_execution());
+    native_timer_->Start();
+  }
+  ~VmToNativeTimerScope() {
+    native_timer_->Stop();
+  }
+
+ private:
+  Timer* native_timer_;
+  DISALLOW_COPY_AND_ASSIGN(VmToNativeTimerScope);
+};
+
+class NativeToVmTimerScope : public ValueObject {
+ public:
+  explicit NativeToVmTimerScope(Isolate* isolate)
+      : dart_running_(false),
+        timer_list_(&(isolate->timer_list())) {
+    Timer* dart_timer = &(timer_list_->time_dart_execution());
+    Timer* native_timer = &(timer_list_->time_native_execution());
+    // Currently when a native function is setup without the auto scope
+    // setup parameter (leaf function) we would have the dart timer still
+    // running as we have not done any transitioning. If for some reason
+    // such a native function makes API call backs we should account for
+    // that.
+    if (dart_timer->running()) {
+      dart_running_ = true;
+      dart_timer->Stop();
+    } else if (native_timer->running()) {
+      native_timer->Stop();
+    }

[turnidge, 2014/02/11 21:24:33]

Is it ever the case that neither timer is running here?

[siva, 2014/02/19 22:38:30]

Changed the code to have just
if (dart_timer->running()) {
 ....
 ....
} else {
 native_timer->Stop();
}

This ensures that in this transition only Dart or Native code is executing.

On 2014/02/11 21:24:33, turnidge wrote:

+  }
+  ~NativeToVmTimerScope() {
+    if (dart_running_) {
+      Timer* dart_timer = &(timer_list_->time_dart_execution());
+      dart_timer->Start();
+    } else {
+      Timer* native_timer = &(timer_list_->time_native_execution());
+      native_timer->Start();
+    }
+  }
+
+ private:
+  bool dart_running_;
+  TimerList* timer_list_;
+  DISALLOW_COPY_AND_ASSIGN(NativeToVmTimerScope);
+};
+
 // Start a scope in which no Dart API call backs are allowed.
 #define START_NO_CALLBACK_SCOPE(isolate)                                       \
   isolate->IncrementNoCallbackScopeDepth()
 
 // End a no Dart API call backs Scope.
 #define END_NO_CALLBACK_SCOPE(isolate)                                         \
   isolate->DecrementNoCallbackScopeDepth()
 
 #define CHECK_CALLBACK_STATE(isolate)                                          \
   if (isolate->no_callback_scope_depth() != 0) {                               \
     return reinterpret_cast<Dart_Handle>(Api::AcquiredError(isolate));         \
   }                                                                            \
 
 #define ASSERT_CALLBACK_STATE(isolate)                                         \
   ASSERT(isolate->no_callback_scope_depth() == 0)
 
 }  // namespace dart.
 
 #endif  // VM_DART_API_IMPL_H_