diff --git a/README.md b/README.md index ac845c5..ea6ec4e 100644 --- a/README.md +++ b/README.md @@ -112,86 +112,146 @@ xychart-beta ### Resursanvändning över tid -Följande diagram visar minnesanvändning genom programmets livstid för utvalda språk: +Följande diagram visar minnesanvändning genom programmets hela livstid. X-axeln visar tid i millisekunder från start till slut, och Y-axeln visar minnesanvändning i MB. Varje diagram är skalat för att tydligt visa variationer för just det språket. -#### Elixir (Långsamt språk med konstant minne) +#### Kompilerade språk (Native Code) + +##### C - Snabbaste språket (11ms, minimalt minne) ```mermaid xychart-beta - title "Elixir - Resursanvändning över tid" - x-axis "Tid (ms)" 0 --> 294 - y-axis "Minne (MB)" 0 --> 3.0 + title "C - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 12 + y-axis "Minne (MB)" 0 --> 1 + line [0.0] +``` + +**Analys:** C använder praktiskt taget inget minne och kör på 11ms. Minnet är stabilt på 0 MB under hela körningen. + +##### Rust - Snabb och minneseffektiv (11ms) + +```mermaid +xychart-beta + title "Rust - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 12 + y-axis "Minne (MB)" 0 --> 1 + line [0.0] +``` + +**Analys:** Rust matchar C i prestanda och minnesanvändning. Nollkostnadsabstraktioner ger optimal prestanda. + +##### Assembly - Låg-nivå prestanda (18ms) + +```mermaid +xychart-beta + title "Assembly - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 20 + y-axis "Minne (MB)" 0 --> 1 + line [0.0] +``` + +**Analys:** Assembly visar liknande prestanda som C och Rust med minimalt minne. + +##### Haskell - Snabb men högt minne (49ms, 10.5MB) + +```mermaid +xychart-beta + title "Haskell - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 8 + y-axis "Minne (MB)" 0 --> 12 + line [10.5] +``` + +**Analys:** Haskell är snabb (49ms) men använder betydligt mer minne (10.5 MB) på grund av runtime och garbage collector. + +##### Dart - Högt minne men snabb (41ms, 9.1MB) + +```mermaid +xychart-beta + title "Dart - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 12 + y-axis "Minne (MB)" 0 --> 11 + line [9.1] +``` + +**Analys:** Dart visar högre minnesanvändning (9.1 MB) men bibehåller bra prestanda tack vare JIT-kompilering. + +#### Tolkade språk + +##### Elixir - Långsamt men stabilt minne (338ms, 2MB) + +```mermaid +xychart-beta + title "Elixir - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 300 + y-axis "Minne (MB)" 0 --> 3 line [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0] ``` -#### TypeScript (Långsamt språk med varierande minne) +**Analys:** Elixir är långsammare (338ms) men visar mycket stabil minnesanvändning på 2 MB genom hela körningen. BEAM VM ger förutsägbar minnesanvändning. + +##### TypeScript - Långsammast med varierande minne (1780ms, 2MB) ```mermaid xychart-beta - title "TypeScript - Resursanvändning över tid" - x-axis "Tid (ms)" 0 --> 1419 - y-axis "Minne (MB)" 0 --> 3.015625 + title "TypeScript - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 1500 + y-axis "Minne (MB)" 0 --> 3 line [1.9, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0] ``` -#### Dart (Snabbt språk med högt minne) +**Analys:** TypeScript är långsammast (1780ms) men visar intressant minnesprofil: startar lägre (1.9 MB) och stabiliseras snabbt på 2 MB. + +##### Scala - JVM-baserad (737ms, 2MB) ```mermaid xychart-beta - title "Dart - Resursanvändning över tid" - x-axis "Tid (ms)" 0 --> 11 - y-axis "Minne (MB)" 0 --> 10.09375 - line [9.1] + title "Scala - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 360 + y-axis "Minne (MB)" 0 --> 3 + line [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0] ``` -#### Haskell (Snabbt språk med mycket högt minne) +**Analys:** Scala på JVM visar stabil minnesanvändning men långsammare exekvering på grund av JVM startup-tid. + +##### JavaScript - Node.js prestanda (169ms, 2MB) ```mermaid xychart-beta - title "Haskell - Resursanvändning över tid" - x-axis "Tid (ms)" 0 --> 7 - y-axis "Minne (MB)" 0 --> 11.546875 - line [10.5] + title "JavaScript - Minnesanvändning över tid" + x-axis "Tid (ms)" 0 --> 500 + y-axis "Minne (MB)" 0 --> 3 + line [2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 0.0] ``` -#### C (Snabbaste språket med minimalt minne) +**Analys:** JavaScript visar stabil minnesanvändning men med en intressant minskning i slutet (0 MB) när processen avslutar. + +#### Jämförelse av minnesanvändning + +##### Snabba språk (< 50ms) - Minnesprofil ```mermaid xychart-beta - title "C - Resursanvändning över tid" - x-axis "Tid (ms)" 0 --> 5 - y-axis "Minne (MB)" 0 --> 1.0 - line [0.0] -``` - -#### Jämförelse av snabba språk - -```mermaid -xychart-beta - title "Snabba språk - Minnesanvändning över tid" - x-axis "Tid (ms)" 0 --> 35 + title "Snabba språk - Minnesanvändning jämförelse" + x-axis ["C", "Rust", "Assembly", "Go", "Nim", "Odin", "C++", "Fortran", "Swift", "Haskell", "Dart"] y-axis "Minne (MB)" 0 --> 12 - line [2.0, 2.0] - line [0.0] - line [1.4] - line [2.0, 2.0] - line [0.5] - line [9.1] - line [1.8, 1.8] - line [0.0] - line [10.5] - line [2.0, 2.0] - line [2.0, 2.0] - line [2.3] - line [0.0] - line [4.0] - line [2.0, 2.0] - line [2.0, 2.0] - line [2.0] - line [0.0] - line [2.7] + bar [0, 0, 0, 0, 0, 0, 0, 1, 0, 10.5, 9.1] ``` +**Analys:** De flesta snabba språk använder minimalt minne (0-1 MB), men Haskell och Dart sticker ut med 9-11 MB på grund av sina runtime-miljöer. + +##### Långsamma språk (> 200ms) - Minnesprofil + +```mermaid +xychart-beta + title "Långsamma språk - Minnesanvändning jämförelse" + x-axis ["Elixir", "Erlang", "R", "Scala", "TypeScript"] + y-axis "Minne (MB)" 0 --> 3 + bar [2.0, 2.0, 2.0, 2.0, 2.0] +``` + +**Analys:** Alla långsamma språk visar liknande minnesanvändning (2 MB), vilket tyder på att exekveringstiden inte direkt korrelerar med minnesanvändningen. + ### Binärstorlekar Filstorlekar för kompilerade binärer (där tillämpligt):