Initial UserTag and dart:profiler library

runtime/vm/object.cc

Index: runtime/vm/object.cc
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index f81ec3dc50c8f44cb5f974af51abcae5e7e2122e..73405abd2a3c2afd7ba53219a389137385fabfa1 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -9,6 +9,7 @@
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/bigint_operations.h"
+#include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/code_generator.h"
@@ -1141,6 +1142,32 @@ RawError* Object::Init(Isolate* isolate) {
   object_store->set_mirror_reference_class(cls);
   RegisterPrivateClass(cls, Symbols::_MirrorReference(), lib);
 
+  // Pre-register the profiler library so we can place the vm class
+  // UserTag there rather than the core library.
+  lib = Library::LookupLibrary(Symbols::DartProfiler());
+  if (lib.IsNull()) {
+    lib = Library::NewLibraryHelper(Symbols::DartProfiler(), true);
+    lib.Register();
+    isolate->object_store()->set_bootstrap_library(ObjectStore::kProfiler,
+                                                   lib);
+  }
+  ASSERT(!lib.IsNull());
+  ASSERT(lib.raw() == Library::ProfilerLibrary());
+
+  lib = Library::LookupLibrary(Symbols::DartProfiler());
+  ASSERT(!lib.IsNull());
+  cls = Class::New<UserTag>();
+  object_store->set_user_tag_class(cls);
+  RegisterPrivateClass(cls, Symbols::_UserTag(), lib);

[siva, 2014/04/09 21:32:01]

pending_classes.Add(cls) ?

[Cutch, 2014/04/09 22:27:20]

Done.

+
+  cls = Class::New<Instance>(kIllegalCid);
+  RegisterClass(cls, Symbols::UserTag(), lib);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
+  cls.set_is_prefinalized();
+  pending_classes.Add(cls);

[siva, 2014/04/09 21:32:01]

Why do you have to initialize the UserTag class like this, wouldn't it get setup
when the profiler library is parsed?

[Cutch, 2014/04/09 22:27:20]

Done.

+
+
   // Setup some default native field classes which can be extended for
   // specifying native fields in dart classes.
   Library::InitNativeWrappersLibrary(isolate);
@@ -1439,6 +1466,9 @@ void Object::InitFromSnapshot(Isolate* isolate) {
 
   cls = Class::New<MirrorReference>();
   object_store->set_mirror_reference_class(cls);
+
+  cls = Class::New<UserTag>();
+  object_store->set_object_class(cls);
 }
 
 
@@ -9189,6 +9219,11 @@ RawLibrary* Library::TypedDataLibrary() {
 }
 
 
+RawLibrary* Library::ProfilerLibrary() {
+  return Isolate::Current()->object_store()->profiler_library();
+}
+
+
 const char* Library::ToCString() const {
   const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
@@ -18266,4 +18301,149 @@ void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
 }
 
 
+void UserTag::MakeActive() const {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  intptr_t user_tag = tag();
+  isolate->set_user_tag(static_cast<uword>(user_tag));
+  isolate->object_store()->set_current_tag(*this);

[siva, 2014/04/09 21:32:01]

should be isolate->set_current_tag();

[Cutch, 2014/04/09 22:27:20]

Done.

+}
+
+
+void UserTag::ClearActive() {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  isolate->set_user_tag(UserTags::kNoUserTag);
+  isolate->object_store()->clear_current_tag();
+}
+
+
+RawUserTag* UserTag::New(const String& label, Heap::Space space) {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->user_tag_class() != Class::null());
+  ASSERT(isolate->object_store()->tag_table() != GrowableObjectArray::null());
+  // Canonicalize by name.
+  UserTag& result = UserTag::Handle(FindTagInIsolate(isolate, label));
+  if (!result.IsNull()) {
+    // Tag already exists, return existing instance.
+    return result.raw();
+  }
+  // No tag with label exists, create and register with isolate tag table.
+  {
+    RawObject* raw = Object::Allocate(UserTag::kClassId,
+                                      UserTag::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_label(label);
+  intptr_t tag_id = FindAvailableTagId(isolate);
+  ASSERT(tag_id >= 0);
+  result.set_tag(tag_id);
+  AddTagToIsolate(isolate, result);
+  return result.raw();
+}
+
+
+RawUserTag* UserTag::FindTagInIsolate(Isolate* isolate, const String& label) {
+  ASSERT(isolate->object_store()->tag_table() != GrowableObjectArray::null());
+  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->tag_table());

[siva, 2014/04/09 21:32:01]

Why is the tag table in the object store and not in the isolate.

[Cutch, 2014/04/09 22:27:20]

Moved to isolate.

+  UserTag& other = UserTag::Handle(isolate);
+  String& tag_label = String::Handle(isolate);
+  for (intptr_t i = 0; i < tag_table.Length(); i++) {
+    other ^= tag_table.At(i);
+    ASSERT(!other.IsNull());
+    tag_label ^= other.label();
+    ASSERT(!tag_label.IsNull());
+    if (tag_label.Equals(label)) {
+      return other.raw();
+    }
+  }
+  return UserTag::null();
+}
+
+
+void UserTag::AddTagToIsolate(Isolate* isolate, const UserTag& tag) {
+  ASSERT(isolate->object_store()->tag_table() != GrowableObjectArray::null());
+  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->tag_table());
+#if defined(DEBUG)
+  // Verify that no existing tag has the same tag id.
+  UserTag& other = UserTag::Handle(isolate);
+  for (intptr_t i = 0; i < tag_table.Length(); i++) {
+    other ^= tag_table.At(i);
+    ASSERT(!other.IsNull());
+    ASSERT(tag.tag() != other.tag());
+  }
+#endif

[siva, 2014/04/09 21:32:01]

We should asert here that TagTableIsFull(isolate) is false.

[Cutch, 2014/04/09 22:27:20]

Done.

+  tag_table.Add(tag);
+}
+
+
+bool UserTag::TagTableIsFull(Isolate* isolate) {
+  ASSERT(isolate->object_store()->tag_table() != GrowableObjectArray::null());
+  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->tag_table());
+  ASSERT(tag_table.Length() <= UserTags::kMaxUserTags);
+  return tag_table.Length() == UserTags::kMaxUserTags;
+}
+
+
+RawUserTag* UserTag::FindTagById(uword tag_id) {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate->object_store()->tag_table() != GrowableObjectArray::null());
+  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->tag_table());
+  UserTag& tag = UserTag::Handle(isolate);
+  for (intptr_t i = 0; i < tag_table.Length(); i++) {
+    tag ^= tag_table.At(i);
+    if (tag.tag() == tag_id) {
+      return tag.raw();
+    }
+  }

[siva, 2014/04/09 21:32:01]

If tag ids go sequentially this would just be an index into the growable array
right there would not be a need to iterate and match the tag id.

[Cutch, 2014/04/09 22:27:20]

Done.

+  return UserTag::null();
+}
+
+
+intptr_t UserTag::FindAvailableTagId(Isolate* isolate) {
+  ASSERT(!TagTableIsFull(isolate));
+  ASSERT(isolate->object_store()->tag_table() != GrowableObjectArray::null());
+  const GrowableObjectArray& tag_table = GrowableObjectArray::Handle(
+      isolate, isolate->object_store()->tag_table());
+  // Use a bit-vector to collect used tag ids.
+  BitVector* bv = new BitVector(UserTags::kMaxUserTags);
+  UserTag& other = UserTag::Handle(isolate);
+  for (intptr_t i = 0; i < tag_table.Length(); i++) {
+    other ^= tag_table.At(i);
+    ASSERT(!other.IsNull());
+    ASSERT(other.tag() >= UserTags::kUserTagIdOffset);
+    ASSERT(other.tag() <
+           (UserTags::kUserTagIdOffset + UserTags::kMaxUserTags));
+    // Mark tag as used.
+    bv->Add(other.tag() - UserTags::kUserTagIdOffset);
+  }
+  // Find first available id.
+  for (intptr_t i = 0; i < bv->length(); i++) {
+    if (!bv->Contains(i)) {
+      return i + UserTags::kUserTagIdOffset;
+    }
+  }

[siva, 2014/04/09 21:32:01]

As discussed offline, since you don't provide a means to remove a tag we could
just go with a scheme to increment the tag ids and grad the next one instead of
this bit vector scheme of finding the next available tag.

I think the ability to delete tags is probably not going to be needed.

[Cutch, 2014/04/09 22:27:20]

Done.

+  // We should always be able to find an available tag id.
+  UNREACHABLE();
+  return -1;
+}
+
+
+const char* UserTag::ToCString() const {
+  const String& tag_label = String::Handle(label());
+  return tag_label.ToCString();
+}
+
+
+void UserTag::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  Instance::PrintToJSONStream(stream, ref);
+}
+
+
 }  // namespace dart