Pi-beräkningsbenchmark: Prestandajämförelse av 34 programmeringsspråk

Sammanfattning

Denna studie jämför prestandan hos 34 programmeringsspråk vid beräkning av π (pi) med hög precision. Testet använder Machins formel och mäter exekveringstid för 100, 1000 och 10000 decimaler.

Testmiljö

Hårdvara:

• Modell: MacBook Neo (Mac17,5)
• Processor: Apple A18 Pro
  • 6 kärnor: 2 prestandakärnor + 4 effektivitetskärnor
  • Arkitektur: ARM64
• Minne: 8 GB RAM
• Operativsystem: macOS (Darwin)

Mätmetod:

• Varje språk körs 4 gånger per test
• Första körningen räknas som "warmup" och exkluderas
• Resultatet är genomsnittet av de 3 efterföljande körningarna
• Tidsmätning i millisekunder (ms)

Metod: Machins formel

Alla implementationer använder Machins formel för π-beräkning:

π/4 = 4·arctan(1/5) - arctan(1/239)

Där arctan(x) beräknas med Taylor-serien:

arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...

Fördelar med denna metod:

1. Snabb konvergens (få termer krävs)
2. Enkel implementation
3. Hög noggrannhet möjlig
4. Endast heltalsaritmetik krävs

Resultat

100 decimaler

Språk	Tid (ms)	Kategori	Status
C	6	Kompilerat (native)	✓
Assembly	7	Kompilerat (native)	✓
C++	7	Kompilerat (native)	✓
Nim	7	Kompilerat (native)	✓
Odin	7	Kompilerat (native)	✓
Rust	7	Kompilerat (native)	✓
Fortran	8	Kompilerat (native)	✓
Objective-C	8	Kompilerat (native)	✓
Crystal	9	Kompilerat (native)	✓
Go	9	Kompilerat (native)	✓
Swift	9	Kompilerat (native)	✓
Lua	10	Tolkat (JIT)	✓
D	12	Kompilerat (native)	✓
Zig	12	Kompilerat (native)	✓
Bash	14	Tolkat (skript)	✓
Haskell	19	Kompilerat (native)	✓
Dart	20	Kompilerat/JIT	✓
Brainfuck	32	Esoteriskt	✓
Perl	34	Tolkat	✓
Python	34	Tolkat	✓
Java	36	JIT-kompilerat	✓
C#	38	JIT-kompilerat	✓
Kotlin	47	JIT-kompilerat	✓
PHP	56	Tolkat	✓
Ruby	62	Tolkat	✓
JavaScript	77	JIT-kompilerat	✓
Erlang	119	Tolkat (BEAM)	✓
Julia	151	JIT-kompilerat	✓
R	156	Tolkat	✓
Elixir	281	Tolkat (BEAM)	✓
Scala	389	JIT-kompilerat	✓
TypeScript	884	JIT-kompilerat	✓
Vimscript	31	Tolkat	✗ (precision)
Wolfram	-	Tolkat	✗ (ej konfigurerad)

1000 decimaler

Språk	Tid (ms)	Kategori	Status
Assembly	4	Kompilerat (native)	✓
C	4	Kompilerat (native)	✓
Go	5	Kompilerat (native)	✓
Rust	5	Kompilerat (native)	✓
Objective-C	6	Kompilerat (native)	✓
C++	7	Kompilerat (native)	✓
Crystal	7	Kompilerat (native)	✓
D	10	Kompilerat (native)	✓
Odin	10	Kompilerat (native)	✓
Nim	11	Kompilerat (native)	✓
Zig	12	Kompilerat (native)	✓
Fortran	17	Kompilerat (native)	✓
Dart	19	Kompilerat/JIT	✓
Haskell	19	Kompilerat (native)	✓
Bash	26	Tolkat (skript)	✓
Lua	29	Tolkat (JIT)	✓
Brainfuck	34	Esoteriskt	✓
Python	38	Tolkat	✓
C#	39	JIT-kompilerat	✓
Java	41	JIT-kompilerat	✓
Kotlin	49	JIT-kompilerat	✓
PHP	58	Tolkat	✓
Ruby	65	Tolkat	✓
Swift	78	Kompilerat (native)	✓
Perl	84	Tolkat	✓
Erlang	121	Tolkat (BEAM)	✓
Julia	151	JIT-kompilerat	✓
R	167	Tolkat	✓
JavaScript	195	JIT-kompilerat	✓
Elixir	280	Tolkat (BEAM)	✓
Scala	342	JIT-kompilerat	✓
TypeScript	960	JIT-kompilerat	✓

10000 decimaler

Språk	Tid (ms)	Kategori	Status
C	24	Kompilerat (native)	✓
Objective-C	25	Kompilerat (native)	✓
Assembly	27	Kompilerat (native)	✓
Haskell	50	Kompilerat (native)	✓
Rust	53	Kompilerat (native)	✓
Crystal	59	Kompilerat (native)	✓
Go	78	Kompilerat (native)	✓
D	79	Kompilerat (native)	✓
Brainfuck	109	Esoteriskt	✓
C#	116	JIT-kompilerat	✓
Ruby	128	Tolkat	✓
Dart	133	Kompilerat/JIT	✓
Java	134	JIT-kompilerat	✓
Kotlin	141	JIT-kompilerat	✓
Julia	161	JIT-kompilerat	✓
Zig	181	Kompilerat (native)	✓
C++	185	Kompilerat (native)	✓
Erlang	254	Tolkat (BEAM)	✓
PHP	264	Tolkat	✓
Python	300	Tolkat	✓
Elixir	353	Tolkat (BEAM)	✓
Scala	435	JIT-kompilerat	✓
R	451	Tolkat	✓
Odin	459	Kompilerat (native)	✓
Nim	463	Kompilerat (native)	✓
Fortran	1088	Kompilerat (native)	✓
Lua	1543	Tolkat (JIT)	✓
Perl	2285	Tolkat	✓
Bash	4456	Tolkat (skript)	✓
Swift	6735	Kompilerat (native)	✓
JavaScript	10065	JIT-kompilerat	✓
TypeScript	10334	JIT-kompilerat	✓

Prestandaanalys

Kompilerade språk (Native Code)

Definition: Språk som kompileras direkt till maskinkod som exekveras av processorn utan mellanliggande lager.

Karaktäristika:

• Direkt exekvering av maskinkod
• Ingen runtime overhead
• Manuell minneshantering (oftast)
• Optimeringar vid kompileringstillfället

Testresultat:

• Snabbaste: C (24 ms för 10000 decimaler)
• Mekanism: Kompilerar till optimerad ARM64-maskinkod
• Prestandaintervall: 4-1088 ms (beroende på implementation och bibliotek)

Exempel från testet:

C:           24 ms  (Native code, GMP library)
Assembly:    27 ms  (Direct ARM64 instructions)
Rust:        53 ms  (Native code, safe abstractions)
Go:          78 ms  (Native code, GC overhead)
Fortran:    1088 ms  (Native code, older implementation)

Varierande prestanda inom kategorin:

• C/Assembly: Direkt maskinkod, maximal prestanda
• Rust/Zig: Nollkostnadsabstraktioner, jämförbar med C
• Go: Sophämtning (GC) ger liten overhead
• Fortran: Äldre implementation, mindre optimerad

JIT-kompilerade språk (Just-In-Time)

Definition: Språk som kompileras till bytecode vid utveckling, sedan kompileras till maskinkod vid körning.

Karaktäristika:

• Kompilering sker vid körning (runtime)
• Optimeringar baserade på faktisk användning
• Automatisk sophämtning (GC)
• Portabilitet mellan plattformar

Testresultat:

• Snabbaste: Java (134 ms för 10000 decimaler)
• Mekanism: JVM kompilerar bytecode till maskinkod vid körning
• Prestandaintervall: 116-10334 ms

Exempel från testet:

Java:        134 ms  (JVM JIT optimization)
C#:          116 ms  (.NET Core JIT)
Julia:       161 ms  (LLVM JIT, scientific computing)
JavaScript: 10065 ms (V8 JIT, dynamic typing overhead)
TypeScript: 10334 ms (Compiles to JavaScript)

Varierande prestanda inom kategorin:

• Java/C#: Mogna JIT-kompilatorer, bra optimering
• Julia: Designat för numerisk prestanda
• JavaScript/TypeScript: Dynamisk typning, hög overhead

Tolkade språk

Definition: Språk där källkoden läses och exekveras rad för rad av en tolk (interpreter).

Karaktäristika:

• Ingen kompilering i förväg
• Direkt exekvering av källkod
• Flexibel typning (oftast)
• Enklare felsökning

Testresultat:

• Snabbaste: Lua (1543 ms för 10000 decimaler)
• Mekanism: Tolk läser och exekverar kod rad för rad
• Prestandaintervall: 38-4456 ms

Exempel från testet:

Python:      300 ms  (CPython interpreter)
Ruby:        128 ms  (YARV interpreter)
Perl:       2285 ms  (Perl interpreter)
Bash:       4456 ms  (Shell interpreter, process spawning)

Varierande prestanda inom kategorin:

• Python: Optimerad tolk, C-extensioner för stora tal
• Ruby: YARV (Yet Another Ruby Virtual machine)
• Perl: Äldre tolk, mindre optimerad
• Bash: Startar nya processer för varje operation

Funktionella språk (BEAM VM)

Definition: Språk som körs på Erlang Virtual Machine (BEAM), designade för samtidighet och feltolerans.

Karaktäristika:

• Kör på virtuell maskin (BEAM)
• Optimerade för många samtidiga processer
• Inbyggd sophämtning
• Feltolerant design

Testresultat:

• Erlang: 254 ms (10000 decimaler)
• Elixir: 353 ms (10000 decimaler)

Prestandaanalys:

• BEAM VM är optimerad för samtidighet, inte ren beräkning
• Overhead från process-schemaläggning
• Elixir har ytterligare overhead från Elixir-to-Erlang-kompilering

Språkspecifik analys

C

Testresultat:

• 100 decimaler: 6 ms
• 1000 decimaler: 4 ms
• 10000 decimaler: 24 ms

Teknisk analys:

• Kompilerar direkt till ARM64-maskinkod
• Använder GMP-biblioteket för arbitrary precision arithmetic
• Ingen runtime overhead
• Manuell minneshantering möjliggör optimering

Prestandafaktorer:

• Native code execution
• Optimerad GMP-implementation
• Kompilatoroptimeringar (clang/gcc)

Assembly

Testresultat:

• 100 decimaler: 7 ms
• 1000 decimaler: 4 ms
• 10000 decimaler: 27 ms

Teknisk analys:

• Direkt ARM64-instruktioner
• Ingen abstraktion eller overhead
• Manuell registerallokering
• Optimerad för specifik processorarkitektur

Prestandafaktorer:

• Maximal kontroll över exekvering
• Ingen kompilator-overhead
• Processor-specifika optimeringar

Rust

Testresultat:

• 100 decimaler: 7 ms
• 1000 decimaler: 5 ms
• 10000 decimaler: 53 ms

Teknisk analys:

• Kompilerar till native code via LLVM
• Nollkostnadsabstraktioner (zero-cost abstractions)
• Minnessäkerhet utan GC-overhead
• Moderna kompilatoroptimeringar

Prestandafaktorer:

• LLVM-backend ger optimerad maskinkod
• Ingen sophämtning (ownership system)
• Inline-optimeringar

Python

Testresultat:

• 100 decimaler: 34 ms
• 1000 decimaler: 38 ms
• 10000 decimaler: 300 ms

Teknisk analys:

• CPython-tolk exekverar bytecode
• Inbyggt stöd för arbitrary precision integers
• Dynamisk typning med runtime checks
• C-extensioner för prestandakritiska delar

Prestandafaktorer:

• Tolkad exekvering (10-100x långsammare än native)
• Optimerad arbitrary precision implementation
• Overhead från dynamisk typning

JavaScript (Node.js)

Testresultat:

• 100 decimaler: 77 ms
• 1000 decimaler: 195 ms
• 10000 decimaler: 10065 ms

Teknisk analys:

• V8-motorn JIT-kompilerar JavaScript
• Dynamisk typning med hidden classes
• Ingen inbyggd arbitrary precision (använder BigInt)
• Sophämtning med mark-and-sweep

Prestandafaktorer:

• JIT-kompilering ger bra prestanda för små tal
• BigInt-implementation har overhead
• Dynamisk typning ger overhead vid stora beräkningar

Bash

Testresultat:

• 100 decimaler: 14 ms
• 1000 decimaler: 26 ms
• 10000 decimaler: 4456 ms

Teknisk analys:

• Tolkad skalskript
• Startar nya processer för varje operation
• Ingen inbyggd arbitrary precision
• Använder externa verktyg (bc, awk)

Prestandafaktorer:

• Process-spawning overhead
• Ingen optimering för beräkning
• Designat för systemadministration, inte numerisk beräkning

Brainfuck

Testresultat:

• 100 decimaler: 32 ms
• 1000 decimaler: 34 ms
• 10000 decimaler: 109 ms

Teknisk analys:

• Esoteriskt språk med endast 8 instruktioner
• Tolkad exekvering
• Ingen optimering
• Minimal instruction set

Prestandafaktorer:

• Enkel tolk med minimal overhead
• Effektiv för små beräkningar
• Skalar dåligt med komplexitet

Slutsatser

Prestandahierarki

1. Kompilerade språk (Native): 4-1088 ms

• Snabbast för numerisk beräkning
• Direkt maskinkodsexekvering
• Lägst overhead

2. JIT-kompilerade språk: 116-10334 ms

• Bra prestanda efter uppvärmning
• Plattformsoberoende
• Automatisk optimering

3. Tolkade språk: 38-4456 ms

• Långsammare exekvering
• Enklare utveckling
• Flexibel typning

Prestandafaktorer

1. Kompileringstyp: Native > JIT > Tolkad
2. Typsystem: Statisk > Dynamisk
3. Minnesantering: Manuell > GC > Automatisk
4. Bibliotek: Optimerade > Standard > Ej optimerade

Rekommendationer

För maximal prestanda:

• C, Assembly, Rust, Zig

För balans mellan prestanda och utvecklingstid:

• Go, Swift, Kotlin, Java

För snabb utveckling:

• Python, Ruby, JavaScript

För vetenskaplig beräkning:

• Julia, Python (med NumPy), R

Metodologi

Testprotokoll

1. Bygge: Varje språk kompileras/förbereds enligt build.sh
2. Warmup: Första körningen exkluderas (JIT-uppvärmning, caching)
3. Mätning: 3 körningar, genomsnitt beräknas
4. Verifiering: Resultatet jämförs med känt π-värde

Reproducerbarhet

Alla tester kan reproduceras med:

./build.sh                    # Bygg alla språk
./test.sh [språk]             # Testa korrekthet
./run_all.sh [decimaler]     # Kör prestandatest

Begränsningar

• Hårdvaruberoende: Resultaten gäller för Apple A18 Pro
• Implementationsspecifika: Prestanda beror på bibliotek och implementation
• JIT-uppvärmning: Första körningen kan vara långsammare
• Minnesanvändning: Ej mätt i denna studie

Källkod

All källkod finns i respektive språkmapp:

• src/ - Källkod
• cmd/ - Byggscript
• bin/ - Körbar fil (efter bygge)

Licens

MIT License - Se LICENSE-fil för detaljer.

Författare

Automatiskt genererad benchmark-studie. Testdatum: 2026-04-23 Testmiljö: MacBook Neo, Apple A18 Pro, 8 GB RAM