perf: apply masking key 8 bytes at a time (#58)

Basically what it says on the tin. Key results from the benchmarks
below, indicating ~35% faster read/write frame and and ~55% higher
throughput:

```
                  │ ./baseline/bench-results.txt │       ./head/bench-results.txt       │
                  │            sec/op            │    sec/op     vs base                │
ReadFrame/1KiB-4                     867.5n ± 3%   575.8n ±  4%  -33.63% (p=0.000 n=10)
ReadFrame/1MiB-4                     550.2µ ± 1%   331.0µ ± 18%  -39.84% (p=0.000 n=10)
WriteFrame/1KiB-4                    932.5n ± 0%   675.9n ±  0%  -27.51% (p=0.000 n=10)
WriteFrame/1MiB-4                    588.4µ ± 4%   336.3µ ±  4%  -42.84% (p=0.000 n=10)
geomean                              22.62µ        14.43µ        -36.22%

                  │ ./baseline/bench-results.txt │       ./head/bench-results.txt        │
                  │             B/s              │      B/s       vs base                │
ReadFrame/1KiB-4                    1.109Gi ± 3%   1.671Gi ±  4%  +50.67% (p=0.000 n=10)
ReadFrame/1MiB-4                    1.775Gi ± 1%   2.950Gi ± 15%  +66.22% (p=0.000 n=10)
WriteFrame/1KiB-4                   1.032Gi ± 0%   1.423Gi ±  0%  +37.95% (p=0.000 n=10)
WriteFrame/1MiB-4                   1.660Gi ± 3%   2.904Gi ±  3%  +74.97% (p=0.000 n=10)
geomean                             1.355Gi        2.125Gi        +56.80%
```

Author: mccutchen

proto.go

@@ -496,25 +496,29 @@ func NewMaskingKey() MaskingKey {
 	return key
 }
 
-// applyMask optimizes payload masking by working 8 bytes at a time.
+// applyMask applies a [MaskingKey] to the payload in-place.
 func applyMask(payload []byte, mask MaskingKey) {
 	n := len(payload)
+	if n == 0 {
+		return
+	}
+
+	// duplicate 4 byte masking key to make uint64 mask that can be applied to
+	// the payload 8 bytes at a time in a single XOR.
+	mask64 := uint64(mask[0]) | uint64(mask[1])<<8 | uint64(mask[2])<<16 | uint64(mask[3])<<24
+	mask64 |= mask64 << 32
+
+	// apply mask in-place 8 bytes at a time
 	chunks := n / 8
 	for i := range chunks {
-		// create a slice of exactly 8 bytes that the compiler can verify and
-		// eliminate bounds checks on the 8 xor operations per iteration
-		chunk := payload[i*8 : i*8+8]
-		chunk[0] ^= mask[0]
-		chunk[1] ^= mask[1]
-		chunk[2] ^= mask[2]
-		chunk[3] ^= mask[3]
-		chunk[4] ^= mask[0]
-		chunk[5] ^= mask[1]
-		chunk[6] ^= mask[2]
-		chunk[7] ^= mask[3]
+		offset := i * 8
+		data := binary.LittleEndian.Uint64(payload[offset : offset+8])
+		data ^= mask64
+		binary.LittleEndian.PutUint64(payload[offset:offset+8], data)
 	}
+
 	remainder := payload[chunks*8:]
-	for i := range len(remainder) {
+	for i := range remainder {
 		remainder[i] ^= mask[i&3] // i&3 == i%4, but faster
 	}
 }

proto_test.go

@@ -230,13 +230,12 @@ func BenchmarkWriteFrame(b *testing.B) {
 			assert.NilError(b, websocket.WriteFrame(buf, mask, frame))
 			expectedSize := len(buf.Bytes())
 			b.SetBytes(int64(expectedSize))
-			buf.Reset()
 			b.ResetTimer()
 
 			for i := 0; i < b.N; i++ {
 				buf.Reset()
 				assert.NilError(b, websocket.WriteFrame(buf, mask, frame))
-				assert.Equal(b, len(buf.Bytes()), expectedSize, "payload length")
+				assert.Equal(b, buf.Len(), expectedSize, "payload length")
 			}
 		})
 	}