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 month ago by: Registered User

Jump 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()) `);

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: 4 days ago)

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

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Test #1 bubble_sorted_array	446.6 Ops/sec
Test#2 efficient_sorted_array	5960.6 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month 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.

Related benchmarks: