fix(bytes): equals() works with subarray

[iuioiua]

Fixes #3603

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Project coverage is 90.99%. Comparing base (d209aa3) to head (0052a36).

Additional details and impacted files

@@           Coverage Diff           @@
##             main    #4630   +/-   ##
=======================================
  Coverage   90.99%   90.99%           
=======================================
  Files         478      478           
  Lines       37383    37383           
  Branches     5308     5308           
=======================================
  Hits        34016    34016           
  Misses       3305     3305           
  Partials       62       62           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[0f-0b]

new TypedArray(typedArray) copies each element to the new array.

[kt3k]

LGTM 👍

[tjjfvi]

This change fixes the bug but is really bad for performance:

import { equals } from "https://raw.githubusercontent.com/denoland/deno_std/0052a36/bytes/equals.ts"

const a999 = new Uint8Array(999);
const b999 = new Uint8Array(999);

const a1k = new Uint8Array(1000);
const b1k = new Uint8Array(1000);

Deno.bench("999", () => {
  equals(a999, b999)
})

Deno.bench("1k", () => {
  equals(a1k, b1k)
})

benchmark      time (avg)        iter/s             (min … max)       p75       p99      p995
--------------------------------------------------------------- -----------------------------
999           461.05 ns/iter   2,168,977.3 (454.72 ns … 511.36 ns) 460.35 ns 487.23 ns 511.36 ns
1k              1.37 µs/iter     728,273.7     (1.29 µs … 1.53 µs)   1.41 µs   1.53 µs   1.53 µs

The "optimized" equals32Bit function is 3x slower than the naive version.

As @0f-0b pointed out, the new Uint32Array(a, ...) is copying each element; new Uint32Array(new Uint8Array([1, 2])) is new Uint32Array([1, 2]). So, it's currently, taking two N-byte buffers, allocating two 4N-byte buffers, copying the N bytes to every fourth byte, and then checking if all 4N bytes are equivalent (75% of which are zeroes).

I don't think this function should be allocating memory at all (for one thing, it makes the function always O(N), even if the first byte differs). Instead, the equals32Bit path should be taken only when a.byteOffset % 4 === b.byteOffset % 4, and the uint32arrays should be constructed as subarrays.

[iuioiua]

Thank you for the insight, @0f-0b and @tjjfvi. You guys are right. I'll submit a PR that reverts this change shortly.

[iuioiua]

See #4632