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: 6 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

Autogenerated LLM Sumamry (model gemma2:9b, generated 4 days ago):

LLMs can make mistakes. Check important info.

Latest run results:

Run details: (Test run date: 2 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:131.0) Gecko/20100101 Firefox/131.0

Browser/OS: Firefox 131 on Windows

View result in a separate tab

Test name	Executions per second
boolean array	146740.6 Ops/sec
typed Array with uInt8	122425.4 Ops/sec
boolean array - Strict	150639.9 Ops/sec
typed Array with uInt8 - Strict	122334.1 Ops/sec
weird boolean - Strict	925908.9 Ops/sec
uint8 .fill()	2459886.0 Ops/sec
weird boolean - .fill	12564610.0 Ops/sec

Related benchmarks:

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

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: 6 years ago by: Registered User

Jump to the latest result

boolean array

typed Array with uInt8

boolean array - Strict

typed Array with uInt8 - Strict

weird boolean - Strict

uint8 .fill()

weird boolean - .fill

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model gemma2:9b, generated 4 days ago):