Benchmark: Immutable vs Versioned - Equality Check Performance

Immutable vs Versioned - Equality Check Performance (version: 3)

How much slowed is a versioned equality check than an immutable (reference) equality check?

Comparing performance of: Immutable Check (equal) vs Immutable Check (NOT equal) vs Versioned Check (equal) vs Versioned Check (NOT equal) vs Immutable or Versioned check (equal) vs Immutable or Versioned check (NOT equal)

Created: 7 years ago by: Registered User

Jump to the latest result

Script Preparation code:

function immutableCheck(obj1, obj2) {
	return (obj1 === obj2)
};

function versionedCheck(obj1, obj2) {
	if ((obj1 == null) && (obj2 == null)) return true;
	if ((obj1 != null) && (obj2 != null)) return (obj1._v_ === obj2._v_);
	return false;
};

function immutableOrVersionedCheck(obj1, obj2) {
	if ((obj1 == null) && (obj2 == null)) return true;
	if ((obj1 != null) && (obj2 != null)) {
		if (obj1._v_) return (obj1._v_ === obj2._v_);
		return (obj1 === obj2);
	}
    return false;
};

function optimisationKiller(f, obj1, obj2) {
  	isEqual = 42;
	isEqual = f(obj1, obj2);
	res = isEqual;
}

object1 = { _v_: 1 };
object2 = { _v_: 2 };

Tests:

Immutable Check (equal)
optimisationKiller(immutableCheck, object1, object1);
Immutable Check (NOT equal)
optimisationKiller(immutableCheck, object1, object2);
Versioned Check (equal)
optimisationKiller(versionedCheck, object1, object1);
Versioned Check (NOT equal)
optimisationKiller(versionedCheck, object1, object2);
Immutable or Versioned check (equal)
optimisationKiller(immutableOrVersionedCheck, object1, object1);
Immutable or Versioned check (NOT equal)
optimisationKiller(immutableOrVersionedCheck, object1, object2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Immutable Check (equal)
Immutable Check (NOT equal)
Versioned Check (equal)
Versioned Check (NOT equal)
Immutable or Versioned check (equal)
Immutable or Versioned check (NOT equal)

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and its results.

**Benchmark Definition**

The benchmark tests how different equality check approaches perform in JavaScript. There are three main functions:

1. `immutableCheck(obj1, obj2)`: This function uses the reference equality check (`===`) to compare two objects. It returns `true` if both objects have the same memory address.
2. `versionedCheck(obj1, obj2)`: This function checks for versioned equality by comparing the `_v_` property of each object. If either object is null, it returns true; otherwise, it compares the `_v_` property. If neither object has an `_v_` property, it falls back to reference equality check.
3. `immutableOrVersionedCheck(obj1, obj2)`: This function uses a combination of both approaches: if one or both objects are null, it returns true; otherwise, it compares the `_v_` property (if present).

**Options Compared**

The benchmark compares four different equality check approaches:

1. **Immutable Check (`immutableCheck`)**: Uses reference equality check.
2. **Versioned Check (`versionedCheck`)**: Checks for versioned equality by comparing the `_v_` property.
3. **Immutable or Versioned Check (`immutableOrVersionedCheck`)**: Combines both approaches, with some variations.

**Pros and Cons**

Here's a brief summary of each approach:

1. **Immutable Check (`immutableCheck`)**:
	* Pros: Fast, easy to understand, and straightforward.
	* Cons: May lead to unexpected behavior when objects have mutable properties or side effects.
2. **Versioned Check (`versionedCheck`)**:
	* Pros: Handles object identity more accurately than reference equality check, especially for objects with complex structures.
	* Cons: Can be slower due to the additional property comparison and may not handle all edge cases correctly (e.g., non-numeric values).
3. **Immutable or Versioned Check (`immutableOrVersionedCheck`)**:
	* Pros: Balances performance and predictability, providing a good default choice for most use cases.
	* Cons: May be slower than the immutable check due to the additional property comparison.

**Library and Special JS Features**

The benchmark uses the `_v_` property to simulate versioning. This property is not part of standard JavaScript, so it's likely specific to the versioning library or framework being tested (not explicitly mentioned in the provided code).

**Other Alternatives**

If you need more fine-grained control over equality checks or performance optimizations, consider using:

1. **Deep object comparison libraries**: Libraries like `lodash.isEqual` or `jsonschema/validate` provide optimized and efficient ways to compare objects.
2. **Custom equality functions**: Implementing custom equality functions can offer better performance and flexibility for specific use cases.
3. **Native JavaScript methods**: Utilize native JavaScript methods like `Object.is()` (available in modern browsers) or `===` with the `strict` mode (for better handling of object identity).

Keep in mind that the best approach depends on your specific requirements, data structures, and performance constraints.

Related benchmarks: