Speed up snapshots of *int8lists, by using memmove.

runtime/vm/raw_object_snapshot.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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 2274 matching lines @@
   writer->WriteIndexedObject(kFloat64x2Cid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out the float values.
   writer->Write<double>(ptr()->value_[0]);
   writer->Write<double>(ptr()->value_[1]);
 }
 
 
 #define TYPED_DATA_READ(setter, type)                                          \
-  for (intptr_t i = 0; i < lengthInBytes; i += element_size) {                 \
+  for (intptr_t i = 0; i < length_in_bytes; i += element_size) {               \
     result.Set##setter(i, reader->Read<type>());                               \
   }                                                                            \
 
 
 RawTypedData* TypedData::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   intptr_t cid = RawObject::ClassIdTag::decode(tags);
   intptr_t len = reader->ReadSmiValue();
   TypedData& result = TypedData::ZoneHandle(
       reader->isolate(), TypedData::New(cid, len, HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the array elements.
   intptr_t element_size = ElementSizeInBytes(cid);
-  intptr_t lengthInBytes = len * element_size;
+  intptr_t length_in_bytes = len * element_size;
   switch (cid) {
     case kTypedDataInt8ArrayCid:
-      TYPED_DATA_READ(Int8, int8_t);
+    case kTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid: {
+      uint8_t* data = reinterpret_cast<uint8_t*>(result.DataAddr(0));
+      reader->ReadBytes(data, length_in_bytes);
       break;
-    case kTypedDataUint8ArrayCid:
-      TYPED_DATA_READ(Uint8, uint8_t);
-      break;
-    case kTypedDataUint8ClampedArrayCid:
-      TYPED_DATA_READ(Uint8, uint8_t);
-      break;
+    }
     case kTypedDataInt16ArrayCid:
       TYPED_DATA_READ(Int16, int16_t);
       break;
     case kTypedDataUint16ArrayCid:
       TYPED_DATA_READ(Uint16, uint16_t);
       break;
     case kTypedDataInt32ArrayCid:
       TYPED_DATA_READ(Int32, int32_t);
       break;
     case kTypedDataUint32ArrayCid:
       TYPED_DATA_READ(Uint32, uint32_t);
       break;
     case kTypedDataInt64ArrayCid:
       TYPED_DATA_READ(Int64, int64_t);
       break;
     case kTypedDataUint64ArrayCid:
       TYPED_DATA_READ(Uint64, uint64_t);
       break;
     case kTypedDataFloat32ArrayCid:

[Ivan Posva, 2014/04/03 05:41:02]

You should consider doing the same for Float32 and Float64 at least. They don't
compress very well using the current compression algorithm, which has been tuned
for small integer values.

       TYPED_DATA_READ(Float32, float);
       break;
     case kTypedDataFloat64ArrayCid:
       TYPED_DATA_READ(Float64, double);
       break;
     default:
       UNREACHABLE();
   }
   return result.raw();
 }
@@ skipping 42 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(cid);
   writer->WriteIntptrValue(tags);
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the array elements.
   switch (cid) {
     case kTypedDataInt8ArrayCid:
-      TYPED_DATA_WRITE(int8_t);
+    case kTypedDataUint8ArrayCid:
+    case kTypedDataUint8ClampedArrayCid: {
+      uint8_t* data = reinterpret_cast<uint8_t*>(ptr()->data_);
+      writer->WriteBytes(data, len);
       break;
-    case kTypedDataUint8ArrayCid:
-      TYPED_DATA_WRITE(uint8_t);
-      break;
-    case kTypedDataUint8ClampedArrayCid:
-      TYPED_DATA_WRITE(uint8_t);
-      break;
+    }
     case kTypedDataInt16ArrayCid:
       TYPED_DATA_WRITE(int16_t);
       break;
     case kTypedDataUint16ArrayCid:
       TYPED_DATA_WRITE(uint16_t);
       break;
     case kTypedDataInt32ArrayCid:
       TYPED_DATA_WRITE(int32_t);
       break;
     case kTypedDataUint32ArrayCid:
@@ skipping 252 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a MirrorReference)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart