Track live instance and allocation counts for classes

runtime/vm/object.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 "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 266 matching lines @@
   } else if (name.Length() != start_pos) {
     // Append the last segment.
     segment = String::SubString(name, start_pos, (name.Length() - start_pos));
     unmangled_name = String::Concat(unmangled_name, segment);
   }
 
   intptr_t len = unmangled_name.Length();
   intptr_t start = 0;
   intptr_t dot_pos = -1;  // Position of '.' in the name, if any.
   bool is_setter = false;
-
   for (intptr_t i = start; i < len; i++) {
     if (unmangled_name.CharAt(i) == ':') {
+      if (start != 0) {
+        // Reset and break.
+        start = 0;
+        dot_pos = -1;
+        break;
+      }
       ASSERT(start == 0);  // Only one : is possible in getters or setters.
       if (unmangled_name.CharAt(0) == 's') {
         is_setter = true;
       }
       start = i + 1;
     } else if (unmangled_name.CharAt(i) == '.') {
+      if (dot_pos != -1) {
+        // Reset and break.
+        start = 0;
+        dot_pos = -1;
+        break;
+      }
       ASSERT(dot_pos == -1);  // Only one dot is supported.
       dot_pos = i;
     }
   }
 
   if ((start == 0) && (dot_pos == -1)) {
     // This unmangled_name is fine as it is.
     return unmangled_name.raw();
   }
 
@@ skipping 1145 matching lines @@
 
   uword address = heap->Allocate(size, space);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
     const Instance& exception =
         Instance::Handle(isolate->object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
+  if (space == Heap::kNew) {
+    isolate->class_table()->UpdateAllocatedNew(cls_id, size);
+  } else {
+    isolate->class_table()->UpdateAllocatedOld(cls_id, size);
+  }
   NoGCScope no_gc;
   InitializeObject(address, cls_id, size);
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   ASSERT(cls_id == RawObject::ClassIdTag::decode(raw_obj->ptr()->tags_));
   return raw_obj;
 }
 
 
 class StoreBufferUpdateVisitor : public ObjectPointerVisitor {
  public:
@@ skipping 48 matching lines @@
 
 RawString* Class::Name() const {
   // TODO(turnidge): This assert fails for the fake kFreeListElement class.
   // Fix this.
   ASSERT(raw_ptr()->name_ != String::null());
   return raw_ptr()->name_;
 }
 
 
 RawString* Class::UserVisibleName() const {
-  if (FLAG_show_internal_names) {
-    return Name();
-  }
-  switch (id()) {
-    case kIntegerCid:
-    case kSmiCid:
-    case kMintCid:
-    case kBigintCid:
-      return Symbols::Int().raw();
-    case kDoubleCid:
-      return Symbols::Double().raw();
-    case kOneByteStringCid:
-    case kTwoByteStringCid:
-    case kExternalOneByteStringCid:
-    case kExternalTwoByteStringCid:
-      return Symbols::New("String");
-    case kArrayCid:
-    case kImmutableArrayCid:
-    case kGrowableObjectArrayCid:
-      return Symbols::List().raw();
-    case kFloat32x4Cid:
-      return Symbols::Float32x4().raw();
-    case kInt32x4Cid:
-      return Symbols::Int32x4().raw();
-    case kTypedDataInt8ArrayCid:
-    case kExternalTypedDataInt8ArrayCid:
-      return Symbols::Int8List().raw();
-    case kTypedDataUint8ArrayCid:
-    case kExternalTypedDataUint8ArrayCid:
-      return Symbols::Uint8List().raw();
-    case kTypedDataUint8ClampedArrayCid:
-    case kExternalTypedDataUint8ClampedArrayCid:
-      return Symbols::Uint8ClampedList().raw();
-    case kTypedDataInt16ArrayCid:
-    case kExternalTypedDataInt16ArrayCid:
-      return Symbols::Int16List().raw();
-    case kTypedDataUint16ArrayCid:
-    case kExternalTypedDataUint16ArrayCid:
-      return Symbols::Uint16List().raw();
-    case kTypedDataInt32ArrayCid:
-    case kExternalTypedDataInt32ArrayCid:
-      return Symbols::Int32List().raw();
-    case kTypedDataUint32ArrayCid:
-    case kExternalTypedDataUint32ArrayCid:
-      return Symbols::Uint32List().raw();
-    case kTypedDataInt64ArrayCid:
-    case kExternalTypedDataInt64ArrayCid:
-      return Symbols::Int64List().raw();
-    case kTypedDataUint64ArrayCid:
-    case kExternalTypedDataUint64ArrayCid:
-      return Symbols::Uint64List().raw();
-    case kTypedDataFloat32x4ArrayCid:
-    case kExternalTypedDataFloat32x4ArrayCid:
-      return Symbols::Float32x4List().raw();
-    case kTypedDataFloat32ArrayCid:
-    case kExternalTypedDataFloat32ArrayCid:
-      return Symbols::Float32List().raw();
-    case kTypedDataFloat64ArrayCid:
-    case kExternalTypedDataFloat64ArrayCid:
-      return Symbols::Float64List().raw();
-    default:
-      if (!IsCanonicalSignatureClass()) {
-        const String& name = String::Handle(Name());
-        return String::IdentifierPrettyName(name);
-      } else {
-        return Name();
-      }
-  }
-  UNREACHABLE();
+  ASSERT(raw_ptr()->user_name_ != String::null());
+  return raw_ptr()->user_name_;

[Ivan Posva, 2014/01/17 06:53:16]

Why is this allocated eagerly? Is there a reason why we do not lazily create and
cache this on first access?

[Cutch, 2014/01/17 18:37:59]

We write protect the VM isolate's heap.

 }
 
 
 RawType* Class::SignatureType() const {
   ASSERT(IsSignatureClass());
   const Function& function = Function::Handle(signature_function());
   ASSERT(!function.IsNull());
   if (function.signature_class() != raw()) {
     // This class is a function type alias. Return the canonical signature type.
     const Class& canonical_class = Class::Handle(function.signature_class());
@@ skipping 1163 matching lines @@
   result.set_instance_size(instance_size);
   result.set_next_field_offset(ExternalTypedData::NextFieldOffset());
   result.set_is_prefinalized();
   return result.raw();
 }
 
 
 void Class::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
+  if (raw_ptr()->user_name_ == String::null()) {
+    // Generate and set user_name.
+    const String& user_name = String::Handle(GenerateUserVisibleName());
+    set_user_name(user_name);
+  }
 }
 
 
+void Class::set_user_name(const String& value) const {
+  StorePointer(&raw_ptr()->user_name_, value.raw());
+}
+
+
+RawString* Class::GenerateUserVisibleName() const {
+  if (FLAG_show_internal_names) {
+    return Name();
+  }
+  switch (id()) {
+    case kNullCid:
+      return Symbols::Null().raw();
+    case kDynamicCid:
+      return Symbols::Dynamic().raw();
+    case kVoidCid:
+      return Symbols::Void().raw();
+    case kClassCid:
+      return Symbols::Class().raw();
+    case kUnresolvedClassCid:
+      return Symbols::UnresolvedClass().raw();
+    case kTypeArgumentsCid:
+      return Symbols::TypeArguments().raw();
+    case kInstantiatedTypeArgumentsCid:
+      return Symbols::InstantiatedTypeArguments().raw();
+    case kPatchClassCid:
+      return Symbols::PatchClass().raw();
+    case kFunctionCid:
+      return Symbols::Function().raw();
+    case kClosureDataCid:
+      return Symbols::ClosureData().raw();
+    case kRedirectionDataCid:
+      return Symbols::RedirectionData().raw();
+    case kFieldCid:
+      return Symbols::Field().raw();
+    case kLiteralTokenCid:
+      return Symbols::LiteralToken().raw();
+    case kTokenStreamCid:
+      return Symbols::TokenStream().raw();
+    case kScriptCid:
+      return Symbols::Script().raw();
+    case kLibraryCid:
+      return Symbols::Library().raw();
+    case kLibraryPrefixCid:
+      return Symbols::LibraryPrefix().raw();
+    case kNamespaceCid:
+      return Symbols::Namespace().raw();
+    case kCodeCid:
+      return Symbols::Code().raw();
+    case kInstructionsCid:
+      return Symbols::Instructions().raw();
+    case kPcDescriptorsCid:
+      return Symbols::PcDescriptors().raw();
+    case kStackmapCid:
+      return Symbols::Stackmap().raw();
+    case kLocalVarDescriptorsCid:
+      return Symbols::LocalVarDescriptors().raw();
+    case kExceptionHandlersCid:
+      return Symbols::ExceptionHandlers().raw();
+    case kDeoptInfoCid:
+      return Symbols::DeoptInfo().raw();
+    case kContextCid:
+      return Symbols::Context().raw();
+    case kContextScopeCid:
+      return Symbols::ContextScope().raw();
+    case kICDataCid:
+      return Symbols::ICData().raw();
+    case kMegamorphicCacheCid:
+      return Symbols::MegamorphicCache().raw();
+    case kSubtypeTestCacheCid:
+      return Symbols::SubtypeTestCache().raw();
+    case kApiErrorCid:
+      return Symbols::ApiError().raw();
+    case kLanguageErrorCid:
+      return Symbols::LanguageError().raw();
+    case kUnhandledExceptionCid:
+      return Symbols::UnhandledException().raw();
+    case kUnwindErrorCid:
+      return Symbols::UnwindError().raw();
+    case kIntegerCid:
+    case kSmiCid:
+    case kMintCid:
+    case kBigintCid:
+      return Symbols::Int().raw();
+    case kDoubleCid:
+      return Symbols::Double().raw();
+    case kOneByteStringCid:
+    case kTwoByteStringCid:
+    case kExternalOneByteStringCid:
+    case kExternalTwoByteStringCid:
+      return Symbols::StringSym().raw();
+    case kArrayCid:
+    case kImmutableArrayCid:
+    case kGrowableObjectArrayCid:
+      return Symbols::List().raw();
+    case kFloat32x4Cid:
+      return Symbols::Float32x4().raw();
+    case kInt32x4Cid:
+      return Symbols::Int32x4().raw();
+    case kTypedDataInt8ArrayCid:
+    case kExternalTypedDataInt8ArrayCid:
+      return Symbols::Int8List().raw();
+    case kTypedDataUint8ArrayCid:
+    case kExternalTypedDataUint8ArrayCid:
+      return Symbols::Uint8List().raw();
+    case kTypedDataUint8ClampedArrayCid:
+    case kExternalTypedDataUint8ClampedArrayCid:
+      return Symbols::Uint8ClampedList().raw();
+    case kTypedDataInt16ArrayCid:
+    case kExternalTypedDataInt16ArrayCid:
+      return Symbols::Int16List().raw();
+    case kTypedDataUint16ArrayCid:
+    case kExternalTypedDataUint16ArrayCid:
+      return Symbols::Uint16List().raw();
+    case kTypedDataInt32ArrayCid:
+    case kExternalTypedDataInt32ArrayCid:
+      return Symbols::Int32List().raw();
+    case kTypedDataUint32ArrayCid:
+    case kExternalTypedDataUint32ArrayCid:
+      return Symbols::Uint32List().raw();
+    case kTypedDataInt64ArrayCid:
+    case kExternalTypedDataInt64ArrayCid:
+      return Symbols::Int64List().raw();
+    case kTypedDataUint64ArrayCid:
+    case kExternalTypedDataUint64ArrayCid:
+      return Symbols::Uint64List().raw();
+    case kTypedDataFloat32x4ArrayCid:
+    case kExternalTypedDataFloat32x4ArrayCid:
+      return Symbols::Float32x4List().raw();
+    case kTypedDataFloat32ArrayCid:
+    case kExternalTypedDataFloat32ArrayCid:
+      return Symbols::Float32List().raw();
+    case kTypedDataFloat64ArrayCid:
+    case kExternalTypedDataFloat64ArrayCid:
+      return Symbols::Float64List().raw();
+    default:
+      if (!IsCanonicalSignatureClass()) {
+        const String& name = String::Handle(Name());
+        return String::IdentifierPrettyName(name);
+      } else {
+        return Name();
+      }
+  }
+  UNREACHABLE();
+}
+
+
 void Class::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
 void Class::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
 
@@ skipping 14180 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart