Implement in-heap backing store for typed arrays.

src/heap.cc

 // 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 2804 matching lines @@
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_external_unsigned_int_array_map(Map::cast(obj));
 
   { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_FLOAT_ARRAY_TYPE,
                                          ExternalArray::kAlignedSize);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_external_float_array_map(Map::cast(obj));
 
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_UINT8_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;

[Toon Verwaest, 2013/12/23 10:40:32]

Can we already change all these ToObject to To, only declare maybe_obj once; and
remove all the { ... }? And probably make "obj" instead Map* map; so that we
don't need to Map::cast obj. Hence:

Map* map;
MaybeObject* maybe_map;

...
maybe_map = AllocateMap(FIXED_INT8_ARRAY_TYPE, kVariableSizeSentinel);
if (!maybe_map->To(&map)) return false;
set_fixed_int8_array_map(map);
...

I think all this syntactical noise is getting more and more ridiculous.

[Dmitry Lomov (no reviews), 2014/01/07 15:48:43]

Done (+ more boilerplate scratching)
On 2013/12/23 10:40:32, Toon Verwaest wrote:

+  }
+  set_fixed_uint8_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_INT8_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_int8_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_UINT16_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_uint16_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_INT16_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_int16_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_UINT32_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_uint32_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_INT32_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_int32_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_FLOAT32_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_float32_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_FLOAT64_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_float64_array_map(Map::cast(obj));
+
+  { MaybeObject* maybe_obj = AllocateMap(FIXED_UINT8_CLAMPED_ARRAY_TYPE,
+                                         kVariableSizeSentinel);
+    if (!maybe_obj->ToObject(&obj)) return false;
+  }
+  set_fixed_uint8_clamped_array_map(Map::cast(obj));
+
   { MaybeObject* maybe_obj =
         AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
   set_non_strict_arguments_elements_map(Map::cast(obj));
 
   { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_DOUBLE_ARRAY_TYPE,
                                          ExternalArray::kAlignedSize);
     if (!maybe_obj->ToObject(&obj)) return false;
   }
@@ skipping 847 matching lines @@
     case kExternalDoubleArray:
       return kExternalDoubleArrayMapRootIndex;
     case kExternalPixelArray:
       return kExternalPixelArrayMapRootIndex;
     default:
       UNREACHABLE();
       return kUndefinedValueRootIndex;
   }
 }
 
+
+Map* Heap::MapForFixedTypedArray(ExternalArrayType array_type) {
+  return Map::cast(roots_[RootIndexForFixedTypedArray(array_type)]);
+}
+
+
+Heap::RootListIndex Heap::RootIndexForFixedTypedArray(
+    ExternalArrayType array_type) {
+  switch (array_type) {
+    case kExternalByteArray:
+      return kFixedInt8ArrayMapRootIndex;
+    case kExternalUnsignedByteArray:
+      return kFixedUint8ArrayMapRootIndex;
+    case kExternalShortArray:
+      return kFixedInt16ArrayMapRootIndex;
+    case kExternalUnsignedShortArray:
+      return kFixedUint16ArrayMapRootIndex;
+    case kExternalIntArray:
+      return kFixedInt32ArrayMapRootIndex;
+    case kExternalUnsignedIntArray:
+      return kFixedUint32ArrayMapRootIndex;
+    case kExternalFloatArray:
+      return kFixedFloat32ArrayMapRootIndex;
+    case kExternalDoubleArray:
+      return kFixedFloat64ArrayMapRootIndex;
+    case kExternalPixelArray:
+      return kFixedUint8ClampedArrayMapRootIndex;
+    default:
+      UNREACHABLE();
+      return kUndefinedValueRootIndex;
+  }
+}
+
 Heap::RootListIndex Heap::RootIndexForEmptyExternalArray(
     ElementsKind elementsKind) {
   switch (elementsKind) {
     case EXTERNAL_BYTE_ELEMENTS:
       return kEmptyExternalByteArrayRootIndex;
     case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
       return kEmptyExternalUnsignedByteArrayRootIndex;
     case EXTERNAL_SHORT_ELEMENTS:
       return kEmptyExternalShortArrayRootIndex;
     case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
@@ skipping 501 matching lines @@
 
   reinterpret_cast<ExternalArray*>(result)->set_map_no_write_barrier(
       MapForExternalArrayType(array_type));
   reinterpret_cast<ExternalArray*>(result)->set_length(length);
   reinterpret_cast<ExternalArray*>(result)->set_external_pointer(
       external_pointer);
 
   return result;
 }
 
+static void ForFixedTypedArray(ExternalArrayType array_type,
+                               int* element_size,
+                               ElementsKind* element_kind) {
+  switch (array_type) {
+    case kExternalUnsignedByteArray:
+      *element_size = 1;
+      *element_kind = UINT8_ELEMENTS;
+      return;
+    case kExternalByteArray:
+      *element_size = 1;
+      *element_kind = INT8_ELEMENTS;
+      return;
+    case kExternalUnsignedShortArray:
+      *element_size = 2;
+      *element_kind = UINT16_ELEMENTS;
+      return;
+    case kExternalShortArray:
+      *element_size = 2;
+      *element_kind = INT16_ELEMENTS;
+      return;
+    case kExternalUnsignedIntArray:
+      *element_size = 4;
+      *element_kind = UINT32_ELEMENTS;
+      return;
+    case kExternalIntArray:
+      *element_size = 4;
+      *element_kind = INT32_ELEMENTS;
+      return;
+    case kExternalFloatArray:
+      *element_size = 4;
+      *element_kind = FLOAT32_ELEMENTS;
+      return;
+    case kExternalDoubleArray:
+      *element_size = 8;
+      *element_kind = FLOAT64_ELEMENTS;
+      return;
+    case kExternalPixelArray:
+      *element_size = 1;
+      *element_kind = UINT8_CLAMPED_ELEMENTS;
+      return;
+    default:
+      UNREACHABLE();
+  }
+}
+
+
+MaybeObject* Heap::AllocateFixedTypedArray(int length,
+                                           ExternalArrayType array_type,
+                                           PretenureFlag pretenure) {
+  int element_size = 1;  // Bogus.

[Toon Verwaest, 2013/12/23 10:40:32]

Doesn't it work to set element_size and elements_kind in the UNREACHABLE()
branch above, rather than initialize them here? Then you don't need those //
Bogus labels here and it's in sync with what most other code does.

[Dmitry Lomov (no reviews), 2014/01/07 15:48:43]

Done.

+  ElementsKind elements_kind = UINT8_ELEMENTS;  // Bogus.
+  ForFixedTypedArray(array_type, &element_size, &elements_kind);
+  int size = length * element_size + FixedTypedArrayBase::kDataOffset;
+  AllocationSpace space = SelectSpace(size, OLD_DATA_SPACE, pretenure);
+
+  HeapObject* object;
+  { MaybeObject* maybe_object = AllocateRaw(size, space, OLD_DATA_SPACE);

[Toon Verwaest, 2013/12/23 10:40:32]

Remove the { ... }.

[Dmitry Lomov (no reviews), 2014/01/07 15:48:43]

Done.

+    if (!maybe_object->To<HeapObject>(&object)) return maybe_object;

[Toon Verwaest, 2013/12/23 10:40:32]

Is the <HeapObject> really necessary? If not remove it. Otherwise, if it's
necessary cause the map isn't correct yet, can we directly cast to
FixedTypedArrayBase?

[Dmitry Lomov (no reviews), 2014/01/07 15:48:43]

No because FixedTypedArrayBase::cast checks map as well.

+  }
+  FixedTypedArrayBase* elements =
+      reinterpret_cast<FixedTypedArrayBase*>(object);
+  elements->set_map(MapForFixedTypedArray(array_type));
+  elements->set_length(length);
+  return elements;
+}
+
 
 MaybeObject* Heap::CreateCode(const CodeDesc& desc,
                               Code::Flags flags,
                               Handle<Object> self_reference,
                               bool immovable,
                               bool crankshafted,
                               int prologue_offset) {
   // Allocate ByteArray before the Code object, so that we do not risk
   // leaving uninitialized Code object (and breaking the heap).
   ByteArray* reloc_info;
@@ skipping 2757 matching lines @@
 }
 
 
 void Heap::EnsureWeakObjectToCodeTable() {
   if (!weak_object_to_code_table()->IsHashTable()) {
     set_weak_object_to_code_table(*isolate()->factory()->NewWeakHashTable(16));
   }
 }
 
 
+void Heap::FatalProcessOutOfMemory(const char* location, bool take_snapshot) {
+  v8::internal::V8::FatalProcessOutOfMemory(location, take_snapshot);
+}
+
 #ifdef DEBUG
 
 class PrintHandleVisitor: public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++)
       PrintF("  handle %p to %p\n",
              reinterpret_cast<void*>(p),
              reinterpret_cast<void*>(*p));
   }
@@ skipping 965 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   OS::MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   OS::MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal