Benchmark: Maping BooleanArray vs uInt8 Array2 vs uint8 with bitMasking _2

Maping BooleanArray vs uInt8 Array2 vs uint8 with bitMasking _2 (version: 4)

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.

Comparing performance of: boolean array vs typed Array with uInt8 vs boolean array - Strict vs typed Array with uInt8 - Strict vs weird boolean - Strict vs uint8 .fill() vs weird boolean - .fill

Created: 7 years ago by: Registered User

Jump to the latest result

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);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
boolean array
typed Array with uInt8
boolean array - Strict
typed Array with uInt8 - Strict
weird boolean - Strict
uint8 .fill()
weird boolean - .fill

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 8 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36

Browser/OS: Chrome 139 on Linux

View result in a separate tab

Test name	Executions per second
boolean array	425621.2 Ops/sec
typed Array with uInt8	77756.6 Ops/sec
boolean array - Strict	431249.2 Ops/sec
typed Array with uInt8 - Strict	90246.9 Ops/sec
weird boolean - Strict	580056.7 Ops/sec
uint8 .fill()	25077322.0 Ops/sec
weird boolean - .fill	27392968.0 Ops/sec

Autogenerated LLM Summary (model gemma2:9b, generated one year ago):

LLMs can make mistakes. Check important info.

Related benchmarks: