Benchmark: Python benchmarks support (via Pyodide & WebAssembly)

Python benchmarks support (via Pyodide & WebAssembly) (version: 19)

MeasureThat.net now supports Python in-browser benchmarks via Pyodide. This new feature allows users to write and execute Python code directly within their web browser, enabling seamless performance testing and benchmarking of Python scripts. (added in v1.7.0)

Comparing performance of: `Test #1 bubble_sorted_array vs Test#2 efficient_sorted_array`

Created: one year ago by: Registered User

Go to the latest result

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/pyodide/v0.26.3/full/pyodide.js'></script>

Script Preparation code:

async function globalMeasureThatScriptPrepareFunction() {
  	window.globalPyodide = await loadPyodide();
  	console.log(globalPyodide.runPython('import sys; sys.version'));
	await globalPyodide.loadPackage('numpy');
	await globalPyodide.runPython(`
		import numpy as np
		import random

		def bubble_sort(arr):
			n = len(arr)
			for i in range(n):
				for j in range(0, n-i-1):
					if arr[j] > arr[j+1]:
						arr[j], arr[j+1] = arr[j+1], arr[j]
			return arr

		def efficient_sort(arr):
			return sorted(arr)

		def generate_random_array(size, lower_bound, upper_bound):
			return [random.randint(lower_bound, upper_bound) for _ in range(size)]

		# Generate a random array
		random_array = generate_random_array(250, 1, 500000)
		print("Original array:", random_array)
	`);    
}

Tests:

Test #1 bubble_sorted_array
window.globalPyodide.runPython(` bubble_sort(random_array.copy()) `);
Test#2 efficient_sorted_array
window.globalPyodide.runPython(` efficient_sort(random_array.copy()) `);

Historical Performance Data aggregated from 55 community runs

Desktop Results:

Chrome 50 runs

Test#2 efficient_sorted_array

2K/s

Test #1 bubble_sorted_array

187/s

Fastest: Test#2 efficient_sorted_array (11.0x faster)

View exact numbers

✓ Test#2 efficient_sorted_array: 2,054 ops/sec
• Test #1 bubble_sorted_array: 187 ops/sec

Mobile Results:

Chrome 5 runs

Test#2 efficient_sorted_array

4K/s

Test #1 bubble_sorted_array

340/s

Fastest: Test#2 efficient_sorted_array (12.3x faster)

View exact numbers

✓ Test#2 efficient_sorted_array: 4,199 ops/sec
• Test #1 bubble_sorted_array: 340 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Test #1 bubble_sorted_array
Test#2 efficient_sorted_array

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 21 hours ago)

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

Browser/OS: Chrome 151 on Windows

View result in a separate tab

Test#2 efficient_sorted_array

3K/s

Test #1 bubble_sorted_array

194/s

View exact numbers

Test name	Executions per second
✓ Test#2 efficient_sorted_array	2,852 Ops/sec
Test #1 bubble_sorted_array	194 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

LLMs can make mistakes. Check important info.

The provided benchmark tests the performance of two sorting algorithms in Python, executed within a JavaScript environment using the Pyodide library. Pyodide is a tool that allows Python code to run in the browser using WebAssembly, which bridges the gap between JavaScript and Python environments.

### Options Compared
The benchmark compares two sorting methods:
1. **Bubble Sort (`bubble_sort`)**
   - **Description**: This is a classic sorting algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.
   - **Test Case**: `bubble_sort(random_array.copy())`
   
2. **Efficient Sort (`efficient_sort`)**
   - **Description**: This uses Python's built-in `sorted` function, which is optimized and typically implemented using Timsort, a hybrid sorting algorithm derived from merge sort and insertion sort.
   - **Test Case**: `efficient_sort(random_array.copy())`

### Pros/Cons of Different Approaches

#### Bubble Sort
- **Pros**:
  - Simple to understand and implement.
  - Useful for educational purposes or when sorting small datasets.
  
- **Cons**:
  - Highly inefficient for large datasets; its time complexity is O(n^2) in the average and worst case.
  - Performs many unnecessary iterations, particularly when the list is already sorted or nearly sorted.

#### Efficient Sort
- **Pros**:
  - Highly optimized with an average time complexity of O(n log n).
  - Handles large datasets much better and is the preferred sorting method in most real-world applications.
  - Built-in functions are usually optimized by the language maintainers.

- **Cons**:
  - Less transparent than bubble sort in terms of the algorithm's inner workings for beginners.
  - May be less memory efficient than some custom sorting implementations, but generally preferable for large data sets.

### Other Considerations
- **Data Size and Randomness**: The benchmark generates random arrays of size 250 with values ranging between 1 and 500,000, allowing the evaluation of how both algorithms perform on datasets typical of real-world scenarios.
- **Execution Environment**: The benchmarks were executed in a Chrome browser environment, providing performance metrics like executions per second. This is relevant when comparing across different platforms as a purely browser-based performance measurement.

### Alternatives
Other sorting algorithms that could be considered for benchmarking purposes include:
- **Merge Sort**: O(n log n) time complexity, stable and efficient for large datasets.
- **Quick Sort**: O(n log n) time complexity on average, but the worst-case scenario can degrade to O(n^2) depending on the pivot selection.
- **Radix Sort**: A non-comparative sorting algorithm that can achieve O(n) time complexity under certain conditions, typically used for integer sorting.
  
Each of these alternatives offers distinct advantages and might be more suitable for specific applications or datasets depending on size, structure, and the required characteristics of the sort (stability, memory usage, etc.), demonstrating the importance of choosing the right algorithm for the task at hand.

Python benchmarks support (via Pyodide & WebAssembly) (version: 19)

MeasureThat.net now supports Python in-browser benchmarks via Pyodide. This new feature allows users to write and execute Python code directly within their web browser, enabling seamless performance testing and benchmarking of Python scripts. (added in v1.7.0)

Comparing performance of: Test #1 bubble_sorted_array vs Test#2 efficient_sorted_array

Created: one year ago by: Registered User

Go to the latest result

Test #1 bubble_sorted_array

Test#2 efficient_sorted_array

Historical Performance Data aggregated from 55 community runs

Desktop Results:

Chrome 50 runs

Mobile Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one year ago):

Related benchmarks

Comparing performance of: `Test #1 bubble_sorted_array vs Test#2 efficient_sorted_array`