Atomic operations on Uint8ClampedArray

src/runtime/runtime-atomics.cc

 // Copyright 2015 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/base/macros.h"
 #include "src/base/platform/mutex.h"
 #include "src/conversions.h"
@@ skipping 406 matching lines @@
 inline Object* DoExchange(Isolate* isolate, void* buffer, size_t index,
                           Handle<Object> obj) {
   typedef typename FromObjectTraits<T>::atomic_type atomic_type;
   typedef typename FromObjectTraits<T>::convert_type convert_type;
   atomic_type value = ToAtomic<atomic_type>(FromObject<convert_type>(obj));
   atomic_type result =
       ExchangeSeqCst(static_cast<atomic_type*>(buffer) + index, value);
   return ToObject<T>(isolate, FromAtomic<T>(result));
 }
 
+
+// Uint8Clamped functions
+
+uint8_t ClampToUint8(int32_t value) {
+  if (value < 0) return 0;
+  if (value > 255) return 255;
+  return value;

[Jarin, 2015/06/22 07:04:03]

Hmm, I am really surprised this does not need any casting.

[binji, 2015/06/22 18:21:04]

I didn't notice it until you mentioned it. I checked, and it doesn't produce an
error or warning on clang/gcc with -Wall. Also:
http://en.cppreference.com/w/cpp/language/implicit_cast#Numeric_conversions

+}
+
+
+inline Object* DoCompareExchangeUint8Clamped(Isolate* isolate, void* buffer,
+                                             size_t index,
+                                             Handle<Object> oldobj,
+                                             Handle<Object> newobj) {
+  typedef int32_t convert_type;
+  typedef uint8_t atomic_type;
+  atomic_type oldval = ClampToUint8(FromObject<convert_type>(oldobj));
+  atomic_type newval = ClampToUint8(FromObject<convert_type>(newobj));
+  atomic_type result = CompareExchangeSeqCst(
+      static_cast<atomic_type*>(buffer) + index, oldval, newval);
+  return ToObject<uint8_t>(isolate, FromAtomic<uint8_t>(result));
+}
+
+
+inline Object* DoStoreUint8Clamped(Isolate* isolate, void* buffer, size_t index,
+                                   Handle<Object> obj) {
+  typedef int32_t convert_type;
+  typedef uint8_t atomic_type;
+  atomic_type value = ClampToUint8(FromObject<convert_type>(obj));
+  StoreSeqCst(static_cast<atomic_type*>(buffer) + index, value);
+  return *obj;
+}
+
+
+#define DO_UINT8_CLAMPED_OP(name, op)                                        \
+  inline Object* Do##name##Uint8Clamped(Isolate* isolate, void* buffer,      \
+                                        size_t index, Handle<Object> obj) {  \
+    typedef int32_t convert_type;                                            \
+    typedef uint8_t atomic_type;                                             \
+    atomic_type* p = static_cast<atomic_type*>(buffer) + index;              \
+    convert_type operand = FromObject<convert_type>(obj);                    \
+    atomic_type expected;                                                    \
+    atomic_type result;                                                      \
+    do {                                                                     \
+      expected = *p;                                                         \
+      result = ClampToUint8(static_cast<convert_type>(expected) op operand); \
+    } while (CompareExchangeSeqCst(p, expected, result) != expected);        \
+    return ToObject<uint8_t>(isolate, expected);                             \
+  }
+
+DO_UINT8_CLAMPED_OP(Add, +)
+DO_UINT8_CLAMPED_OP(Sub, -)
+DO_UINT8_CLAMPED_OP(And, &)
+DO_UINT8_CLAMPED_OP(Or, | )
+DO_UINT8_CLAMPED_OP(Xor, ^)
+
+#undef DO_UINT8_CLAMPED_OP
+
+
+inline Object* DoExchangeUint8Clamped(Isolate* isolate, void* buffer,
+                                      size_t index, Handle<Object> obj) {
+  typedef int32_t convert_type;
+  typedef uint8_t atomic_type;
+  atomic_type* p = static_cast<atomic_type*>(buffer) + index;
+  atomic_type result = ClampToUint8(FromObject<convert_type>(obj));
+  atomic_type expected;
+  do {
+    expected = *p;
+  } while (CompareExchangeSeqCst(p, expected, result) != expected);
+  return ToObject<uint8_t>(isolate, expected);
+}
+
+
 }  // anonymous namespace
 
 // Duplicated from objects.h
 // V has parameters (Type, type, TYPE, C type, element_size)
 #define INTEGER_TYPED_ARRAYS(V)          \
   V(Uint8, uint8, UINT8, uint8_t, 1)     \
   V(Int8, int8, INT8, int8_t, 1)         \
   V(Uint16, uint16, UINT16, uint16_t, 2) \
   V(Int16, int16, INT16, int16_t, 2)     \
   V(Uint32, uint32, UINT32, uint32_t, 4) \
-  V(Int32, int32, INT32, int32_t, 4)     \
-  V(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t, 1)
+  V(Int32, int32, INT32, int32_t, 4)
 
 
 RUNTIME_FUNCTION(Runtime_AtomicsCompareExchange) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 4);
   CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, sta, 0);
   CONVERT_SIZE_ARG_CHECKED(index, 1);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(oldobj, 2);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(newobj, 3);
   RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
   RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
 
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoCompareExchange<ctype>(isolate, buffer, index, oldobj, newobj);
 
-    TYPED_ARRAYS(TYPED_ARRAY_CASE)
+    INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalFloat32Array:
+      return DoCompareExchange<float>(isolate, buffer, index, oldobj, newobj);
+
+    case kExternalFloat64Array:
+      return DoCompareExchange<double>(isolate, buffer, index, oldobj, newobj);
+
+    case kExternalUint8ClampedArray:
+      return DoCompareExchangeUint8Clamped(isolate, buffer, index, oldobj,
+                                           newobj);
+
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_AtomicsLoad) {
@@ skipping 32 matching lines @@
   RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
   RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
 
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoStore<ctype>(isolate, buffer, index, value);
 
-    TYPED_ARRAYS(TYPED_ARRAY_CASE)
+    INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalFloat32Array:
+      return DoStore<float>(isolate, buffer, index, value);
+
+    case kExternalFloat64Array:
+      return DoStore<double>(isolate, buffer, index, value);
+
+    case kExternalUint8ClampedArray:
+      return DoStoreUint8Clamped(isolate, buffer, index, value);
+
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_AtomicsAdd) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 3);
   CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, sta, 0);
   CONVERT_SIZE_ARG_CHECKED(index, 1);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(value, 2);
   RUNTIME_ASSERT(sta->GetBuffer()->is_shared());
   RUNTIME_ASSERT(index < NumberToSize(isolate, sta->length()));
 
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoAdd<ctype>(isolate, buffer, index, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalUint8ClampedArray:
+      return DoAddUint8Clamped(isolate, buffer, index, value);
+
     case kExternalFloat32Array:
     case kExternalFloat64Array:
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
@@ skipping 10 matching lines @@
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoSub<ctype>(isolate, buffer, index, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalUint8ClampedArray:
+      return DoSubUint8Clamped(isolate, buffer, index, value);
+
     case kExternalFloat32Array:
     case kExternalFloat64Array:
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
@@ skipping 10 matching lines @@
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoAnd<ctype>(isolate, buffer, index, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalUint8ClampedArray:
+      return DoAndUint8Clamped(isolate, buffer, index, value);
+
     case kExternalFloat32Array:
     case kExternalFloat64Array:
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
@@ skipping 10 matching lines @@
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoOr<ctype>(isolate, buffer, index, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalUint8ClampedArray:
+      return DoOrUint8Clamped(isolate, buffer, index, value);
+
     case kExternalFloat32Array:
     case kExternalFloat64Array:
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
@@ skipping 10 matching lines @@
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoXor<ctype>(isolate, buffer, index, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalUint8ClampedArray:
+      return DoXorUint8Clamped(isolate, buffer, index, value);
+
     case kExternalFloat32Array:
     case kExternalFloat64Array:
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
@@ skipping 10 matching lines @@
   void* buffer = sta->GetBuffer()->backing_store();
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoExchange<ctype>(isolate, buffer, index, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
+    case kExternalUint8ClampedArray:
+      return DoExchangeUint8Clamped(isolate, buffer, index, value);
+
     case kExternalFloat32Array:
     case kExternalFloat64Array:
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(Runtime_AtomicsIsLockFree) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(size, 0);
   uint32_t usize = NumberToUint32(*size);
 
   return Runtime::AtomicIsLockFree(usize) ? isolate->heap()->true_value()
                                           : isolate->heap()->false_value();
 }
 }
 }  // namespace v8::internal