Benchmark: while vs recurse vs continuation

Script Preparation code:

var paths = [];

function nthIndexOf(s, search, count, pos = 0) {
    let i = pos - 1;
    while (count > 0) {
        i = s.indexOf(search, i + 1);
        if (i === -1) {
            break;
        }
        count--;
    }
    return i;
}

function nthIndexOfRec(s, search, count, pos = 0) {
    const recurse = (c, p) => {
        if (c === 0) {
            return p;
        }
        const index = s.indexOf(search, p + 1);
        if (index === -1) {
            return -1;
        }
        return recurse(c - 1, index);
    };
    return recurse(count, pos - 1);
}

function nthIndexOfCc(s, search, count, pos = 0) {
    const recurse = (c, p, cc) => {
        if (c === 0) {
            cc(p);
            return;
        }
        const index = s.indexOf(search, p + 1);
        if (index === -1) {
            cc(-1);
            return;
        }
        recurse(c - 1, index, cc);
    };

    let result = -1;
    recurse(count, pos - 1, n => (result = n));
    return result;
}

Tests:

while
paths.forEach(path => console.log(path.substring(0, nthIndexOf(path, '/', 5) + 1)));
recurse
paths.forEach(path => console.log(path.substring(0, nthIndexRec(path, '/', 5) + 1)));
continuation
paths.forEach(path => console.log(path.substring(0, nthIndexCc(path, '/', 5) + 1)));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
while
recurse
continuation

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested in this JavaScript microbenchmark.

**Benchmark Definition**

The benchmark is designed to compare three different approaches for finding the nth occurrence of a character (`/` in this case) within a string:

1. **While Loop (while)**: This approach uses a traditional while loop to iterate until the desired count is reached.
2. **Recursive Function Call (recurse)**: This approach defines a recursive function `nthIndexOfRec` that calls itself with decreasing counts until it reaches zero.
3. **Continuation (continuation)**: This approach uses a technique called "continuation" or "higher-order functions," where the recursive function is passed as an argument to another function (`nthIndexOfCc`) that handles the iteration.

**Pros and Cons of Each Approach**

* **While Loop (while)**:
	+ Pros: Simple, easy to understand, and efficient for small counts.
	+ Cons: May become slow for large counts due to repeated string searches.
* **Recursive Function Call (recurse)**:
	+ Pros: Can be more intuitive than a while loop for finding patterns or recursion-based solutions.
	+ Cons: Recursive calls can lead to stack overflow errors if not implemented carefully, and the function may become slower as the count increases.
* **Continuation (continuation)**:
	+ Pros: Avoids recursive calls and potentially reduces memory usage. Can be more flexible for handling different iteration strategies.
	+ Cons: May require a deeper understanding of functional programming concepts, and its efficiency can depend on the specific implementation.

**Library Usage**

In the benchmark definition JSON, there are no explicit library imports mentioned. However, some libraries might be implicitly used by JavaScript engines or browsers (e.g., V8 in Chrome). If we were to analyze the code further, we'd look for any external dependencies or assumptions made about the environment.

**Special JS Features/Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax. It primarily relies on built-in functions and language constructs.

Now, let's discuss the alternative approaches that could be explored:

1. **Iterative Approach with a Loop**: A straightforward iterative approach using a loop (e.g., `for` or `do-while`) to find the nth occurrence.
2. **Using Regular Expressions**: This approach uses regular expressions to find the nth match instead of string searching.
3. **Parallel Processing**: If the benchmark is designed for high-performance testing, parallel processing techniques like Web Workers or clusters could be used to compare execution speeds across multiple cores.

These alternative approaches might alter the pros and cons of each method mentioned earlier. For example, an iterative approach with a loop might be more efficient than a recursive function call for large counts but less flexible than the continuation approach.

Keep in mind that the choice of implementation depends on the specific requirements and constraints of the benchmark.

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/99.0.4844.51 Safari/537.36 Edg/99.0.1150.36

Browser/OS: Chrome 99 on Windows

View result in a separate tab

Test name	Executions per second
while	8340937.5 Ops/sec
recurse	8810496.0 Ops/sec
continuation	8333820.0 Ops/sec

Related benchmarks:

while vs recurse vs continuation (version: 0)

Comparing performance of: while vs recurse vs continuation

Created: 2 years ago by: Guest

Jump to the latest result

while

recurse

continuation

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):