Stress GC less by allocating exponentially growing string chunks in JSON.stringify.

src/json-stringifier.h

 // Copyright 2012 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 24 matching lines @@
 namespace v8 {
 namespace internal {
 
 class BasicJsonStringifier BASE_EMBEDDED {
  public:
   explicit BasicJsonStringifier(Isolate* isolate);
 
   MaybeObject* Stringify(Handle<Object> object);
 
  private:
-  static const int kPartLength = 8 * 1024;
+  static const int kInitialPartLength = 32;
+  static const int kMaxPartLength = 16 * 1024;
+  static const int kPartLengthGrowthFactor = 2;
   static const int kStackLimit = 8 * 1024;
 
   enum Result { UNCHANGED, SUCCESS, BAILOUT, CIRCULAR, STACK_OVERFLOW };
 
   template <bool is_ascii> void Extend();
 
   void ChangeEncoding();
 
   void ShrinkCurrentPart();
 
@@ skipping 67 matching lines @@
   Result SerializeObject(Handle<JSObject> object);
 
   void SerializeString(Handle<String> object);
 
   template <bool is_ascii, typename Char>
   INLINE(void SerializeString_(Vector<const Char> vector));
 
   INLINE(Result StackPush(Handle<Object> object));
   INLINE(void StackPop());
 
+  INLINE(Handle<String> accumulator()) {
+    return Handle<String>(String::cast(accumulator_store_->value()));
+  }
+
+  INLINE(void set_accumulator(Handle<String> string)) {
+    return accumulator_store_->set_value(*string);
+  }
+
   Isolate* isolate_;
-  Handle<String> accumulator_;
+  // We use a value wrapper for the string accumulator to keep the
+  // (indirect) handle to it in the outermost handle scope.
+  Handle<JSValue> accumulator_store_;
   Handle<String> current_part_;
   Handle<String> tojson_symbol_;
   Handle<JSArray> stack_;
   int current_index_;
+  int part_length_;
   bool is_ascii_;
 
   static const int kJsonQuotesCharactersPerEntry = 8;
   static const char* const JsonQuotes;
 };
 
 
 const char* const BasicJsonStringifier::JsonQuotes =
     "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
     "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 "
@@ skipping 24 matching lines @@
     "h\0      i\0      j\0      k\0      "
     "l\0      m\0      n\0      o\0      "
     "p\0      q\0      r\0      s\0      "
     "t\0      u\0      v\0      w\0      "
     "x\0      y\0      z\0      {\0      "
     "|\0      }\0      ~\0      \177\0      ";
 
 
 BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate)
     : isolate_(isolate), current_index_(0), is_ascii_(true) {
-  accumulator_ = isolate_->factory()->empty_string();
+  accumulator_store_ = Handle<JSValue>::cast(
+      isolate_->factory()->ToObject(isolate_->factory()->empty_string()));
+  part_length_ = kInitialPartLength;
   current_part_ =
-      isolate_->factory()->NewRawAsciiString(kPartLength);
+      isolate_->factory()->NewRawAsciiString(kInitialPartLength);
   tojson_symbol_ = isolate_->factory()->LookupAsciiSymbol("toJSON");
   stack_ = isolate_->factory()->NewJSArray(8);
 }
 
 
 MaybeObject* BasicJsonStringifier::Stringify(Handle<Object> object) {
   switch (Serialize(object)) {
     case SUCCESS:
       ShrinkCurrentPart();
-      return *isolate_->factory()->NewConsString(accumulator_, current_part_);
+      return *isolate_->factory()->NewConsString(accumulator(), current_part_);
     case UNCHANGED:
       return isolate_->heap()->undefined_value();
     case CIRCULAR:
       return isolate_->Throw(*isolate_->factory()->NewTypeError(
                  "circular_structure", HandleVector<Object>(NULL, 0)));
     case STACK_OVERFLOW:
       return isolate_->StackOverflow();
     default:
       return Smi::FromInt(0);
   }
 }
 
 
 template <bool is_ascii, typename Char>
 void BasicJsonStringifier::Append_(Char c) {
   if (is_ascii) {
     SeqAsciiString::cast(*current_part_)->SeqAsciiStringSet(
         current_index_++, c);
   } else {
     SeqTwoByteString::cast(*current_part_)->SeqTwoByteStringSet(
         current_index_++, c);
   }
-  if (current_index_ == kPartLength) Extend<is_ascii>();
+  if (current_index_ == part_length_) Extend<is_ascii>();
 }
 
 
 template <bool is_ascii, typename Char>
 void BasicJsonStringifier::AppendUnchecked_(Char c) {
   if (is_ascii) {
     SeqAsciiString::cast(*current_part_)->SeqAsciiStringSet(
         current_index_++, c);
   } else {
     SeqTwoByteString::cast(*current_part_)->SeqTwoByteStringSet(
         current_index_++, c);
   }
-  ASSERT(current_index_ < kPartLength);
+  ASSERT(current_index_ < part_length_);
 }
 
 
 template <bool is_ascii, typename Char>
 void BasicJsonStringifier::Append_(Char* chars) {
   for ( ; *chars != '\0'; chars++) Append_<is_ascii>(*chars);
 }
 
 
 template <bool is_ascii, typename Char>
@@ skipping 154 matching lines @@
   static const int kBufferSize = 100;
   char chars[kBufferSize];
   Vector<char> buffer(chars, kBufferSize);
   Append(DoubleToCString(number, buffer));
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeArray(
     Handle<JSArray> object) {
+  HandleScope handle_scope(isolate_);
   if (StackPush(object) == CIRCULAR) return CIRCULAR;
   int length = Smi::cast(object->length())->value();
   Append('[');
   switch (object->GetElementsKind()) {
     case FAST_SMI_ELEMENTS: {
       Handle<FixedArray> elements = Handle<FixedArray>(
           FixedArray::cast(object->elements()));
       for (int i = 0; i < length; i++) {
         if (i > 0) Append(',');
         SerializeSmi(Smi::cast(elements->get(i)));
@@ skipping 37 matching lines @@
           return result;
         }
       }
       break;
     }
     default:
       return BAILOUT;
   }
   Append(']');
   StackPop();
+  current_part_ = handle_scope.CloseAndEscape(current_part_);
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeObject(
     Handle<JSObject> object) {
+  HandleScope handle_scope(isolate_);
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
   if (object->IsJSGlobalProxy()) return BAILOUT;
   bool threw = false;
   Handle<FixedArray> contents =
       GetKeysInFixedArrayFor(object, LOCAL_ONLY, &threw);
   if (threw) return BAILOUT;
   Append('{');
   int length = contents->length();
   bool comma = false;
@@ skipping 16 matching lines @@
         property = GetProperty(object, key_handle);
       }
     }
     if (property.is_null()) return BAILOUT;
     Result result = SerializeDeferred(property, comma, key_handle);
     if (!comma && result == SUCCESS) comma = true;
     if (result >= BAILOUT) return result;
   }
   Append('}');
   StackPop();
+  current_part_ = handle_scope.CloseAndEscape(current_part_);
   return SUCCESS;
 }
 
 
 void BasicJsonStringifier::ShrinkCurrentPart() {
-  ASSERT(current_index_ < kPartLength);
+  ASSERT(current_index_ < part_length_);
   if (current_index_ == 0) {
     current_part_ = isolate_->factory()->empty_string();
     return;
   }
 
   int string_size, allocated_string_size;
   if (is_ascii_) {
-    allocated_string_size = SeqAsciiString::SizeFor(kPartLength);
+    allocated_string_size = SeqAsciiString::SizeFor(part_length_);
     string_size = SeqAsciiString::SizeFor(current_index_);
   } else {
-    allocated_string_size = SeqTwoByteString::SizeFor(kPartLength);
+    allocated_string_size = SeqTwoByteString::SizeFor(part_length_);
     string_size = SeqTwoByteString::SizeFor(current_index_);
   }
 
   int delta = allocated_string_size - string_size;
   current_part_->set_length(current_index_);
 
   // String sizes are pointer size aligned, so that we can use filler objects
   // that are a multiple of pointer size.
   Address end_of_string = current_part_->address() + string_size;
   isolate_->heap()->CreateFillerObjectAt(end_of_string, delta);
   if (Marking::IsBlack(Marking::MarkBitFrom(*current_part_))) {
     MemoryChunk::IncrementLiveBytesFromMutator(
         current_part_->address(), -delta);
   }
 }
 
 
 template <bool is_ascii>
 void BasicJsonStringifier::Extend() {
-  accumulator_ =
-      isolate_->factory()->NewConsString(accumulator_, current_part_);
+  set_accumulator(
+      isolate_->factory()->NewConsString(accumulator(), current_part_));
+  if (part_length_ <= kMaxPartLength / kPartLengthGrowthFactor) {
+    part_length_ *= kPartLengthGrowthFactor;
+  }
   if (is_ascii) {
     current_part_ =
-        isolate_->factory()->NewRawAsciiString(kPartLength);
+        isolate_->factory()->NewRawAsciiString(part_length_);
   } else {
     current_part_ =
-        isolate_->factory()->NewRawTwoByteString(kPartLength);
+        isolate_->factory()->NewRawTwoByteString(part_length_);
   }
   current_index_ = 0;
 }
 
 
 void BasicJsonStringifier::ChangeEncoding() {
   ShrinkCurrentPart();
-  accumulator_ = isolate_->factory()->NewConsString(accumulator_,
-                                                    current_part_);
+  set_accumulator(
+      isolate_->factory()->NewConsString(accumulator(), current_part_));
   current_part_ =
-      isolate_->factory()->NewRawTwoByteString(kPartLength);
+      isolate_->factory()->NewRawTwoByteString(part_length_);
   current_index_ = 0;
   is_ascii_ = false;
 }
 
 
 template <bool is_ascii, typename Char>
 void BasicJsonStringifier::SerializeString_(Vector<const Char> vector) {
   int length = vector.length();
-  if (current_index_ + (length << 3) < (kPartLength - 2)) {
+  if (current_index_ + (length << 3) < (part_length_ - 2)) {
     AppendUnchecked_<is_ascii, char>('"');
     for (int i = 0; i < length; i++) {
       Char c = vector[i];
       if ((c >= '#' && c <= '~' && c != '\\') ||
           (!is_ascii && ((c & 0xFF80) != 0))) {
         AppendUnchecked_<is_ascii, Char>(c);
       } else {
         AppendUnchecked_<is_ascii, char>(
             &JsonQuotes[c * kJsonQuotesCharactersPerEntry]);
       }
@@ skipping 30 matching lines @@
       SerializeString_<false, char>(flat.ToAsciiVector());
     } else {
       SerializeString_<false, uc16>(flat.ToUC16Vector());
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_