WIP SharedArrayBuffer implementation

src/objects.h

 // 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.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 
 #include "src/allocation.h"
@@ skipping 426 matching lines @@
   V(JS_CONTEXT_EXTENSION_OBJECT_TYPE)                           \
   V(JS_GENERATOR_OBJECT_TYPE)                                   \
   V(JS_MODULE_TYPE)                                             \
   V(JS_GLOBAL_OBJECT_TYPE)                                      \
   V(JS_BUILTINS_OBJECT_TYPE)                                    \
   V(JS_GLOBAL_PROXY_TYPE)                                       \
   V(JS_ARRAY_TYPE)                                              \
   V(JS_ARRAY_BUFFER_TYPE)                                       \
   V(JS_TYPED_ARRAY_TYPE)                                        \
   V(JS_DATA_VIEW_TYPE)                                          \
+  V(JS_SHARED_ARRAY_BUFFER_TYPE)                                \
+  V(JS_SHARED_TYPED_ARRAY_TYPE)                                 \
   V(JS_PROXY_TYPE)                                              \
   V(JS_SET_TYPE)                                                \
   V(JS_MAP_TYPE)                                                \
   V(JS_SET_ITERATOR_TYPE)                                       \
   V(JS_MAP_ITERATOR_TYPE)                                       \
   V(JS_WEAK_MAP_TYPE)                                           \
   V(JS_WEAK_SET_TYPE)                                           \
   V(JS_REGEXP_TYPE)                                             \
                                                                 \
   V(JS_FUNCTION_TYPE)                                           \
@@ skipping 281 matching lines @@
   JS_CONTEXT_EXTENSION_OBJECT_TYPE,
   JS_GENERATOR_OBJECT_TYPE,
   JS_MODULE_TYPE,
   JS_GLOBAL_OBJECT_TYPE,
   JS_BUILTINS_OBJECT_TYPE,
   JS_GLOBAL_PROXY_TYPE,
   JS_ARRAY_TYPE,
   JS_ARRAY_BUFFER_TYPE,
   JS_TYPED_ARRAY_TYPE,
   JS_DATA_VIEW_TYPE,
+  JS_SHARED_ARRAY_BUFFER_TYPE,
+  JS_SHARED_TYPED_ARRAY_TYPE,
   JS_SET_TYPE,
   JS_MAP_TYPE,
   JS_SET_ITERATOR_TYPE,
   JS_MAP_ITERATOR_TYPE,
   JS_WEAK_MAP_TYPE,
   JS_WEAK_SET_TYPE,
   JS_REGEXP_TYPE,
   JS_FUNCTION_TYPE,  // LAST_JS_OBJECT_TYPE, LAST_JS_RECEIVER_TYPE
 
   // Pseudo-types
@@ skipping 9460 matching lines @@
 
   inline bool is_external();
   inline void set_is_external(bool value);
 
   inline bool should_be_freed();
   inline void set_should_be_freed(bool value);
 
   inline bool is_neuterable();
   inline void set_is_neuterable(bool value);
 
+  inline bool is_shared();
+  inline void set_is_shared(bool value);
+
   // [weak_next]: linked list of array buffers.
   DECL_ACCESSORS(weak_next, Object)
 
   // [weak_first_array]: weak linked list of views.
   DECL_ACCESSORS(weak_first_view, Object)
 
   DECLARE_CAST(JSArrayBuffer)
 
   // Neutering. Only neuters the buffer, not associated typed arrays.
   void Neuter();
@@ skipping 10 matching lines @@
   static const int kSize = kWeakFirstViewOffset + kPointerSize;
 
   static const int kSizeWithInternalFields =
       kSize + v8::ArrayBuffer::kInternalFieldCount * kPointerSize;
 
  private:
   // Bit position in a flag
   static const int kIsExternalBit = 0;
   static const int kShouldBeFreed = 1;
   static const int kIsNeuterableBit = 2;
+  static const int kIsSharedBit = 3;

[Jarin, 2015/04/16 14:55:28]

Why do you need the bit? Cannot you get the sharedness from the map?

[binji, 2015/04/16 21:00:34]

Do you mean from the ExternalArrayType? I currently share that enumeration value
between TypedArrays and SharedTypedArrays. I could add new shared types, but I'm
not sure how much code would need to be duplicated then. Also, I think that will
only work for TypedArrays, not for the SharedArrayBuffer.

Or am I missing something? (quite likely :)

[Jarin, 2015/04/17 07:49:27]

I was just wondering why you could not define is_shared()
{ return map()->instance_type() == JS_SHARED_ARRAY_BUFFER_TYPE; }

[binji, 2015/04/17 09:06:44]

Thanks, that works. I knew I was missing something. :)

 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
 };
 
 
 class JSArrayBufferView: public JSObject {
  public:
   // [buffer]: ArrayBuffer that this typed array views.
   DECL_ACCESSORS(buffer, Object)
 
@@ skipping 22 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBufferView);
 };
 
 
 class JSTypedArray: public JSArrayBufferView {
  public:
   // [length]: length of typed array in elements.
   DECL_ACCESSORS(length, Object)
 
+  // TODO(binji): How to make this a flags array and access it via hydrogen?
+  // See hydrogen.cc:HOptimizedGraphBuilder::GenerateTypedArrayInitialize
+  // [is_shared]
+  DECL_BOOLEAN_ACCESSORS(is_shared)
+
   // Neutering. Only neuters this typed array.
   void Neuter();
 
   DECLARE_CAST(JSTypedArray)
 
   ExternalArrayType type();
   size_t element_size();
 
   Handle<JSArrayBuffer> GetBuffer();
 
   // Dispatched behavior.
   DECLARE_PRINTER(JSTypedArray)
   DECLARE_VERIFIER(JSTypedArray)
 
   static const int kLengthOffset = kViewSize + kPointerSize;
-  static const int kSize = kLengthOffset + kPointerSize;
+  static const int kIsSharedOffset = kLengthOffset + kPointerSize;

[Jarin, 2015/04/16 14:55:28]

Again, why do you need the shared flag? Don't you have it on the map already?

[binji, 2015/04/16 21:00:34]

see above

+  static const int kSize = kIsSharedOffset + kPointerSize;
 
   static const int kSizeWithInternalFields =
       kSize + v8::ArrayBufferView::kInternalFieldCount * kPointerSize;
 
  private:
   static Handle<JSArrayBuffer> MaterializeArrayBuffer(
       Handle<JSTypedArray> typed_array);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSTypedArray);
 };
@@ skipping 747 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_