Benchmark: bitwise operator vs. boolean logic when using TypedArrays

bitwise operator vs. boolean logic when using TypedArrays (version: 2)

Bitwise operators are slow in javascript because there is implicit type conversion between floats and ints. If we use TypedArrays though, javascript engines shouldn't have to convert. But do they? This test is here to find out. We'll also check to see whether conversion is performed between another int-like datatypes, Uint32

Comparing performance of: bitwise operator on Int32Array vs boolean operator on Int32Array vs boolean operator with comparitors on Int32Array vs bitwise operator on Float32Array vs bitwise operator on Uint32Array vs boolean operator on Uint32Array vs boolean operator on Uint32Array with comparators

Created: 9 years ago by: Registered User

Jump to the latest result

Script Preparation code:

var i32 = new Int32Array(10000);
var f32 = new Float32Array(10000);
var ui32 = new Uint32Array(10000);

Tests:

bitwise operator on Int32Array
for(var i=0; i<i32.length; ++i){ i32[i] = i32[i] | i32[i]; }
boolean operator on Int32Array
for(var i=0; i<i32.length; ++i){ i32[i] = i32[i] || i32[i]; }
boolean operator with comparitors on Int32Array
for(var i=0; i<i32.length; ++i){ i32[i] = (i32[i]==1) || (i32[i]==1)? 1:0; }
bitwise operator on Float32Array
for(var i=0; i<f32.length; ++i){ f32[i] = f32[i] | f32[i]; }
bitwise operator on Uint32Array
for(var i=0; i<ui32.length; ++i){ ui32[i] = ui32[i] | ui32[i]; }
boolean operator on Uint32Array
for(var i=0; i<ui32.length; ++i){ ui32[i] = ui32[i] || ui32[i]; }
boolean operator on Uint32Array with comparators
for(var i=0; i<ui32.length; ++i){ ui32[i] = (ui32[i]==1) || (ui32[i]==1)? 1:0; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
bitwise operator on Int32Array
boolean operator on Int32Array
boolean operator with comparitors on Int32Array
bitwise operator on Float32Array
bitwise operator on Uint32Array
boolean operator on Uint32Array
boolean operator on Uint32Array with comparators

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 144 on Windows

View result in a separate tab

Test name	Executions per second
bitwise operator on Int32Array	26479.7 Ops/sec
boolean operator on Int32Array	26067.3 Ops/sec
boolean operator with comparitors on Int32Array	24864.1 Ops/sec
bitwise operator on Float32Array	22678.9 Ops/sec
bitwise operator on Uint32Array	25727.4 Ops/sec
boolean operator on Uint32Array	24717.9 Ops/sec
boolean operator on Uint32Array with comparators	24306.1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

I'd be happy to help explain the benchmark and its results.

**Benchmark Overview**

The benchmark measures the performance of different ways to perform bitwise operations versus boolean logic on TypedArrays (specifically, Int32Array and Float32Array) in JavaScript. The goal is to determine if there's any difference in performance between using bitwise operators and boolean operators with these data types.

**Options Compared**

There are four options being compared:

1. **Bitwise Operator**: Uses the bitwise OR operator (`|`) to perform operations.
2. **Boolean Operator without Comparators**: Uses the logical OR operator (`||`) without comparing values.
3. **Boolean Operator with Comparators**: Uses the logical OR operator (`||`) and compares values using `==` or `===`.
4. **Bitwise Operator on Float32Array**: Tests the performance of bitwise operators on a Float32Array, which is not explicitly mentioned in the benchmark definition but is included to provide additional data.

**Pros and Cons of Each Approach**

1. **Bitwise Operator**:
	* Pros: Can take advantage of hardware optimizations for bitwise operations.
	* Cons: May involve implicit type conversion between floats and integers, as mentioned in the benchmark definition.
2. **Boolean Operator without Comparators**:
	* Pros: Does not require explicit type conversion.
	* Cons: May be slower than bitwise operators due to additional logic.
3. **Boolean Operator with Comparators**:
	* Pros: Provides a clear comparison but may still involve some overhead.
	* Cons: May lead to incorrect results if the comparison values are not equal.

**Library and Purpose**

The `Int32Array` and `Float32Array` data types are part of the JavaScript typed array API. They provide a way to represent numeric arrays with specific types (integers or floats) that can be used for efficient numerical computations.

**Special JS Features/Syntax**

None mentioned in this benchmark, but it's worth noting that other features like `const`, `let`, and `arrow functions` may also affect performance depending on the context.

**Other Alternatives**

If you wanted to measure the performance of these operations using a different approach, you could try:

* Using a different data type (e.g., `Uint32Array`) or library (e.g., `NumJS`) that provides similar functionality.
* Implementing the operations manually without relying on typed arrays or bitwise operators.
* Comparing the performance of JavaScript engines (e.g., V8, SpiderMonkey) and browsers using other benchmarks.

Keep in mind that these alternatives may not be directly relevant to this specific benchmark, but they could provide additional insights into performance optimization strategies for JavaScript.

Related benchmarks: