AstValueFactory: add a cache for one-character strings.

src/ast/ast-value-factory.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 204 matching lines @@
       break;
     case UNDEFINED:
       set_value(isolate->factory()->undefined_value());
       break;
   }
 }
 
 
 AstRawString* AstValueFactory::GetOneByteStringInternal(
     Vector<const uint8_t> literal) {
+  if (literal.length() == 1 && literal[0] >= 'a' && literal[0] <= 'z') {

[Toon Verwaest, 2016/12/05 15:30:40]

IsInRange(literal[0], 'a', 'z') is faster ;)

[marja, 2016/12/08 15:09:59]

Done.

+    int key = literal[0] - 'a';
+    if (one_character_strings_[key] == nullptr) {
+      uint32_t hash = StringHasher::HashSequentialString<uint8_t>(

[Toon Verwaest, 2016/12/05 15:30:40]

We could just have a-z heapstrings preallocated in a similar table and just
manually fill in without internalization lookup in the symbol table. Or in a
follow-up CL :)

[marja, 2016/12/08 15:09:59]

Hmm yeah, sounds like a good idea to keep the CLs separate. (I'd also like to
see the potential perf gain from this CL alone.)

+          literal.start(), literal.length(), hash_seed_);
+      one_character_strings_[key] = GetString(hash, true, literal);
+    }
+    return one_character_strings_[key];
+  }
   uint32_t hash = StringHasher::HashSequentialString<uint8_t>(
       literal.start(), literal.length(), hash_seed_);
   return GetString(hash, true, literal);
 }
 
 
 AstRawString* AstValueFactory::GetTwoByteStringInternal(
     Vector<const uint16_t> literal) {
   uint32_t hash = StringHasher::HashSequentialString<uint16_t>(
       literal.start(), literal.length(), hash_seed_);
@@ skipping 185 matching lines @@
                                   length) == 0;
     } else {
       return CompareCharsUnsigned(reinterpret_cast<const uint16_t*>(l),
                                   reinterpret_cast<const uint16_t*>(r),
                                   length) == 0;
     }
   }
 }
 }  // namespace internal
 }  // namespace v8