Introduce read buffer for external strings when using charAt (ia32).

src/objects.cc

 // 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 942 matching lines @@
   Heap* heap = GetHeap();
   int size = this->Size();  // Byte size of the original string.
   if (size < ExternalString::kSize) {
     // The string is too small to fit an external String in its place. This can
     // only happen for zero length strings.
     return false;
   }
   ASSERT(size >= ExternalString::kSize);
   bool is_ascii = this->IsAsciiRepresentation();
   bool is_symbol = this->IsSymbol();
-  int length = this->length();
-  int hash_field = this->hash_field();
 
-  // Morph the object to an external string by adjusting the map and
-  // reinitializing the fields.
-  this->set_map(is_ascii ?
-                heap->external_string_with_ascii_data_map() :
-                heap->external_string_map());
-  ExternalTwoByteString* self = ExternalTwoByteString::cast(this);
-  self->set_length(length);
-  self->set_hash_field(hash_field);
-  self->set_resource(resource);
-  // Additionally make the object into an external symbol if the original string
-  // was a symbol to start with.
-  if (is_symbol) {
-    self->Hash();  // Force regeneration of the hash value.
-    // Now morph this external string into a external symbol.
-    this->set_map(is_ascii ?
-                  heap->external_symbol_with_ascii_data_map() :
-                  heap->external_symbol_map());
+  ExternalTwoByteString* externalized;
+
+  if (this->length() >= ExternalString::kMinBufferedStringLength &&
+      size < ExternalString::kExtendedSize) {
+    ASSERT(this->IsConsString() || this->IsSlicedString());
+    // Cannot morph in place since size is too small.
+    externalized = ExternalTwoByteString::cast(
+        *(heap->isolate()->factory()->NewExternalStringFromTwoByte(resource)));
+    this->set_map(heap->sliced_string_map());
+    SlicedString* self = SlicedString::cast(this);
+    self->set_parent(externalized);
+    self->set_offset(0);
+  } else {
+    // Morph the string to an external string in place.
+    if (this->length() < ExternalString::kMinBufferedStringLength) {
+      this->set_map(
+          is_ascii ? (is_symbol ? heap->external_symbol_with_ascii_data_map()
+                                : heap->external_string_with_ascii_data_map())
+                   : (is_symbol ? heap->external_symbol_map()
+                                : heap->external_string_map()));
+    } else {
+      this->set_map(
+          is_ascii
+              ? (is_symbol
+                     ? heap->external_buffered_symbol_with_ascii_data_map()
+                     : heap->external_buffered_string_with_ascii_data_map())
+              : (is_symbol ? heap->external_buffered_symbol_map()
+                           : heap->external_buffered_string_map()));
+    }
+    externalized = ExternalTwoByteString::cast(this);
+    externalized->set_resource(resource);
+    if (is_symbol) externalized->Hash();  // Force rehashing.
+    if (externalized->IsBuffered()) {
+      externalized->set_buffer_index(ExternalString::kInvalidBufferIndex);
+    }
   }
 
   // Fill the remainder of the string with dead wood.
   int new_size = this->Size();  // Byte size of the external String object.
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
   if (Marking::IsBlack(Marking::MarkBitFrom(this))) {
     MemoryChunk::IncrementLiveBytes(this->address(), new_size - size);
   }
   return true;
 }
@@ skipping 13 matching lines @@
 #endif  // DEBUG
   Heap* heap = GetHeap();
   int size = this->Size();  // Byte size of the original string.
   if (size < ExternalString::kSize) {
     // The string is too small to fit an external String in its place. This can
     // only happen for zero length strings.
     return false;
   }
   ASSERT(size >= ExternalString::kSize);
   bool is_symbol = this->IsSymbol();
-  int length = this->length();
-  int hash_field = this->hash_field();
 
-  // Morph the object to an external string by adjusting the map and
-  // reinitializing the fields.
-  this->set_map(heap->external_ascii_string_map());
-  ExternalAsciiString* self = ExternalAsciiString::cast(this);
-  self->set_length(length);
-  self->set_hash_field(hash_field);
-  self->set_resource(resource);
-  // Additionally make the object into an external symbol if the original string
-  // was a symbol to start with.
-  if (is_symbol) {
-    self->Hash();  // Force regeneration of the hash value.
-    // Now morph this external string into a external symbol.
-    this->set_map(heap->external_ascii_symbol_map());
+  ExternalAsciiString* externalized;
+
+  if (this->length() >= ExternalString::kMinBufferedStringLength &&
+      size < ExternalString::kExtendedSize) {
+    ASSERT(this->IsConsString() || this->IsSlicedString());
+    // Cannot morph in place since size is too small.
+    externalized = ExternalAsciiString::cast(
+        *(heap->isolate()->factory()->NewExternalStringFromAscii(resource)));
+    this->set_map(heap->sliced_ascii_string_map());
+    SlicedString* self = SlicedString::cast(this);
+    self->set_parent(externalized);
+    self->set_offset(0);
+  } else {
+    // Morph the string to an external string in place.
+    if (this->length() < ExternalString::kMinBufferedStringLength) {
+      this->set_map(is_symbol ? heap->external_ascii_symbol_map()
+                              : heap->external_ascii_string_map());
+    } else {
+      this->set_map(is_symbol ? heap->external_buffered_ascii_symbol_map()
+                              : heap->external_buffered_ascii_string_map());
+    }
+    externalized = ExternalAsciiString::cast(this);
+    externalized->set_resource(resource);
+    if (is_symbol) externalized->Hash();  // Force rehashing.
+    if (externalized->IsBuffered()) {
+      externalized->set_buffer_index(ExternalString::kInvalidBufferIndex);
+    }
   }
 
   // Fill the remainder of the string with dead wood.
   int new_size = this->Size();  // Byte size of the external String object.
   heap->CreateFillerObjectAt(this->address() + new_size, size - new_size);
   if (Marking::IsBlack(Marking::MarkBitFrom(this))) {
     MemoryChunk::IncrementLiveBytes(this->address(), new_size - size);
   }
 
   return true;
@@ skipping 4983 matching lines @@
           rbb,
           &offset,
           max_chars > rbb->capacity ? rbb->capacity : max_chars);
       *offset_ptr = offset + offset_correction;
       return rbb->util_buffer;
     }
   }
 }
 
 
-uint16_t ExternalAsciiString::ExternalAsciiStringGet(int index) {
+uint16_t ExternalAsciiString::ExternalAsciiStringGet(
+    int index, ExternalStringBufferFlag flag) {
   ASSERT(index >= 0 && index < length());
-  return resource()->data()[index];
+  const char* source = resource()->data();
+  if (flag == UPDATE_EXTERNAL_STRING_BUFFER && IsBuffered()) {
+    int buffer_start = Max(0, index - kBackwardBufferedChars);
+    int buffer_end = Min(length(), index + kForwardBufferedChars);
+    int size = (buffer_end - buffer_start) * kASCIISize;
+    set_buffer_index(buffer_start);
+    memcpy(buffer(), source + buffer_start, size);
+  }
+  return *(source + index);
 }
 
 
 const unibrow::byte* ExternalAsciiString::ExternalAsciiStringReadBlock(
       unsigned* remaining,
       unsigned* offset_ptr,
       unsigned max_chars) {
   // Cast const char* to unibrow::byte* (signedness difference).
   const unibrow::byte* b =
       reinterpret_cast<const unibrow::byte*>(resource()->data()) + *offset_ptr;
   *remaining = max_chars;
   *offset_ptr += max_chars;
   return b;
 }
 
 
 const uc16* ExternalTwoByteString::ExternalTwoByteStringGetData(
       unsigned start) {
   return resource()->data() + start;
 }
 
 
-uint16_t ExternalTwoByteString::ExternalTwoByteStringGet(int index) {
+uint16_t ExternalTwoByteString::ExternalTwoByteStringGet(
+    int index, ExternalStringBufferFlag flag) {
   ASSERT(index >= 0 && index < length());
-  return resource()->data()[index];
+  const uint16_t* source = resource()->data();
+  if (flag == UPDATE_EXTERNAL_STRING_BUFFER && IsBuffered()) {
+    int buffer_start = Max(0, index - kBackwardBufferedChars);
+    int buffer_end = Min(length(), index + kForwardBufferedChars);
+    int size = (buffer_end - buffer_start) * kUC16Size;
+    set_buffer_index(buffer_start);
+    memcpy(buffer(), source + buffer_start, size);
+  }
+  return *(source + index);
 }
 
 
 void ExternalTwoByteString::ExternalTwoByteStringReadBlockIntoBuffer(
       ReadBlockBuffer* rbb,
       unsigned* offset_ptr,
       unsigned max_chars) {
   unsigned chars_read = 0;
   unsigned offset = *offset_ptr;
   const uint16_t* data = resource()->data();
@@ skipping 410 matching lines @@
         offset_correction += left_length;
         String::ReadBlockIntoBuffer(right, rbb, &offset, max_chars);
       }
       *offset_ptr = offset + offset_correction;
       return;
     }
   }
 }
 
 
-uint16_t ConsString::ConsStringGet(int index) {
+uint16_t ConsString::ConsStringGet(
+    int index, ExternalStringBufferFlag flag) {
   ASSERT(index >= 0 && index < this->length());
 
   // Check for a flattened cons string
   if (second()->length() == 0) {
     String* left = first();
-    return left->Get(index);
+    return left->Get(index, flag);
   }
 
   String* string = String::cast(this);
 
   while (true) {
     if (StringShape(string).IsCons()) {
       ConsString* cons_string = ConsString::cast(string);
       String* left = cons_string->first();
       if (left->length() > index) {
         string = left;
       } else {
         index -= left->length();
         string = cons_string->second();
       }
     } else {
-      return string->Get(index);
+      return string->Get(index, flag);
     }
   }
 
   UNREACHABLE();
   return 0;
 }
 
 
-uint16_t SlicedString::SlicedStringGet(int index) {
-  return parent()->Get(offset() + index);
+uint16_t SlicedString::SlicedStringGet(
+    int index, ExternalStringBufferFlag flag) {
+  return parent()->Get(offset() + index, flag);
 }
 
 
 const unibrow::byte* SlicedString::SlicedStringReadBlock(
     ReadBlockBuffer* buffer, unsigned* offset_ptr, unsigned chars) {
   unsigned offset = this->offset();
   *offset_ptr += offset;
   const unibrow::byte* answer = String::ReadBlock(String::cast(parent()),
                                                   buffer, offset_ptr, chars);
   *offset_ptr -= offset;
@@ skipping 6000 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 } }  // namespace v8::internal