WIP SharedArrayBuffer implementation

src/runtime/runtime-typedarray.cc

 // Copyright 2014 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/arguments.h"
 #include "src/runtime/runtime.h"
 #include "src/runtime/runtime-utils.h"
 
 
 namespace v8 {
 namespace internal {
 
 void Runtime::FreeArrayBuffer(Isolate* isolate,
                               JSArrayBuffer* phantom_array_buffer) {
   if (phantom_array_buffer->should_be_freed()) {
     DCHECK(phantom_array_buffer->is_external());
     free(phantom_array_buffer->backing_store());
   }
   if (phantom_array_buffer->is_external()) return;
 
   size_t allocated_length =
       NumberToSize(isolate, phantom_array_buffer->byte_length());
 
   reinterpret_cast<v8::Isolate*>(isolate)
       ->AdjustAmountOfExternalAllocatedMemory(
           -static_cast<int64_t>(allocated_length));
-  CHECK(V8::ArrayBufferAllocator() != NULL);
-  V8::ArrayBufferAllocator()->Free(phantom_array_buffer->backing_store(),
-                                   allocated_length);
+  if (phantom_array_buffer->is_shared()) {
+    CHECK(V8::SharedArrayBufferAllocator() != NULL);
+    V8::SharedArrayBufferAllocator()->Free(
+        phantom_array_buffer->backing_store(), allocated_length);
+  } else {
+    CHECK(V8::ArrayBufferAllocator() != NULL);
+    V8::ArrayBufferAllocator()->Free(phantom_array_buffer->backing_store(),
+                                     allocated_length);
+  }
 }
 
 
 void Runtime::SetupArrayBuffer(Isolate* isolate,
                                Handle<JSArrayBuffer> array_buffer,
                                bool is_external, void* data,
                                size_t allocated_length) {
   DCHECK(array_buffer->GetInternalFieldCount() ==
          v8::ArrayBuffer::kInternalFieldCount);
   for (int i = 0; i < v8::ArrayBuffer::kInternalFieldCount; i++) {
@@ skipping 21 matching lines @@
         ->set_weak_next(*array_buffer);
     isolate->heap()->set_last_array_buffer_in_list(*array_buffer);
   }
 }
 
 
 bool Runtime::SetupArrayBufferAllocatingData(Isolate* isolate,
                                              Handle<JSArrayBuffer> array_buffer,
                                              size_t allocated_length,
                                              bool initialize) {
+  bool is_shared = array_buffer->is_shared();

[Jarin, 2015/04/29 04:46:01]

This should be array_buffer->is_shared() == SHARED. Or just make
JSArrayBuffer::is_shared return bool, the main motivation for the SharedFlag is
to make the sharing explicit when passed as a parameter.

(That said, I am a bit surprised that C++ is happy about using enum as bool.)

[binji, 2015/04/29 18:27:22]

Done.

   void* data;
-  CHECK(V8::ArrayBufferAllocator() != NULL);
+  CHECK(is_shared ? V8::SharedArrayBufferAllocator() != NULL
+                  : V8::ArrayBufferAllocator() != NULL);
   // Prevent creating array buffers when serializing.
   DCHECK(!isolate->serializer_enabled());
   if (allocated_length != 0) {
-    if (initialize) {
-      data = V8::ArrayBufferAllocator()->Allocate(allocated_length);
+    if (is_shared) {
+      if (initialize) {
+        data = V8::SharedArrayBufferAllocator()->Allocate(allocated_length);
+      } else {
+        data = V8::SharedArrayBufferAllocator()->AllocateUninitialized(
+            allocated_length);
+      }
     } else {
-      data =
-          V8::ArrayBufferAllocator()->AllocateUninitialized(allocated_length);
+      if (initialize) {
+        data = V8::ArrayBufferAllocator()->Allocate(allocated_length);
+      } else {
+        data =
+            V8::ArrayBufferAllocator()->AllocateUninitialized(allocated_length);
+      }
     }
     if (data == NULL) return false;
   } else {
     data = NULL;
   }
 
   SetupArrayBuffer(isolate, array_buffer, false, data, allocated_length);
 
   reinterpret_cast<v8::Isolate*>(isolate)
       ->AdjustAmountOfExternalAllocatedMemory(allocated_length);
@@ skipping 33 matching lines @@
 
 
 RUNTIME_FUNCTION(Runtime_ArrayBufferGetByteLength) {
   SealHandleScope shs(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_CHECKED(JSArrayBuffer, holder, 0);
   return holder->byte_length();
 }
 
 
+RUNTIME_FUNCTION(Runtime_ArrayBufferIsShared) {
+  SealHandleScope shs(isolate);
+  DCHECK(args.length() == 1);
+  CONVERT_ARG_CHECKED(JSArrayBuffer, holder, 0);
+  return isolate->heap()->ToBoolean(holder->is_shared());
+}
+
+
 RUNTIME_FUNCTION(Runtime_ArrayBufferSliceImpl) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 3);
   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, source, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, target, 1);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(first, 2);
   RUNTIME_ASSERT(!source.is_identical_to(target));
   size_t start = 0;
   RUNTIME_ASSERT(TryNumberToSize(isolate, *first, &start));
   size_t target_length = NumberToSize(isolate, target->byte_length());
@@ skipping 19 matching lines @@
 
 
 RUNTIME_FUNCTION(Runtime_ArrayBufferNeuter) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSArrayBuffer, array_buffer, 0);
   if (array_buffer->backing_store() == NULL) {
     CHECK(Smi::FromInt(0) == array_buffer->byte_length());
     return isolate->heap()->undefined_value();
   }
+  // Shared array buffers should never be neutered.
+  DCHECK(!array_buffer->is_shared());

[jochen (gone - plz use gerrit), 2015/04/28 18:31:46]

why? What about ArrayBuffer.transfer?

[Jarin, 2015/04/29 04:46:01]

The whole idea of SharedArrayBuffer is that it can be shared, i.e., not neutered
on transfer.

[binji, 2015/04/29 18:27:22]

I asked about this on the spec doc, but I think it doesn't make much sense to
add a SharedArrayBuffer.transfer. How would it work if the buffer's backing
store is already being shared across isolates? Either you'd need to have a
synchronization point to swap in the new backing store for all threads (in which
case you wouldn't neuter) or you'd have to neuter on one thread and eventually
share the new buffer with the other threads (which wouldn't help with memory
pressure).

AIUI, the only other case for neutering is transferring an ArrayBuffer to a
Worker, which is the method for sharing a SAB, and does not neuter.

   DCHECK(!array_buffer->is_external());
   void* backing_store = array_buffer->backing_store();
   size_t byte_length = NumberToSize(isolate, array_buffer->byte_length());
   array_buffer->set_is_external(true);
   Runtime::NeuterArrayBuffer(array_buffer);
   V8::ArrayBufferAllocator()->Free(backing_store, byte_length);
   return isolate->heap()->undefined_value();
 }
 
 
@@ skipping 250 matching lines @@
 
   if (!args[1]->IsJSTypedArray())
     return Smi::FromInt(TYPED_ARRAY_SET_NON_TYPED_ARRAY);
 
   CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, target_obj, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, source_obj, 1);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(offset_obj, 2);
 
   Handle<JSTypedArray> target(JSTypedArray::cast(*target_obj));
   Handle<JSTypedArray> source(JSTypedArray::cast(*source_obj));
+
+  if (target->is_shared() != source->is_shared()) {
+    THROW_NEW_ERROR_RETURN_FAILURE(
+        isolate,
+        NewTypeError("invalid_argument", HandleVector<Object>(NULL, 0)));
+  }
+
   size_t offset = 0;
   RUNTIME_ASSERT(TryNumberToSize(isolate, *offset_obj, &offset));
   size_t target_length = NumberToSize(isolate, target->length());
   size_t source_length = NumberToSize(isolate, source->length());
   size_t target_byte_length = NumberToSize(isolate, target->byte_length());
   size_t source_byte_length = NumberToSize(isolate, source->byte_length());
   if (offset > target_length || offset + source_length > target_length ||
       offset + source_length < offset) {  // overflow
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewRangeError("typed_array_set_source_too_large",
@@ skipping 294 matching lines @@
 DATA_VIEW_SETTER(Uint16, uint16_t)
 DATA_VIEW_SETTER(Int16, int16_t)
 DATA_VIEW_SETTER(Uint32, uint32_t)
 DATA_VIEW_SETTER(Int32, int32_t)
 DATA_VIEW_SETTER(Float32, float)
 DATA_VIEW_SETTER(Float64, double)
 
 #undef DATA_VIEW_SETTER
 }
 }  // namespace v8::internal