Benchmark: big for loop vs multiple small for loops

HTML Preparation code:

<script type="module">
    import { World } from 'https://cdn.jsdelivr.net/npm/miniplex@2.0.0/+esm';
  	window.World = World;
</script>

Script Preparation code:

const world = new World();
window.world = world;

for (let i = 1, len = 14500; i <= len; i++) {
    const player = world.add({
      	screen: {
          isVisible: i & 1,
        },
        position: {
            x: i * 2,
            y: i * 4,
        },
        velocity: {
            x: i + 1,
            y: i + 2,
        },
        health: {
            current: i,
            max: i + 1,
        }
    });
}

for (let i = 1, len = 1500; i <= len; i++) {
    const player = world.add({
        position: {
            x: i * 2,
            y: i * 4,
        },
        velocity: {
            x: i + 1,
            y: i + 2,
        },
    });
}

Tests:

one big loop default
const entities = world.with("position", "screen"); for (const entity of entities) { const { position, screen } = entity; if (!screen.isVisible) { continue; } if (entity.velocity) { const { velocity } = entity; position.x += velocity.x position.y += velocity.y } if (entity.health) { const { health } = entity; if (health > 250) { position.x += 1; } } }
one big loop no consts
const entities = world.with("position", "screen"); for (const entity of entities) { if (!entity.screen.isVisible) { continue; } if (entity.position && entity.velocity) { entity.position.x += entity.velocity.x entity.position.y += entity.velocity.y } if (entity.position && entity.health) { if (entity.health > 250) { entity.position.x += 1; } } }
small loops
const velocityEntities = world.with("position", "screen", "velocity"); const healthEntities = world.with("position", "screen", "health"); for (const { position, screen, velocity } of velocityEntities) { if (!screen.isVisible) { continue; } position.x += velocity.x position.y += velocity.y } for (const { position, screen, health } of healthEntities) { if (!screen.isVisible) { continue; } if (health > 250) { position.x += 1; } }
small loops where
const velocityEntities = world.with("position", "screen", "velocity").where(({ screen }) => screen.isVisible); const healthEntities = world.with("position", "screen", "health").where(({ screen, health }) => screen.isVisible && health > 250); for (const { position, screen, velocity } of velocityEntities) { position.x += velocity.x position.y += velocity.y } for (const { position, screen, health } of healthEntities) { if (health > 250) { position.x += 1; } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
one big loop default
one big loop no consts
small loops
small loops where

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 122 on Windows

View result in a separate tab

Test name	Executions per second
one big loop default	3171.1 Ops/sec
one big loop no consts	3126.6 Ops/sec
small loops	2406.7 Ops/sec
small loops where	414.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what is being tested.

**Benchmark Definition**

The benchmark definition is a JavaScript function that creates a world with entities, each having position, screen, velocity, and health properties. The function then iterates over these entities and performs various operations based on their properties.

There are four different benchmarks defined:

1. **One big loop default**: This benchmark uses the `with` method to retrieve all entities with `position` and `screen` properties. It then iterates over these entities, performing operations such as updating position and screen visibility.
2. **One big loop no consts**: This benchmark is similar to the previous one but does not use the `const` keyword for variable declarations.
3. **Small loops**: This benchmark uses the `with` method twice, once for velocity entities and once for health entities. It then iterates over these entities separately, performing operations such as updating position and checking health values.
4. **Small loops where**: This benchmark uses the `where` method to filter entities based on specific conditions, such as screen visibility and health value.

**Options being compared**

The different benchmarks compare the performance of various methods for iterating over entities and performing operations:

1. Using `with` vs. not using `with`
2. Using `const` vs. not using `const` for variable declarations
3. Iterating over all entities at once vs. iterating over entities separately

**Pros and cons**

Here are some pros and cons of each approach:

1. **Using `with`**
	* Pros: Can be more readable, avoids the need to declare variables explicitly.
	* Cons: May lead to slower performance due to the overhead of creating and managing objects.
2. **Not using `with`**
	* Pros: Can avoid the overhead of creating objects, may lead to faster performance.
	* Cons: Requires explicit variable declarations, can be less readable.
3. **Using `const` vs. not using `const`**
	* Pros: Can help with scoping and avoid unnecessary reassignments, which can improve performance.
	* Cons: May add unnecessary overhead due to the creation of objects.

**Device platform and operating system**

The latest benchmark result shows that Chrome 122 on Windows 10 (Desktop) is used as the test environment. The results indicate a significant difference in execution speed between different benchmarks, suggesting that optimizing for this specific device platform and operating system can lead to performance improvements.

In summary, the benchmark tests various methods for iterating over entities and performing operations, comparing the pros and cons of using `with`, not using `with`, and using `const` vs. not using `const`. The results suggest that optimizing for a specific device platform and operating system can lead to significant performance improvements.

Related benchmarks:

big for loop vs multiple small for loops (version: 0)

Comparing performance of: one big loop default vs one big loop no consts vs small loops vs small loops where

Created: 2 years ago by: Guest

Jump to the latest result

one big loop default

one big loop no consts

small loops

small loops where

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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