Speed up the Dart_IsBlah functions by checking the class index. This

vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 24 matching lines @@
 ThreadLocalKey Api::api_native_key_ = Thread::kUnsetThreadLocalKey;
 
 const char* CanonicalFunction(const char* func) {
   if (strncmp(func, "dart::", 6) == 0) {
     return func + 6;
   } else {
     return func;
   }
 }
 
-#define RETURN_TYPE_ERROR(isolate, dart_handle, Type)                         \
-  do {                                                                        \
-    const Object& tmp =                                                       \
-        Object::Handle(isolate, Api::UnwrapHandle((dart_handle)));            \
-    if (tmp.IsNull()) {                                                       \
-      return Api::NewError("%s expects argument '%s' to be non-null.",        \
-                           CURRENT_FUNC, #dart_handle);                       \
-    } else if (tmp.IsError()) {                                               \
-      return dart_handle;                                                     \
-    } else {                                                                  \
-      return Api::NewError("%s expects argument '%s' to be of type %s.",      \
-                           CURRENT_FUNC, #dart_handle, #Type);                \
-    }                                                                         \
+#define RETURN_TYPE_ERROR(isolate, dart_handle, Type)                   \
+  do {                                                                  \
+    const Object& tmp =                                                 \
+        Object::Handle(isolate, Api::UnwrapHandle((dart_handle)));      \
+    if (tmp.IsNull()) {                                                 \
+      return Api::NewError("%s expects argument '%s' to be non-null.",  \
+                           CURRENT_FUNC, #dart_handle);                 \
+    } else if (tmp.IsError()) {                                         \
+      return dart_handle;                                               \
+    } else {                                                            \
+      return Api::NewError("%s expects argument '%s' to be of type %s.", \
+                           CURRENT_FUNC, #dart_handle, #Type);          \
+    }                                                                   \
   } while (0)
 
 
 // Return error if isolate is in an inconsistent state.
 // Return NULL when no error condition exists.
 const char* CheckIsolateState(Isolate* isolate, bool generating_snapshot) {
   bool success = true;
   if (!ClassFinalizer::AllClassesFinalized()) {
     success = (generating_snapshot) ?
         ClassFinalizer::FinalizePendingClassesForSnapshotCreation() :
@@ skipping 45 matching lines @@
          state->IsValidWeakPersistentHandle(object) ||
          state->IsValidPersistentHandle(object) ||
          state->IsValidLocalHandle(object));
   ASSERT(FinalizablePersistentHandle::raw_offset() == 0 &&
          PersistentHandle::raw_offset() == 0 &&
          LocalHandle::raw_offset() == 0);
 #endif
   return *(reinterpret_cast<RawObject**>(object));
 }
 
-#define DEFINE_UNWRAP(Type)                                                   \
-  const Type& Api::Unwrap##Type##Handle(Isolate* iso,                         \
-                                        Dart_Handle dart_handle) {            \
-    const Object& tmp = Object::Handle(iso, Api::UnwrapHandle(dart_handle));  \
-    Type& typed_handle = Type::Handle(iso);                                   \
-    if (tmp.Is##Type()) {                                                     \
-      typed_handle ^= tmp.raw();                                              \
-    }                                                                         \
-    return typed_handle;                                                      \
+#define DEFINE_UNWRAP(Type)                                             \
+  const Type& Api::Unwrap##Type##Handle(Isolate* iso,                   \
+                                        Dart_Handle dart_handle) {      \
+    const Object& tmp = Object::Handle(iso, Api::UnwrapHandle(dart_handle)); \
+    Type& typed_handle = Type::Handle(iso);                             \
+    if (tmp.Is##Type()) {                                               \
+      typed_handle ^= tmp.raw();                                        \
+    }                                                                   \
+    return typed_handle;                                                \
   }
 CLASS_LIST_NO_OBJECT(DEFINE_UNWRAP)
 #undef DEFINE_UNWRAP
 
 
 LocalHandle* Api::UnwrapAsLocalHandle(const ApiState& state,
                                       Dart_Handle object) {
   ASSERT(state.IsValidLocalHandle(object));
   return reinterpret_cast<LocalHandle*>(object);
 }
@@ skipping 110 matching lines @@
   ASSERT(api_native_key_ == Thread::kUnsetThreadLocalKey);
   api_native_key_ = Thread::CreateThreadLocal();
   ASSERT(api_native_key_ != Thread::kUnsetThreadLocalKey);
 }
 
 
 // --- Handles ---
 
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
-  return obj.IsError();
+  ASSERT(kError + 5 == kInstance);  // There are 4 subtypes of Error.

[Ivan Posva, 2012/05/09 23:28:16]

This is brittle in case we delete one of the error types and add a new non-error
type before kInstance. Should we just enumerate them here?

[turnidge, 2012/05/10 17:49:38]

I have moved all of these predicates to raw_object.h.  I considered attaching
the functions to the Raw classes (like putting IsErrorClassIndex on RawError)
but it got odd in the case of builtin LIst types (they don't seem to have a
common supertype) so I left them as standalone functions.  I have expanded the
asserts to try to make them less brittle.

+  intptr_t class_index = Api::ClassIndex(handle);
+  return (class_index >= kError && class_index < kInstance);
 }
 
 
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsError()) {
     Error& error = Error::Handle(isolate);
     error ^= obj.raw();
@@ skipping 91 matching lines @@
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
   Exceptions::PropagateError(error);
   UNREACHABLE();
 
   return Api::NewError("Cannot reach here.  Internal error.");
 }
 
 
 DART_EXPORT void _Dart_ReportErrorHandle(const char* file,
-                                           int line,
-                                           const char* handle,
-                                           const char* message) {
+                                         int line,
+                                         const char* handle,
+                                         const char* message) {
   fprintf(stderr, "%s:%d: error handle: '%s':\n    '%s'\n",
           file, line, handle, message);
   OS::Abort();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
@@ skipping 613 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_Null() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::Null(isolate);
 }
 
 
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsNull();
+  ASSERT(kNullClassIndex + 1 == kDynamicClassIndex);  // No subtypes.
+  return Api::ClassIndex(object) == kNullClassIndex;
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Instance& expected =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj1));
   const Instance& actual =
@@ skipping 49 matching lines @@
   ASSERT(malformed_type_error.IsNull());  // Type was created here from a class.
   return Api::Success(isolate);
 }
 
 
 // --- Numbers ----
 
 
 // TODO(iposva): The argument should be an instance.
 DART_EXPORT bool Dart_IsNumber(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsNumber();
+  ASSERT(kNumber + 6 == kString);  // There are 5 subtypes of Number.

[Ivan Posva, 2012/05/09 23:28:16]

ditto.

+  intptr_t class_index = Api::ClassIndex(object);
+  return (class_index >= kNumber && class_index < kString);
 }
 
 
 // --- Integers ----
 
 
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object) {
-  // Fast path for Smis.
-  if (Api::IsSmi(object)) {
-    return true;
-  }
-
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsInteger();
+  ASSERT(kInteger + 4 == kDouble);  // There are 3 subtypes of Integer.

[Ivan Posva, 2012/05/09 23:28:16]

ditto.

+  intptr_t class_index = Api::ClassIndex(object);
+  return (class_index >= kInteger && class_index < kDouble);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
-  // Fast path for Smis.
+  // Fast path for Smis and Mints.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
-  if (Api::IsSmi(integer)) {
+  intptr_t class_index = Api::ClassIndex(integer);
+  if (class_index == kSmi || class_index == kMint) {
     *fits = true;
     return Api::Success(isolate);
   }
 
   DARTSCOPE_NOCHECKS(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
-  if (int_obj.IsSmi() || int_obj.IsMint()) {
-    *fits = true;
-  } else {
-    ASSERT(int_obj.IsBigint());
+  ASSERT(int_obj.IsBigint());
 #if defined(DEBUG)
-    Bigint& bigint = Bigint::Handle(isolate);
-    bigint ^= int_obj.raw();
-    ASSERT(!BigintOperations::FitsIntoMint(bigint));
+  Bigint& bigint = Bigint::Handle(isolate);
+  bigint ^= int_obj.raw();
+  ASSERT(!BigintOperations::FitsIntoMint(bigint));
 #endif
-    *fits = false;
-  }
+  *fits = false;
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer,
                                                    bool* fits) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
@@ skipping 146 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_False() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return Api::False(isolate);
 }
 
 
 DART_EXPORT bool Dart_IsBoolean(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsBool();
+  ASSERT(kBool + 1 == kArray);  // No subtypes.

[turnidge, 2012/05/10 17:49:38]

I dropped the asserts for types with no subtypes.  I felt that they were overly
paranoid -- let me know if you disagree.

+  return Api::ClassIndex(object) == kBool;
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewBoolean(bool value) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE_SCOPE(isolate);
   return value ? Api::True(isolate) : Api::False(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Bool& obj = Api::UnwrapBoolHandle(isolate, boolean_obj);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, boolean_obj, Bool);
   }
   *value = obj.value();
   return Api::Success(isolate);
 }
 
 
 // --- Doubles ---
 
 
 DART_EXPORT bool Dart_IsDouble(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsDouble();
+  ASSERT(kDouble + 1 == kString);  // No subtypes.
+  return Api::ClassIndex(object) == kDouble;
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, Double::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj,
                                          double* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Double& obj = Api::UnwrapDoubleHandle(isolate, double_obj);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, double_obj, Double);
   }
   *value = obj.value();
   return Api::Success(isolate);
 }
 
 
 // --- Strings ---
 
 
 DART_EXPORT bool Dart_IsString(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsString();
+  ASSERT(kString + 7 == kBool);  // There are 6 subtypes of String.

[Ivan Posva, 2012/05/09 23:28:16]

ditto.

+  intptr_t class_index = Api::ClassIndex(object);
+  return (class_index >= kString && class_index < kBool);
 }
 
 
 DART_EXPORT bool Dart_IsString8(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsOneByteString() || obj.IsExternalOneByteString();
+  intptr_t class_index = Api::ClassIndex(object);
+  return (class_index == kOneByteString ||
+          class_index == kExternalOneByteString);
 }
 
 
 DART_EXPORT bool Dart_IsString16(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return (obj.IsOneByteString() || obj.IsExternalOneByteString() ||
-          obj.IsTwoByteString() || obj.IsExternalTwoByteString());
+  intptr_t class_index = Api::ClassIndex(object);
+  return (class_index == kOneByteString ||
+          class_index == kTwoByteString ||
+          class_index == kExternalOneByteString ||
+          class_index == kExternalTwoByteString);
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(str));
   if (obj.IsString()) {
     String& string_obj = String::Handle(isolate);
     string_obj ^= obj.raw();
@@ skipping 29 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_NewString32(const uint32_t* codepoints,
                                          intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, String::New(codepoints, length));
 }
 
 
 DART_EXPORT bool Dart_IsExternalString(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const String& str = Api::UnwrapStringHandle(isolate, object);
-  if (str.IsNull()) {
-    return false;
-  }
-  return str.IsExternal();
+  intptr_t class_index = Api::ClassIndex(object);
+  return (class_index == kExternalOneByteString ||
+          class_index == kExternalTwoByteString ||
+          class_index == kExternalFourByteString);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ExternalStringGetPeer(Dart_Handle object,
                                                    void** peer) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str = Api::UnwrapStringHandle(isolate, object);
   if (str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, object, String);
@@ skipping 206 matching lines @@
                               &malformed_type_error)) {
       ASSERT(malformed_type_error.IsNull());  // Type is a raw List.
       return instance.raw();
     }
   }
   return Instance::null();
 }
 
 
 DART_EXPORT bool Dart_IsList(Dart_Handle object) {
+  ASSERT(kArray + 2 == kGrowableObjectArray);  // There is 1 subtype of Array.

[Ivan Posva, 2012/05/09 23:28:16]

ditto.

+  ASSERT(kGrowableObjectArray + 1 == kByteArray);  // No subtypes.
+  intptr_t class_index = Api::ClassIndex(object);
+  if (class_index >= kArray && class_index < kByteArray) {
+    return true;
+  }
+
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return (obj.IsArray() || obj.IsGrowableObjectArray() ||
-          (GetListInstance(isolate, obj) != Instance::null()));
+  return GetListInstance(isolate, obj) != Instance::null();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewList(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, Array::New(length));
 }
 
 
@@ skipping 324 matching lines @@
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // --- Byte Arrays ---
 
 
 DART_EXPORT bool Dart_IsByteArray(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsByteArray();
+  ASSERT(kByteArray + 21 == kClosure);  // There are 20 subtypes of ByteArray

[Ivan Posva, 2012/05/09 23:28:16]

ditto.

+  intptr_t class_index = Api::ClassIndex(object);
+  return (class_index >= kByteArray && class_index <= kClosure);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewByteArray(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   return Api::NewHandle(isolate, Uint8Array::New(length));
 }
 
 
@@ skipping 207 matching lines @@
                                                    intptr_t byte_offset,
                                                    double value) {
   return ByteArraySetAt(array, byte_offset, value);
 }
 
 
 // --- Closures ---
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
+  // We can't use a fast class index check here because there are many
+  // different signature classes for closures.
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsClosure();
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
@@ skipping 863 matching lines @@
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
   }
   CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
-  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
-  return obj.IsLibrary();
+  ASSERT(kLibrary + 1 == kLibraryPrefix);  // No subtypes.
+  return Api::ClassIndex(object) == kLibrary;
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library, Dart_Handle name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(isolate, Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString()) {
     return Api::NewError("Invalid class name specified");
   }
@@ skipping 179 matching lines @@
       *buffer = NULL;
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 }  // namespace dart