Pretenure JSON graph if the input string is larger than 100*1024 chars.

src/json-parser.h

 // Copyright 2011 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 143 matching lines @@
   inline Zone* zone() const { return zone_; }
 
   static const int kInitialSpecialStringLength = 1024;
 
 
  private:
   Handle<String> source_;
   int source_length_;
   Handle<SeqAsciiString> seq_source_;
 
+  PretenureFlag tenure_;

[Michael Starzinger, 2012/10/22 16:44:28]

Let's call that "pretenure_" to be in line with the rest of the code-base.

[Toon Verwaest, 2012/10/23 08:05:57]

Done.

   Isolate* isolate_;
   Factory* factory_;
   Handle<JSFunction> object_constructor_;
   uc32 c0_;
   int position_;
   Zone* zone_;
 };
 
 template <bool seq_ascii>
 Handle<Object> JsonParser<seq_ascii>::ParseJson(Handle<String> source,
                                                 Zone* zone) {
   isolate_ = source->map()->GetHeap()->isolate();
   factory_ = isolate_->factory();
   object_constructor_ =
       Handle<JSFunction>(isolate()->native_context()->object_function());
   zone_ = zone;
   FlattenString(source);
   source_ = source;
   source_length_ = source_->length();
+  static const int kJsonAllocatePretenured = 100 * 1024;

[Michael Starzinger, 2012/10/22 16:44:28]

Can we move this constant out into the JsonParser class. And I would rename it
to kPretenureThreshold or something like that.

[Toon Verwaest, 2012/10/23 08:05:57]

Done.

+  tenure_ = (source_length_ >= kJsonAllocatePretenured) ? TENURED : NOT_TENURED;
 
   // Optimized fast case where we only have ASCII characters.
   if (seq_ascii) {
     seq_source_ = Handle<SeqAsciiString>::cast(source_);
   }
 
   // Set initial position right before the string.
   position_ = -1;
   // Advance to the first character (possibly EOS)
   AdvanceSkipWhitespace();
@@ skipping 81 matching lines @@
   }
   return ReportUnexpectedCharacter();
 }
 
 
 // Parse a JSON object. Position must be right at '{'.
 template <bool seq_ascii>
 Handle<Object> JsonParser<seq_ascii>::ParseJsonObject() {
   Handle<Object> prototype;
   Handle<JSObject> json_object =
-      factory()->NewJSObject(object_constructor());
+      factory()->NewJSObject(object_constructor(), tenure_);
   ASSERT_EQ(c0_, '{');
 
   AdvanceSkipWhitespace();
   if (c0_ != '}') {
     do {
       if (c0_ != '"') return ReportUnexpectedCharacter();
 
       int start_position = position_;
       Advance();
 
@@ skipping 63 matching lines @@
       if (element.is_null()) return ReportUnexpectedCharacter();
       elements.Add(element, zone());
     } while (MatchSkipWhiteSpace(','));
     if (c0_ != ']') {
       return ReportUnexpectedCharacter();
     }
   }
   AdvanceSkipWhitespace();
   // Allocate a fixed array with all the elements.
   Handle<FixedArray> fast_elements =
-      factory()->NewFixedArray(elements.length());
+      factory()->NewFixedArray(elements.length(), tenure_);
   for (int i = 0, n = elements.length(); i < n; i++) {
     fast_elements->set(i, *elements[i]);
   }
-  return factory()->NewJSArrayWithElements(fast_elements);
+  return factory()->NewJSArrayWithElements(
+      fast_elements, FAST_ELEMENTS, tenure_);
 }
 
 
 template <bool seq_ascii>
 Handle<Object> JsonParser<seq_ascii>::ParseJsonNumber() {
   bool negative = false;
   int beg_pos = position_;
   if (c0_ == '-') {
     Advance();
     negative = true;
@@ skipping 46 matching lines @@
     Vector<const char> result =
         Vector<const char>(reinterpret_cast<const char*>(buffer.start()),
         length);
     number = StringToDouble(isolate()->unicode_cache(),
                              result,
                              NO_FLAGS,  // Hex, octal or trailing junk.
                              0.0);
     buffer.Dispose();
   }
   SkipWhitespace();
-  return factory()->NewNumber(number);
+  return factory()->NewNumber(number, tenure_);
 }
 
 
 template <typename StringType>
 inline void SeqStringSet(Handle<StringType> seq_str, int i, uc32 c);
 
 template <>
 inline void SeqStringSet(Handle<SeqTwoByteString> seq_str, int i, uc32 c) {
   seq_str->SeqTwoByteStringSet(i, c);
 }
 
 template <>
 inline void SeqStringSet(Handle<SeqAsciiString> seq_str, int i, uc32 c) {
   seq_str->SeqAsciiStringSet(i, c);
 }
 
 template <typename StringType>
-inline Handle<StringType> NewRawString(Factory* factory, int length);
+inline Handle<StringType> NewRawString(Factory* factory,
+                                       int length,
+                                       PretenureFlag tenure);

[Michael Starzinger, 2012/10/22 16:44:28]

Call the third argument "pretenure".

[Toon Verwaest, 2012/10/23 08:05:57]

Done.

 
 template <>
-inline Handle<SeqTwoByteString> NewRawString(Factory* factory, int length) {
-  return factory->NewRawTwoByteString(length, NOT_TENURED);
+inline Handle<SeqTwoByteString> NewRawString(Factory* factory,
+                                             int length,
+                                             PretenureFlag tenure) {

[Michael Starzinger, 2012/10/22 16:44:28]

Likewise.

[Toon Verwaest, 2012/10/23 08:05:57]

Done.

+  return factory->NewRawTwoByteString(length, tenure);
 }
 
 template <>
-inline Handle<SeqAsciiString> NewRawString(Factory* factory, int length) {
-  return factory->NewRawAsciiString(length, NOT_TENURED);
+inline Handle<SeqAsciiString> NewRawString(Factory* factory,
+                                           int length,
+                                           PretenureFlag tenure) {

[Michael Starzinger, 2012/10/22 16:44:28]

Likewise.

[Toon Verwaest, 2012/10/23 08:05:57]

Done.

+  return factory->NewRawAsciiString(length, tenure);
 }
 
 
 // Scans the rest of a JSON string starting from position_ and writes
 // prefix[start..end] along with the scanned characters into a
 // sequential string of type StringType.
 template <bool seq_ascii>
 template <typename StringType, typename SinkChar>
 Handle<String> JsonParser<seq_ascii>::SlowScanJsonString(
     Handle<String> prefix, int start, int end) {
   int count = end - start;
   int max_length = count + source_length_ - position_;
   int length = Min(max_length, Max(kInitialSpecialStringLength, 2 * count));
-  Handle<StringType> seq_str = NewRawString<StringType>(factory(), length);
+  Handle<StringType> seq_str =
+      NewRawString<StringType>(factory(), length, tenure_);
   // Copy prefix into seq_str.
   SinkChar* dest = seq_str->GetChars();
   String::WriteToFlat(*prefix, dest, start, end);
 
   while (c0_ != '"') {
     // Check for control character (0x00-0x1f) or unterminated string (<0).
     if (c0_ < 0x20) return Handle<String>::null();
     if (count >= length) {
       // We need to create a longer sequential string for the result.
       return SlowScanJsonString<StringType, SinkChar>(seq_str, 0, count);
@@ skipping 158 matching lines @@
     } else {
       return SlowScanJsonString<SeqAsciiString, char>(source_,
                                                       beg_pos,
                                                       position_);
     }
   } while (c0_ != '"');
   int length = position_ - beg_pos;
   Handle<String> result;
   if (seq_ascii && is_symbol) {
     result = factory()->LookupAsciiSymbol(seq_source_,
-                                                     beg_pos,
-                                                     length);
+                                          beg_pos,

[Michael Starzinger, 2012/10/22 16:44:28]

Indentation seems off.

[Toon Verwaest, 2012/10/23 08:05:57]

Seems fine here.

On 2012/10/22 16:44:28, Michael Starzinger wrote:

+                                          length);
   } else {
-    result = factory()->NewRawAsciiString(length);
+    result = factory()->NewRawAsciiString(length, tenure_);
     char* dest = SeqAsciiString::cast(*result)->GetChars();
     String::WriteToFlat(*source_, dest, beg_pos, position_);
   }
   ASSERT_EQ('"', c0_);
   // Advance past the last '"'.
   AdvanceSkipWhitespace();
   return result;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_PARSER_H_