buffer: optimize Buffer.copy

This removes some of the overhead by extending the V8 api.

PR-URL: #62491

Author: ronag

deps/v8/include/v8-array-buffer.h

@@ -456,6 +456,17 @@ class V8_EXPORT ArrayBufferView : public Object {
    */
   bool HasBuffer() const;
 
+  /**
+   * Copies |count| bytes from |source| starting at |source_start| into
+   * |target| starting at |target_start| using memmove semantics. Unlike
+   * CopyContents, this method handles both source and destination, supports
+   * byte offsets, and requires no HandleScope. Behaviour is undefined
+   * if either view is detached or if the range exceeds the view bounds.
+   */
+  static void FastCopy(const ArrayBufferView* source, size_t source_start,
+                       ArrayBufferView* target, size_t target_start,
+                       size_t count);
+
   V8_INLINE static ArrayBufferView* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);

deps/v8/src/api/api.cc

@@ -9044,6 +9044,39 @@ size_t v8::ArrayBufferView::CopyContents(void* dest, size_t byte_length) {
   return bytes_to_copy;
 }
 
+// static
+void v8::ArrayBufferView::FastCopy(const ArrayBufferView* source,
+                                    size_t source_start,
+                                    ArrayBufferView* target,
+                                    size_t target_start, size_t count) {
+  i::DisallowGarbageCollection no_gc;
+  auto src = Utils::OpenDirectHandle(source);
+  auto dst = Utils::OpenDirectHandle(target);
+
+  if (V8_UNLIKELY(src->IsDetachedOrOutOfBounds() ||
+                  dst->IsDetachedOrOutOfBounds())) {
+    return;
+  }
+
+  char* src_data;
+  if (i::IsJSTypedArray(*src)) {
+    src_data = reinterpret_cast<char*>(i::Cast<i::JSTypedArray>(*src)->DataPtr());
+  } else {
+    src_data = reinterpret_cast<char*>(
+        i::Cast<i::JSDataViewOrRabGsabDataView>(*src)->data_pointer());
+  }
+
+  char* dst_data;
+  if (i::IsJSTypedArray(*dst)) {
+    dst_data = reinterpret_cast<char*>(i::Cast<i::JSTypedArray>(*dst)->DataPtr());
+  } else {
+    dst_data = reinterpret_cast<char*>(
+        i::Cast<i::JSDataViewOrRabGsabDataView>(*dst)->data_pointer());
+  }
+
+  memmove(dst_data + target_start, src_data + source_start, count);
+}
+
 v8::MemorySpan<uint8_t> v8::ArrayBufferView::GetContents(
     v8::MemorySpan<uint8_t> storage) {
   internal::DisallowGarbageCollection no_gc;

doc/api/buffer.md

@@ -1767,9 +1767,15 @@ added: v0.1.90
 Copies data from a region of `buf` to a region in `target`, even if the `target`
 memory region overlaps with `buf`.
 
-[`TypedArray.prototype.set()`][] performs the same operation, and is available
-for all TypedArrays, including Node.js `Buffer`s, although it takes
-different function arguments.
+[`TypedArray.prototype.set()`][] performs a similar operation and is available
+for all TypedArrays, including Node.js `Buffer`s, although it takes different
+function arguments. It differs from `buf.copy()` in two ways:
+
+1. If either buffer is detached, it throws a `TypeError` instead of performing
+   a no-op.
+2. If either buffer is backed by a [`SharedArrayBuffer`][], it performs a
+   slower copy based on a stricter memory model.
+
 
 ```mjs
 import { Buffer } from 'node:buffer';

lib/buffer.js

@@ -267,7 +267,7 @@ function copyImpl(source, target, targetStart, sourceStart, sourceEnd) {
   return _copyActual(source, target, targetStart, sourceStart, sourceEnd);
 }
 
-function _copyActual(source, target, targetStart, sourceStart, sourceEnd, isUint8Copy = false) {
+function _copyActual(source, target, targetStart, sourceStart, sourceEnd) {
   if (sourceEnd - sourceStart > target.byteLength - targetStart)
     sourceEnd = sourceStart + target.byteLength - targetStart;
 
@@ -279,11 +279,7 @@ function _copyActual(source, target, targetStart, sourceStart, sourceEnd, isUint
   if (nb <= 0)
     return 0;
 
-  if (sourceStart === 0 && nb === sourceLen && (isUint8Copy || isUint8Array(target))) {
-    TypedArrayPrototypeSet(target, source, targetStart);
-  } else {
-    _copy(source, target, targetStart, sourceStart, nb);
-  }
+  _copy(source, target, targetStart, sourceStart, nb);
 
   return nb;
 }

src/node_buffer.cc

@@ -585,26 +585,15 @@ void StringSlice(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
-void CopyImpl(Local<Value> source_obj,
-              Local<Value> target_obj,
-              const uint32_t target_start,
-              const uint32_t source_start,
-              const uint32_t to_copy) {
-  ArrayBufferViewContents<char> source(source_obj);
-  SPREAD_BUFFER_ARG(target_obj, target);
-
-  memmove(target_data + target_start, source.data() + source_start, to_copy);
-}
-
 // Assume caller has properly validated args.
 void SlowCopy(const FunctionCallbackInfo<Value>& args) {
-  Local<Value> source_obj = args[0];
-  Local<Value> target_obj = args[1];
   const uint32_t target_start = args[2].As<Uint32>()->Value();
   const uint32_t source_start = args[3].As<Uint32>()->Value();
   const uint32_t to_copy = args[4].As<Uint32>()->Value();
 
-  CopyImpl(source_obj, target_obj, target_start, source_start, to_copy);
+  ArrayBufferView::FastCopy(ArrayBufferView::Cast(*args[0]), source_start,
+                            ArrayBufferView::Cast(*args[1]), target_start,
+                            to_copy);
 
   args.GetReturnValue().Set(to_copy);
 }
@@ -618,10 +607,10 @@ uint32_t FastCopy(Local<Value> receiver,
                   uint32_t to_copy,
                   // NOLINTNEXTLINE(runtime/references)
                   FastApiCallbackOptions& options) {
-  HandleScope scope(options.isolate);
-
-  CopyImpl(source_obj, target_obj, target_start, source_start, to_copy);
-
+  TRACK_V8_FAST_API_CALL("buffer.copy");
+  ArrayBufferView::FastCopy(ArrayBufferView::Cast(*source_obj), source_start,
+                            ArrayBufferView::Cast(*target_obj), target_start,
+                            to_copy);
   return to_copy;
 }