Benchmark: Big vs small numbers

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

const large = 11294810293810000;
const smaller = large / 60000;

function millisToMins(millis) {
  return millis / 60000;
}

function doesNothing(input) {
  return input;
}

Tests:

working with millis then converting
millisToMins(large / 12131 * 1237)
working with minutes directly
smaller / 12131 * 1237
working with minutes directly (with a wrapped function call to see if that causes slowness)
doesNothing(smaller / 12131 * 1237)
more wrapping to see performance impact
doesNothing(doesNothing(doesNothing(doesNothing(doesNothing(smaller / 12131 * 1237)))))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
working with millis then converting
working with minutes directly
working with minutes directly (with a wrapped function call to see if that causes slowness)
more wrapping to see performance impact

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36

Browser/OS: Chrome 132 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
working with millis then converting	135226016.0 Ops/sec
working with minutes directly	152305872.0 Ops/sec
working with minutes directly (with a wrapped function call to see if that causes slowness)	153816896.0 Ops/sec
more wrapping to see performance impact	125217944.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the JSON provided compares the performance of various computational approaches to handling time values, specifically in milliseconds and minutes. The focus is on different methods of calculating elapsed time based on large numbers and the potential performance implications of wrapping function calls.

### Options Compared

1. **Working with milliseconds then converting**:
   - **Test Case**: `millisToMins(large / 12131 * 1237)`
   - Here, large numerical calculations are performed first in milliseconds before converting to minutes. The `millisToMins` function is used for this conversion.
   - **Performance**: This option is expected to be slower because it involves two operations: division and multiplication, followed by a conversion function.

2. **Working with minutes directly**:
   - **Test Case**: `smaller / 12131 * 1237`
   - This method directly operates on time calculated in minutes (derived as `large / 60000`), which is expected to be faster.
   - **Performance**: This approach typically executes faster than the first since it skips the overhead of converting back from milliseconds.

3. **Wrapped function call with minute calculation**:
   - **Test Case**: `doesNothing(smaller / 12131 * 1237)`
   - This case involves the same direct minute calculation but wraps it in a function call (`doesNothing`), introducing additional function overhead.
   - **Performance**: The impact of function wrapping is being tested to see if it affects performance compared to straight calculations.

4. **More wrapping to measure performance impact**:
   - **Test Case**: `doesNothing(doesNothing(doesNothing(doesNothing(doesNothing(smaller / 12131 * 1237)))))`
   - This test involves multiple layers of function wrapping to see if excessive function calls significantly slow down the execution.
   - **Performance**: As the number of function calls increases, it is expected that performance might degrade, illustrating the function call overhead and stack depth limits.

### Pros and Cons of Different Approaches

- **Direct calculations (working with minutes)**:
  - **Pros**: 
    - More straightforward and less computational overhead, as it reduces the need for conversions.
  - **Cons**: 
    - When working solely with larger computations, this approach may not always be applicable.

- **Using milliseconds with conversion**:
  - **Pros**:
    - Sometimes working with milliseconds might be necessary based on specific contexts (API responses, timestamps).
  - **Cons**:
    - Slower due to the additional conversion step.
  
- **Function wrapping**:
  - **Pros**:
    - Enables code abstraction and potential reuse; necessary in many functional programming designs.
  - **Cons**:
    - Increased function call overhead can lead to performance degradation in scenarios with high-frequency or recursive function calls.

### Other Considerations

- **JavaScript Engine Optimization**: Modern JavaScript engines can optimize function calls better than older ones, but excessive wrapping still generally leads to slower performance.
- **Use Cases**: The choice between these options should depend on the specific requirements of the application. For applications that require high-performance calculations (e.g., real-time systems), minimizing function calls and avoiding unnecessary conversions is key.
  
### Other Alternatives

- **Using Libraries**: If a library was used (though not in this case), it could facilitate these calculations, especially for complex time manipulations. Libraries like `moment.js` or `date-fns` can handle large date/time manipulations but may introduce overhead.
- **Native `Date` and `Time` functions**: Utilizing JavaScript's built-in `Date` functions could be another alternative, though they are primarily geared toward handling date objects rather than raw calculations, often adding complexity without significant benefits.

In conclusion, this benchmark effectively highlights the performance implications of using milliseconds versus minutes in calculations and illustrates the potential impact of function wrapping in JavaScript executions. Each method has distinct advantages and challenges, thus, the best approach will vary based on the specific context and needs of the application.

Related benchmarks:

Big vs small numbers (version: 3)

Comparing performance of: working with millis then converting vs working with minutes directly vs working with minutes directly (with a wrapped function call to see if that causes slowness) vs more wrapping to see performance impact

Created: 2 months ago by: Registered User

Jump to the latest result

working with millis then converting

working with minutes directly

working with minutes directly (with a wrapped function call to see if that causes slowness)

more wrapping to see performance impact

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):