Run results for: Maping numeric vs f32 vs f64

compare the map speed of an array of random true/false values compared to an ArrayBuffer with a uInt8 view of 0 or 1. The results are that the typed array is much much faster. There are two possible reasons I can think of for this. 1) JavaScript boolean type size of 4Bytes where as an element of a uInt8 array is actually 1Byte. 2) The ArrayBuffer is allocating contiguous memory resulting in a better cache hit ratio.

Go to the benchmark

Run details:

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Firefox/102.0

Browser: Firefox 102

Operating system: Linux

Device Platform: Desktop

Date tested: 8 months ago

Test name	Executions per second
numeric array	86680.1 Ops/sec
Float64Array	24004.8 Ops/sec
Float32Array	20436.4 Ops/sec

Script Preparation code:

const size = 1024;

var buffer64 = new ArrayBuffer(size*8);
var buffer32 = new ArrayBuffer(size*4);
var f64View = new Float32Array(buffer64, 0, size);
var f32View = new Float32Array(buffer32, 0, size);

var numericArray = [];
for (let i=0; i<size; i++) {
  const someVal = Math.random();
  numericArray[i] = someVal;
  f64View[i] = someVal;
  f32View[i] = someVal;
}

Tests:

numeric array
const resultArray = numericArray.map(s => { return (s == 1); });
Float64Array
const resultArray = f64View.map(s => { return (s == 1); });
Float32Array
const resultArray = f32View.map(s => { return (s == 1); });

Run results for: Maping numeric vs f32 vs f64

numeric array

Float64Array

Float32Array