Implement safepointing of threads

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 339 matching lines @@
   if (function.IsNull()) {
     return ApiError::New(String::Handle(String::New("")));
   }
   const Array& args = Array::Handle(Array::New(kNumArgs));
   args.SetAt(0, receiver);
   args.SetAt(1, argument);
   return DartEntry::InvokeFunction(function, args);
 }
 
 
+static const char* GetErrorString(Thread* thread, const Object& obj) {
+  if (obj.IsError()) {
+    const Error& error = Error::Cast(obj);
+    const char* str = error.ToErrorCString();
+    intptr_t len = strlen(str) + 1;
+    char* str_copy = Api::TopScope(thread)->zone()->Alloc<char>(len);
+    strncpy(str_copy, str, len);
+    // Strip a possible trailing '\n'.
+    if ((len > 1) && (str_copy[len - 2] == '\n')) {
+      str_copy[len - 2] = '\0';
+    }
+    return str_copy;
+  } else {
+    return "";
+  }
+}
+
+
 Dart_Handle Api::InitNewHandle(Thread* thread, RawObject* raw) {
   LocalHandles* local_handles = Api::TopScope(thread)->local_handles();
   ASSERT(local_handles != NULL);
   LocalHandle* ref = local_handles->AllocateHandle();
   ref->set_raw(raw);
   return ref->apiHandle();
 }
 
 
 Dart_Handle Api::NewHandle(Thread* thread, RawObject* raw) {
@@ skipping 74 matching lines @@
   return Api::NewHandle(thread, isolate->object_store()->sticky_error());
 }
 
 
 Dart_Isolate Api::CastIsolate(Isolate* isolate) {
   return reinterpret_cast<Dart_Isolate>(isolate);
 }
 
 
 Dart_Handle Api::NewError(const char* format, ...) {
-  DARTSCOPE(Thread::Current());
+  Thread* T = Thread::Current();
+  CHECK_API_SCOPE(T);
+  HANDLESCOPE(T);
   CHECK_CALLBACK_STATE(T);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = Z->Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, format);
@@ skipping 276 matching lines @@
   DARTSCOPE(Thread::Current());
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
   return (obj.IsUnwindError() && UnwindError::Cast(obj).is_vm_restart());
 }
 
 
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   API_TIMELINE_DURATION;
   DARTSCOPE(Thread::Current());
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
-  if (obj.IsError()) {
-    const Error& error = Error::Cast(obj);
-    const char* str = error.ToErrorCString();
-    intptr_t len = strlen(str) + 1;
-    char* str_copy = Api::TopScope(T)->zone()->Alloc<char>(len);
-    strncpy(str_copy, str, len);
-    // Strip a possible trailing '\n'.
-    if ((len > 1) && (str_copy[len - 2] == '\n')) {
-      str_copy[len - 2] = '\0';
-    }
-    return str_copy;
-  } else {
-    return "";
-  }
+  return GetErrorString(T, obj);
 }
 
 
 DART_EXPORT bool Dart_ErrorHasException(Dart_Handle handle) {
   DARTSCOPE(Thread::Current());
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
   return obj.IsUnhandledException();
 }
 
 
@@ skipping 36 matching lines @@
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewUnhandledExceptionError(Dart_Handle exception) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(T);
 
   Instance& obj = Instance::Handle(Z);
   intptr_t class_id = Api::ClassId(exception);
   if ((class_id == kApiErrorCid) || (class_id == kLanguageErrorCid)) {
-    obj = String::New(::Dart_GetError(exception));
+    const Object& excp = Object::Handle(Z, Api::UnwrapHandle(exception));
+    obj = String::New(GetErrorString(T, excp));
   } else {
     obj = Api::UnwrapInstanceHandle(Z, exception).raw();
     if (obj.IsNull()) {
       RETURN_TYPE_ERROR(Z, exception, Instance);
     }
   }
   const Stacktrace& stacktrace = Stacktrace::Handle(Z);
   return Api::NewHandle(T, UnhandledException::New(obj, stacktrace));
 }
 
@@ skipping 194 matching lines @@
 DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     intptr_t external_allocation_size,
     Dart_WeakPersistentHandleFinalizer callback) {
   Thread* thread = Thread::Current();
   CHECK_ISOLATE(thread->isolate());
   if (callback == NULL) {
     return NULL;
   }
+  TransitionNativeToVM transition(thread);
   return AllocateFinalizableHandle(thread,
                                    object,
                                    peer,
                                    external_allocation_size,
                                    callback);
 }
 
 
 DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object) {
   Isolate* isolate = Isolate::Current();
@@ skipping 198 matching lines @@
     const Error& error_obj =
         Error::Handle(Z, Dart::InitializeIsolate(snapshot, callback_data));
     if (error_obj.IsNull()) {
   #if defined(DART_NO_SNAPSHOT)
       if (FLAG_check_function_fingerprints) {
         Library::CheckFunctionFingerprints();
       }
   #endif  // defined(DART_NO_SNAPSHOT).
       // We exit the API scope entered above.
       Dart_ExitScope();
+      T->set_execution_state(Thread::kThreadInNative);
+      T->EnterSafepoint();
       return Api::CastIsolate(I);
     }
     *error = strdup(error_obj.ToErrorCString());
     // We exit the API scope entered above.
     Dart_ExitScope();
   }
   Dart::ShutdownIsolate();
   return reinterpret_cast<Dart_Isolate>(NULL);
 }
 
 
 DART_EXPORT void Dart_ShutdownIsolate() {
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
   CHECK_ISOLATE(I);
   {
     StackZone zone(T);
     HandleScope handle_scope(T);
     Dart::RunShutdownCallback();
   }
+  T->ExitSafepoint();
+  T->set_execution_state(Thread::kThreadInVM);
   Dart::ShutdownIsolate();
 }
 
 
 DART_EXPORT Dart_Isolate Dart_CurrentIsolate() {
   return Api::CastIsolate(Isolate::Current());
 }
 
 
 DART_EXPORT void* Dart_CurrentIsolateData() {
@@ skipping 23 matching lines @@
 DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate) {
   CHECK_NO_ISOLATE(Isolate::Current());
   // TODO(16615): Validate isolate parameter.
   Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   if (iso->HasMutatorThread()) {
     FATAL("Multiple mutators within one isolate is not supported.");
   }
   if (!Thread::EnterIsolate(iso)) {
     FATAL("Unable to Enter Isolate as Dart VM is shutting down");
   }
+  Thread* T = Thread::Current();
+  T->set_execution_state(Thread::kThreadInNative);
+  T->EnterSafepoint();
 }
 
 
 DART_EXPORT void Dart_ThreadDisableProfiling() {
   OSThread* os_thread = OSThread::Current();
   if (os_thread == NULL) {
     return;
   }
   os_thread->DisableThreadInterrupts();
 }
@@ skipping 198 matching lines @@
     data.done = false;
     I->message_handler()->Run(
         Dart::thread_pool(),
         NULL, RunLoopDone, reinterpret_cast<uword>(&data));
     while (!data.done) {
       ml.Wait();
     }
     if (!Thread::EnterIsolate(I)) {
       FATAL("Inconsistent state, VM shutting down while in run loop.");
     }
+    Thread* thread = Thread::Current();

[zra, 2016/01/08 23:32:07]

It looks like TransitionNativeToVM transition(thread) and DARTSCOPE manage the
thread state and safepoints automagically, but sometimes they're managed
manually, like here.

In places where they're managed manually, and there isn't a matching enter/exit
safepoint or set/unset thread state nearby, it would be helpful to know where
the matching calls are.

[siva, 2016/01/12 21:26:22]

DARTSCOPE has a TransitionNativeToVM in it which transitions the state on entry
and restores it back on exit. This works nicely for most calls but EnterIsolate
and ExitIsolate are special as the Thread is unscheduled on exit and we might
get scheduled on a different Thread structure on EnterIsolate so using a Stack
allocated object like TransitionNativeToVM would not work in that case and hence
the explicit code that transitions.

I will add a comment to make this clear.

+    thread->set_execution_state(Thread::kThreadInNative);
+    thread->EnterSafepoint();
   }
   if (I->object_store()->sticky_error() != Object::null()) {
     Dart_Handle error = Api::NewHandle(T, I->object_store()->sticky_error());
     I->object_store()->clear_sticky_error();
     return error;
   }
   if (FLAG_print_class_table) {
     HANDLESCOPE(T);
     I->class_table()->Print();
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_HandleMessage() {
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
   CHECK_API_SCOPE(T);
   CHECK_CALLBACK_STATE(T);
   API_TIMELINE_BEGIN_END;
+  TransitionNativeToVM trainsition(T);
   if (I->message_handler()->HandleNextMessage() != MessageHandler::kOK) {
     Dart_Handle error = Api::NewHandle(T, I->object_store()->sticky_error());
     I->object_store()->clear_sticky_error();
     return error;
   }
   return Api::Success();
 }
 
 
 DART_EXPORT bool Dart_HandleServiceMessages() {
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
   CHECK_API_SCOPE(T);
   CHECK_CALLBACK_STATE(T);
   API_TIMELINE_DURATION;
+  TransitionNativeToVM trainsition(T);
   ASSERT(I->GetAndClearResumeRequest() == false);
   MessageHandler::MessageStatus status =
       I->message_handler()->HandleOOBMessages();
   bool resume = I->GetAndClearResumeRequest();
   return (status != MessageHandler::kOK) || resume;
 }
 
 
 DART_EXPORT bool Dart_HasServiceMessages() {
   Isolate* isolate = Isolate::Current();
@@ skipping 3260 matching lines @@
   ASSERT(isolate->api_state() != NULL &&
          (isolate->api_state()->IsValidWeakPersistentHandle(rval)));
 #endif
   Api::SetWeakHandleReturnValue(arguments, rval);
 }
 
 
 // --- Environment ---
 RawString* Api::CallEnvironmentCallback(Thread* thread, const String& name) {
   Isolate* isolate = thread->isolate();
-  Scope api_scope(thread);
   Dart_EnvironmentCallback callback = isolate->environment_callback();
   String& result = String::Handle(thread->zone());
   if (callback != NULL) {
+    TransitionVMToNative transition(thread);
+    Scope api_scope(thread);
     Dart_Handle response = callback(Api::NewHandle(thread, name.raw()));
     if (::Dart_IsString(response)) {
       result ^= Api::UnwrapHandle(response);
     } else if (::Dart_IsError(response)) {
       const Object& error = Object::Handle(
           thread->zone(), Api::UnwrapHandle(response));
       Exceptions::ThrowArgumentError(
           String::Handle(String::New(Error::Cast(error).ToErrorCString())));
     } else if (!::Dart_IsNull(response)) {
       // At this point everything except null are invalid environment values.
@@ skipping 1133 matching lines @@
   return Api::Success();
 }
 #endif  // DART_PRECOMPILED
 
 
 DART_EXPORT bool Dart_IsRunningPrecompiledCode() {
   return Dart::IsRunningPrecompiledCode();
 }
 
 }  // namespace dart