Make block writes in the serializer more efficient.

src/serialize.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 1568 matching lines @@
 
 void Serializer::ObjectSerializer::SerializeExternalString() {
   // Instead of serializing this as an external string, we serialize
   // an imaginary sequential string with the same content.
   Isolate* isolate = serializer_->isolate();
   DCHECK(object_->IsExternalString());
   DCHECK(object_->map() != isolate->heap()->native_source_string_map());
   ExternalString* string = ExternalString::cast(object_);
   int length = string->length();
   Map* map;
-  int size;
-  const char* resource;
+  int content_size;
+  int allocation_size;
+  const byte* resource;
   // Find the map and size for the imaginary sequential string.
   bool internalized = object_->IsInternalizedString();
   if (object_->IsExternalOneByteString()) {
     map = internalized ? isolate->heap()->one_byte_internalized_string_map()
                        : isolate->heap()->one_byte_string_map();
-    size = SeqOneByteString::SizeFor(length);
-    resource = ExternalOneByteString::cast(string)->resource()->data();
+    allocation_size = SeqOneByteString::SizeFor(length);
+    content_size = length * kCharSize;
+    resource = reinterpret_cast<const byte*>(
+        ExternalOneByteString::cast(string)->resource()->data());
   } else {
     map = internalized ? isolate->heap()->internalized_string_map()
                        : isolate->heap()->string_map();
-    size = SeqTwoByteString::SizeFor(length);
-    resource = reinterpret_cast<const char*>(
+    allocation_size = SeqTwoByteString::SizeFor(length);
+    content_size = length * kShortSize;
+    resource = reinterpret_cast<const byte*>(
         ExternalTwoByteString::cast(string)->resource()->data());
   }
 
-  AllocationSpace space =
-      (size > Page::kMaxRegularHeapObjectSize) ? LO_SPACE : OLD_DATA_SPACE;
-  SerializePrologue(space, size, map);
+  AllocationSpace space = (allocation_size > Page::kMaxRegularHeapObjectSize)
+                              ? LO_SPACE
+                              : OLD_DATA_SPACE;
+  SerializePrologue(space, allocation_size, map);
 
   // Output the rest of the imaginary string.
-  int bytes_to_output = size - HeapObject::kHeaderSize;
+  int bytes_to_output = allocation_size - HeapObject::kHeaderSize;
 
   // Output raw data header. Do not bother with common raw length cases here.
   sink_->Put(kRawData, "RawDataForString");
   sink_->PutInt(bytes_to_output, "length");
 
   // Serialize string header (except for map).
   Address string_start = string->address();
   for (int i = HeapObject::kHeaderSize; i < SeqString::kHeaderSize; i++) {
     sink_->PutSection(string_start[i], "StringHeader");
   }
 
   // Serialize string content.
-  int content_length = size - SeqString::kHeaderSize;
-  for (int i = 0; i < content_length; i++) {
-    sink_->PutSection(resource[i], "StringContent");
-  }
+  sink_->PutRaw(const_cast<byte*>(resource), content_size, "StringContent");
+
+  // Since the allocation size is rounded up to object alignment, there
+  // maybe left-over bytes that need to be padded.
+  int padding_size = allocation_size - SeqString::kHeaderSize - content_size;
+  DCHECK(0 <= padding_size && padding_size < kObjectAlignment);
+  for (int i = 0; i < padding_size; i++) sink_->PutSection(0, "StringPadding");

[vogelheim, 2014/10/23 16:48:44]

If I get this correctly, this makes sure that you can use PutRaw (rather than
many 1-byte PutSection) but maintain correct padding. An alternative might be to
add SnapshotByteSink::PutRawPadded, which hides this and returns the actual
number of bytes written. Then you could just call PutRawPadded, and DCHECK
whether the return value matches bytes_to_output.

As usual... you decide. :)

[Yang, 2014/10/24 07:14:24]

This is a single use case, so I'd leave it at this.

 
   sink_->Put(kSkip, "SkipAfterString");
   sink_->PutInt(bytes_to_output, "SkipDistance");
 }
 
 
 void Serializer::ObjectSerializer::Serialize() {
   if (object_->IsExternalString()) {
     Heap* heap = serializer_->isolate()->heap();
     if (object_->map() != heap->native_source_string_map()) {
@@ skipping 226 matching lines @@
     if (code_object_) {
       Code* code = CloneCodeObject(object_);
       WipeOutRelocations(code);
       // We need to wipe out the header fields *after* wiping out the
       // relocations, because some of these fields are needed for the latter.
       code->WipeOutHeader();
       object_start = code->address();
     }
 
     const char* description = code_object_ ? "Code" : "Byte";
-    for (int i = 0; i < bytes_to_output; i++) {
-      sink_->PutSection(object_start[base + i], description);
-    }
+    sink_->PutRaw(object_start + base, bytes_to_output, description);
     if (code_object_) delete[] object_start;
   }
   if (to_skip != 0 && return_skip == kIgnoringReturn) {
     sink_->Put(kSkip, "Skip");
     sink_->PutInt(to_skip, "SkipDistance");
     to_skip = 0;
   }
   return to_skip;
 }
 
@@ skipping 419 matching lines @@
 
 int SerializedCodeData::CheckSum(String* string) {
   int checksum = Version::Hash();
 #ifdef DEBUG
   uint32_t seed = static_cast<uint32_t>(checksum);
   checksum = static_cast<int>(IteratingStringHasher::Hash(string, seed));
 #endif  // DEBUG
   return checksum;
 }
 } }  // namespace v8::internal