Revert r32930 (Add more timing information in the VM to track time...)

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, 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 "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
@@ skipping 525 matching lines @@
   // Different objects.
   EXPECT(!Dart_IdentityEquals(five, seven));
 
   // Case where identical() is not the same as pointer equality.
   Dart_Handle nan1 = Dart_NewDouble(NAN);
   Dart_Handle nan2 = Dart_NewDouble(NAN);
   EXPECT(Dart_IdentityEquals(nan1, nan2));
 
   // Non-instance objects.
   {
+    Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
     Dart_Handle lib1 = Dart_LookupLibrary(dart_core);
     Dart_Handle lib2 = Dart_LookupLibrary(dart_mirrors);
 
     EXPECT(Dart_IdentityEquals(lib1, lib1));
     EXPECT(Dart_IdentityEquals(lib2, lib2));
     EXPECT(!Dart_IdentityEquals(lib1, lib2));
 
     // Mix instance and non-instance.
     EXPECT(!Dart_IdentityEquals(lib1, nan1));
     EXPECT(!Dart_IdentityEquals(nan1, lib1));
@@ skipping 1224 matching lines @@
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   Dart_EnterScope();
   {
     EXPECT(state->top_scope() != NULL);
-    HANDLESCOPE(isolate);
+    DARTSCOPE(isolate);
     const String& str1 = String::Handle(String::New("Test String"));
     Dart_Handle ref = Api::NewHandle(isolate, str1.raw());
     String& str2 = String::Handle();
     str2 ^= Api::UnwrapHandle(ref);
     EXPECT(str1.Equals(str2));
   }
   Dart_ExitScope();
   EXPECT(scope == state->top_scope());
 }
 
 
 // Unit test for creating and deleting persistent handles.
 UNIT_TEST_CASE(PersistentHandles) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   Dart_PersistentHandle handles[2000];
   Dart_EnterScope();
   {
-    HANDLESCOPE(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle ref1 = Api::NewHandle(isolate, String::New(kTestString1));
     for (int i = 0; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref1);
     }
     Dart_EnterScope();
     Dart_Handle ref2 = Api::NewHandle(isolate, String::New(kTestString2));
     for (int i = 1000; i < 2000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref2);
     }
     for (int i = 500; i < 1500; i++) {
@@ skipping 41 matching lines @@
 
 // Test that we are able to create a persistent handle from a
 // persistent handle.
 UNIT_TEST_CASE(NewPersistentHandle_FromPersistentHandle) {
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
+  DARTSCOPE(isolate);
 
   // Start with a known persistent handle.
   Dart_PersistentHandle obj1 = Dart_NewPersistentHandle(Dart_True());
   EXPECT(state->IsValidPersistentHandle(obj1));
 
   // And use it to allocate a second persistent handle.
   Dart_Handle obj2 = Dart_HandleFromPersistent(obj1);
   Dart_PersistentHandle obj3 = Dart_NewPersistentHandle(obj2);
   EXPECT(state->IsValidPersistentHandle(obj3));
 
@@ skipping 10 matching lines @@
 // Test that we can assign to a persistent handle.
 UNIT_TEST_CASE(AssignToPersistentHandle) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
-  HANDLESCOPE(isolate);
+  DARTSCOPE(isolate);
   String& str = String::Handle();
 
   // Start with a known persistent handle.
   Dart_Handle ref1 = Api::NewHandle(isolate, String::New(kTestString1));
   Dart_PersistentHandle obj = Dart_NewPersistentHandle(ref1);
   EXPECT(state->IsValidPersistentHandle(obj));
   str ^= Api::UnwrapAsPersistentHandle(obj)->raw();
   EXPECT(str.Equals(kTestString1));
 
   // Now create another local handle and assign it to the persistent handle.
@@ skipping 44 matching lines @@
     Dart_EnterScope();
 
     // Create an object in new space.
     Dart_Handle new_ref = NewString("new string");
     EXPECT_VALID(new_ref);
 
     // Create an object in old space.
     Dart_Handle old_ref;
     {
       Isolate* isolate = Isolate::Current();
-      HANDLESCOPE(isolate);
+      DARTSCOPE(isolate);
       old_ref = Api::NewHandle(isolate, String::New("old string", Heap::kOld));
       EXPECT_VALID(old_ref);
     }
 
     // Create a weak ref to the new space object.
     weak_new_ref = Dart_NewWeakPersistentHandle(new_ref, NULL, NULL);
     EXPECT_VALID(AsHandle(weak_new_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
 
     // Create a weak ref to the old space object.
@@ skipping 141 matching lines @@
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_WeakPersistentHandle weak1 = NULL;
   Dart_WeakPersistentHandle weak2 = NULL;
   Dart_WeakPersistentHandle weak3 = NULL;
   Dart_WeakPersistentHandle weak4 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
+
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong)));
 
     weak1 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kOld)),
         NULL, NULL);
@@ skipping 196 matching lines @@
 }
 
 
 TEST_CASE(PrologueWeakPersistentHandles) {
   Dart_WeakPersistentHandle old_pwph = NULL;
   Dart_WeakPersistentHandle new_pwph = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
     new_pwph = Dart_NewPrologueWeakPersistentHandle(
         Api::NewHandle(isolate,
                        String::New("new space prologue weak", Heap::kNew)),
         NULL, NULL);
     EXPECT_VALID(AsHandle(new_pwph));
     EXPECT(!Dart_IsNull(AsHandle(new_pwph)));
     old_pwph = Dart_NewPrologueWeakPersistentHandle(
         Api::NewHandle(isolate,
                        String::New("old space prologue weak", Heap::kOld)),
         NULL, NULL);
@@ skipping 66 matching lines @@
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_WeakPersistentHandle weak1 = NULL;
   Dart_WeakPersistentHandle weak2 = NULL;
   Dart_WeakPersistentHandle weak3 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
+
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
@@ skipping 84 matching lines @@
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_WeakPersistentHandle weak1 = NULL;
   Dart_WeakPersistentHandle weak2 = NULL;
   Dart_WeakPersistentHandle weak3 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
+
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
@@ skipping 1095 matching lines @@
   result = Dart_CreateNativeWrapperClass(
       lib,
       NewString("NativeFieldsWrapper"),
       kNumNativeFields);
 
   // Load up a test script in the test library.
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
-  HANDLESCOPE(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
@@ skipping 48 matching lines @@
   Dart_Handle result;
   const int kNumNativeFields = 2;
 
   // Load up a test script in the test library.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
                                              native_field_lookup);
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
-  HANDLESCOPE(Isolate::Current());
+  DARTSCOPE(Isolate::Current());
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
@@ skipping 319 matching lines @@
       "  static const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain1() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n"
       "Function testMain2() {\n"
       "  return () {};\n"
       "}\n";
   Dart_Handle result;
+  DARTSCOPE(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns an object of type NativeFields.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, NULL);
   EXPECT_VALID(retobj);
 
   // Now access and set various native instance fields of the returned object.
   // All of these tests are expected to return failure as there are no
@@ skipping 57 matching lines @@
       "  var port = new RawReceivePort();\n"
       "  var obj = new Test(1,2);\n"
       "  var msg = [obj, port.sendPort];\n"
       "  var snd = Isolate.spawn(echo, msg);\n"
       "  port.handler = (msg) {\n"
       "    port.close();\n"
       "    print('from worker ${msg}');\n"
       "  };\n"
       "}\n";
 
+  DARTSCOPE(Isolate::Current());
+
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke 'main' which should spawn an isolate and try to send an
   // object with native fields over to the spawned isolate. This
   // should result in an unhandled exception which is checked.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(retobj));
 }
 
@@ skipping 650 matching lines @@
       "  static const int fld4 = 10;\n"
       "}\n"
       "Function testMain1() {\n"
       "  InvokeClosure obj = new InvokeClosure(10, 20);\n"
       "  return obj.method1(10);\n"
       "}\n"
       "Function testMain2() {\n"
       "  return InvokeClosure.method2(10);\n"
       "}\n";
   Dart_Handle result;
+  DARTSCOPE(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns a closure.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, NULL);
   EXPECT_VALID(retobj);
 
   EXPECT(Dart_IsClosure(retobj));
   EXPECT(!Dart_IsClosure(Dart_NewInteger(101)));
@@ skipping 1718 matching lines @@
 const int kInterruptCount = 10;
 static int interrupt_count = 0;
 static bool IsolateInterruptTestCallback() {
   OS::Print(" ========== Interrupt callback called #%d\n", interrupt_count + 1);
   {
     MonitorLocker ml(sync);
     interrupt_count++;
     ml.Notify();
   }
   if (interrupt_count == kInterruptCount) {
-    START_TIMER(Isolate::Current(), time_native_execution);
     Dart_EnterScope();
     Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
     EXPECT_VALID(lib);
     Dart_Handle exc = NewString("foo");
     EXPECT_VALID(exc);
     Dart_Handle result = Dart_ThrowException(exc);
     EXPECT_VALID(result);
     UNREACHABLE();  // Dart_ThrowException only returns if it gets an error.
     return false;
   }
@@ skipping 576 matching lines @@
 }
 
 
 // Allocates an object in new space and assigns it a peer.  Allows the
 // peer referent to be garbage collected and checks that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneNewSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
+    DARTSCOPE(isolate);
     Dart_Handle str = NewString("a string");
     EXPECT_VALID(str);
     EXPECT(Dart_IsString(str));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* out = &out;
     EXPECT_VALID(Dart_GetPeer(str, &out));
     EXPECT(out == NULL);
     int peer = 1234;
     EXPECT_VALID(Dart_SetPeer(str, &peer));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 52 matching lines @@
 }
 
 
 // Allocates two objects in new space and assigns them a peer.  Allow
 // the peer referents to be garbage collected and check that the count
 // of peer objects is decremented by two.
 TEST_CASE(CollectTwoNewSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
+    DARTSCOPE(isolate);
     Dart_Handle s1 = NewString("s1");
     EXPECT_VALID(s1);
     EXPECT(Dart_IsString(s1));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* o1 = &o1;
     EXPECT(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == NULL);
     int p1 = 1234;
     EXPECT_VALID(Dart_SetPeer(s1, &p1));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 63 matching lines @@
   EXPECT(out == NULL);
   int peer = 1234;
   EXPECT_VALID(Dart_SetPeer(str, &peer));
   out = &out;
   EXPECT(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   isolate->heap()->CollectGarbage(Heap::kNew);
   isolate->heap()->CollectGarbage(Heap::kNew);
   {
-    HANDLESCOPE(isolate);
+    DARTSCOPE(isolate);
     String& handle = String::Handle();
     handle ^= Api::UnwrapHandle(str);
     EXPECT(handle.IsOld());
   }
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   EXPECT_VALID(Dart_SetPeer(str, NULL));
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
@@ skipping 32 matching lines @@
 }
 
 
 // Allocates an object in old space and assigns it a peer.  Allow the
 // peer referent to be garbage collected and check that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneOldSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    HANDLESCOPE(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle str = Api::NewHandle(isolate, String::New("str", Heap::kOld));
     EXPECT_VALID(str);
     EXPECT(Dart_IsString(str));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* out = &out;
     EXPECT(Dart_GetPeer(str, &out));
     EXPECT(out == NULL);
     int peer = 1234;
     EXPECT_VALID(Dart_SetPeer(str, &peer));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 55 matching lines @@
 }
 
 
 // Allocates two objects in old space and assigns them a peer.  Allows
 // the peer referents to be garbage collected and checks that the
 // count of peer objects is decremented by two.
 TEST_CASE(CollectTwoOldSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    HANDLESCOPE(isolate);
+    DARTSCOPE(isolate);
     Dart_Handle s1 = Api::NewHandle(isolate, String::New("s1", Heap::kOld));
     EXPECT_VALID(s1);
     EXPECT(Dart_IsString(s1));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* o1 = &o1;
     EXPECT(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == NULL);
     int p1 = 1234;
     EXPECT_VALID(Dart_SetPeer(s1, &p1));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 456 matching lines @@
                                    NewString("main"),
                                    1,
                                    dart_args);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(6, value);
 }
 
 }  // namespace dart