Reimplement Symbols using hash table template.

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 6790 matching lines @@
 }
 
 
 void RedirectionData::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 RawString* Field::GetterName(const String& field_name) {
   CompilerStats::make_accessor_name++;
+  // TODO(koda): Avoid most of these allocations by adding prefix-based lookup
+  // to Symbols.
   return String::Concat(Symbols::GetterPrefix(), field_name);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   const String& str = String::Handle(Field::GetterName(field_name));
   return Symbols::New(str);
 }
 
 
 RawString* Field::SetterName(const String& field_name) {
   CompilerStats::make_accessor_name++;
+  // TODO(koda): Avoid most of these allocations by adding prefix-based lookup
+  // to Symbols.
   return String::Concat(Symbols::SetterPrefix(), field_name);
 }
 
 
 RawString* Field::SetterSymbol(const String& field_name) {
   const String& str = String::Handle(Field::SetterName(field_name));
   return Symbols::New(str);
 }
 
 
@@ skipping 816 matching lines @@
     return descriptor.literal->Hash();
   }
 
   static uword Hash(const Object& key) {
     if (key.IsLiteralToken()) {
       return String::HashRawSymbol(LiteralToken::Cast(key).literal());
     } else {
       return String::Cast(key).Hash();
     }
   }
+
+  static RawObject* NewKey(const Scanner::TokenDescriptor& descriptor) {
+    return LiteralToken::New(descriptor.kind, *descriptor.literal);
+  }
 };
 typedef UnorderedHashMap<CompressedTokenTraits> CompressedTokenMap;
 
 
 // Helper class for creation of compressed token stream data.
 class CompressedTokenStreamData : public ValueObject {
  public:
   static const intptr_t kInitialBufferSize = 16 * KB;
   CompressedTokenStreamData() :
       buffer_(NULL),
       stream_(&buffer_, Reallocate, kInitialBufferSize),
       tokens_(Array::Handle(
           HashTables::New<CompressedTokenMap>(kInitialTableSize))) {
   }
   ~CompressedTokenStreamData() {
     // Safe to discard the hash table now.
     tokens_.Release();
   }
 
   // Add an IDENT token into the stream and the token hash map.
   void AddIdentToken(const String* ident) {
     ASSERT(ident->IsSymbol());
-    intptr_t index = tokens_.NumOccupied();
-    intptr_t entry;
-    if (!tokens_.FindKeyOrDeletedOrUnused(*ident, &entry)) {
-      tokens_.InsertKey(entry, *ident);
-      tokens_.UpdatePayload(entry, 0, Smi::Handle(Smi::New(index)));
-      HashTables::EnsureLoadFactor(0.0, kMaxLoadFactor, tokens_);
-    } else {
-      index = Smi::Value(Smi::RawCast(tokens_.GetPayload(entry, 0)));
-    }
+    const intptr_t fresh_index = tokens_.NumOccupied();
+    intptr_t index = Smi::Value(Smi::RawCast(
+        tokens_.InsertOrGetValue(*ident,
+                                 Smi::Handle(Smi::New(fresh_index)))));
     WriteIndex(index);
   }
 
   // Add a LITERAL token into the stream and the token hash map.
   void AddLiteralToken(const Scanner::TokenDescriptor& descriptor) {
     ASSERT(descriptor.literal->IsSymbol());
-    intptr_t index = tokens_.NumOccupied();
-    intptr_t entry;
-    if (!tokens_.FindKeyOrDeletedOrUnused(descriptor, &entry)) {
-      LiteralToken& new_literal = LiteralToken::Handle(
-          LiteralToken::New(descriptor.kind, *descriptor.literal));
-      tokens_.InsertKey(entry, new_literal);
-      tokens_.UpdatePayload(entry, 0, Smi::Handle(Smi::New(index)));
-      HashTables::EnsureLoadFactor(0.0, kMaxLoadFactor, tokens_);
-    } else {
-      index = Smi::Value(Smi::RawCast(tokens_.GetPayload(entry, 0)));
-    }
+    const intptr_t fresh_index = tokens_.NumOccupied();
+    intptr_t index = Smi::Value(Smi::RawCast(
+        tokens_.InsertNewOrGetValue(descriptor,
+                                    Smi::Handle(Smi::New(fresh_index)))));
     WriteIndex(index);
   }
 
   // Add a simple token into the stream.
   void AddSimpleToken(intptr_t kind) {
     stream_.WriteUnsigned(kind);
   }
 
   // Return the compressed token stream.
   uint8_t* GetStream() const { return buffer_; }
@@ skipping 21 matching lines @@
   }
 
   static uint8_t* Reallocate(uint8_t* ptr,
                              intptr_t old_size,
                              intptr_t new_size) {
     void* new_ptr = ::realloc(reinterpret_cast<void*>(ptr), new_size);
     return reinterpret_cast<uint8_t*>(new_ptr);
   }
 
   static const intptr_t kInitialTableSize = 32;
-  static const double kMaxLoadFactor;
 
   uint8_t* buffer_;
   WriteStream stream_;
   CompressedTokenMap tokens_;
 
   DISALLOW_COPY_AND_ASSIGN(CompressedTokenStreamData);
 };
 
 
-const double CompressedTokenStreamData::kMaxLoadFactor = 0.75;
-
-
 RawTokenStream* TokenStream::New(const Scanner::GrowableTokenStream& tokens,
                                  const String& private_key) {
   // Copy the relevant data out of the scanner into a compressed stream of
   // tokens.
   CompressedTokenStreamData data;
   intptr_t len = tokens.length();
   for (intptr_t i = 0; i < len; i++) {
     Scanner::TokenDescriptor token = tokens[i];
     if (token.kind == Token::kIDENT) {  // Identifier token.
       if (FLAG_compiler_stats) {
@@ skipping 11394 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart