Improve performance of string buffer by modifying concatAll native to allow growable array and an i…

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 13279 matching lines @@
   intptr_t char_size = Utils::Maximum(str1.CharSize(), str2.CharSize());
   if (char_size == kTwoByteChar) {
     return TwoByteString::Concat(str1, str2, space);
   }
   return OneByteString::Concat(str1, str2, space);
 }
 
 
 RawString* String::ConcatAll(const Array& strings,
                              Heap::Space space) {
+  return ConcatAllRange(strings, 0, strings.Length(), space);
+}
+
+
+RawString* String::ConcatAllRange(const Array& strings,
+                                  intptr_t start,
+                                  intptr_t end,
+                                  Heap::Space space) {
   ASSERT(!strings.IsNull());
+  ASSERT(start >= 0);
+  ASSERT(end <= strings.Length());
   intptr_t result_len = 0;
-  intptr_t strings_len = strings.Length();
   String& str = String::Handle();
   intptr_t char_size = kOneByteChar;
-  for (intptr_t i = 0; i < strings_len; i++) {
+  // Compute 'char_size' and 'result_len'.
+  for (intptr_t i = start; i < end; i++) {
     str ^= strings.At(i);
-    intptr_t str_len = str.Length();
+    const intptr_t str_len = str.Length();
     if ((kMaxElements - result_len) < str_len) {
       Isolate* isolate = Isolate::Current();
       const Instance& exception =
           Instance::Handle(isolate->object_store()->out_of_memory());
       Exceptions::Throw(exception);
       UNREACHABLE();
     }
     result_len += str_len;
     char_size = Utils::Maximum(char_size, str.CharSize());
   }
   if (char_size == kOneByteChar) {
-    return OneByteString::ConcatAll(strings, result_len, space);
+    return OneByteString::ConcatAll(strings, start, end, result_len, space);
   }
   ASSERT(char_size == kTwoByteChar);
-  return TwoByteString::ConcatAll(strings, result_len, space);
+  return TwoByteString::ConcatAll(strings, start, end, result_len, space);
 }
 
 
 RawString* String::SubString(const String& str,
                              intptr_t begin_index,
                              Heap::Space space) {
   ASSERT(!str.IsNull());
   if (begin_index >= str.Length()) {
     return String::null();
   }
@@ skipping 470 matching lines @@
   intptr_t len2 = str2.Length();
   intptr_t len = len1 + len2;
   const String& result = String::Handle(OneByteString::New(len, space));
   String::Copy(result, 0, str1, 0, len1);
   String::Copy(result, len1, str2, 0, len2);
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::ConcatAll(const Array& strings,
+                                           intptr_t start,
+                                           intptr_t end,
                                            intptr_t len,
                                            Heap::Space space) {
+  ASSERT(!strings.IsNull());
+  ASSERT(start >= 0);
+  ASSERT(end <= strings.Length());
   const String& result = String::Handle(OneByteString::New(len, space));
   String& str = String::Handle();
-  intptr_t strings_len = strings.Length();
   intptr_t pos = 0;
-  for (intptr_t i = 0; i < strings_len; i++) {
+  for (intptr_t i = start; i < end; i++) {
     str ^= strings.At(i);
-    intptr_t str_len = str.Length();
+    const intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     ASSERT((kMaxElements - pos) >= str_len);
     pos += str_len;
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
@@ skipping 153 matching lines @@
   intptr_t len2 = str2.Length();
   intptr_t len = len1 + len2;
   const String& result = String::Handle(TwoByteString::New(len, space));
   String::Copy(result, 0, str1, 0, len1);
   String::Copy(result, len1, str2, 0, len2);
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::ConcatAll(const Array& strings,
+                                           intptr_t start,
+                                           intptr_t end,
                                            intptr_t len,
                                            Heap::Space space) {
+  ASSERT(!strings.IsNull());
+  ASSERT(start >= 0);
+  ASSERT(end <= strings.Length());
   const String& result = String::Handle(TwoByteString::New(len, space));
   String& str = String::Handle();
-  intptr_t strings_len = strings.Length();
   intptr_t pos = 0;
-  for (intptr_t i = 0; i < strings_len; i++) {
+  for (intptr_t i = start; i < end; i++) {
     str ^= strings.At(i);
-    intptr_t str_len = str.Length();
+    const intptr_t str_len = str.Length();
     String::Copy(result, pos, str, 0, str_len);
     ASSERT((kMaxElements - pos) >= str_len);
     pos += str_len;
   }
   return TwoByteString::raw(result);
 }
 
 
 RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
@@ skipping 1205 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart