Run results for: Maping BooleanArray vs uInt8 Array2 vs uint8 with bitMasking _2

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.

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.128 Safari/537.36

Browser: Chrome 89

Operating system: Windows

Device Platform: Desktop

Date tested: 3 years ago

Test name	Executions per second
boolean array	213299.9 Ops/sec
typed Array with uInt8	56718.3 Ops/sec
boolean array - Strict	234900.4 Ops/sec
typed Array with uInt8 - Strict	62705.5 Ops/sec
weird boolean - Strict	433367.0 Ops/sec
uint8 .fill()	7874508.0 Ops/sec
weird boolean - .fill	8477467.0 Ops/sec

Script Preparation code:

const size = 1024;

var buffer = new ArrayBuffer(size);
var u8View = new Uint8Array(buffer, 0, size);

var buffer2 = new ArrayBuffer(size);
var u8BoolView = new Uint8Array(buffer2, 0, size/8);

var booleanArray = [];
for (let i=0; i<size; i++) {
  const someVal = Math.random()*1;
  //typed array stores (0 or 1)
  u8View[i] = someVal;
  //boolean array stores (false or true)
  booleanArray.push(someVal == 1);
}

for (let i=0; i<size/8; i++) {
  let some256Val = Math.random()*255;
  for (let j=0; j<8; j++) { 
  }
  let FLAG_A = some256Val &= 128;
  let FLAG_B = some256Val &= 64;
  let FLAG_C = some256Val &= 32;
  let FLAG_D = some256Val &= 16;
  let FLAG_E = some256Val &= 8;
  let FLAG_F = some256Val &= 4;
  let FLAG_G = some256Val &= 2;
  let FLAG_H = some256Val &= 1;
  u8BoolView[i] = (FLAG_A | FLAG_B | FLAG_C | FLAG_D | FLAG_E | FLAG_F | FLAG_G | FLAG_H);
}

Tests:

boolean array
const resultArray = booleanArray.map(s => { return (s == 1); });
typed Array with uInt8
const resultArray = u8View.map(s => { return (s == 1); });
boolean array - Strict
'use strict'; const resultArray = booleanArray.map(s => { return (s == 1); });
typed Array with uInt8 - Strict
'use strict'; const resultArray = u8View.map(s => { return (s == 1); });
weird boolean - Strict
'use strict'; const resultArray = u8BoolView.map(s => { return ((s &= 128) == 1); });
uint8 .fill()
const resultArray = u8View.fill(1);
weird boolean - .fill
const resultArray = u8BoolView.fill(255);

Run results for: Maping BooleanArray vs uInt8 Array2 vs uint8 with bitMasking _2

boolean array

typed Array with uInt8

boolean array - Strict

typed Array with uInt8 - Strict

weird boolean - Strict

uint8 .fill()

weird boolean - .fill