Elixir benchmarken en profileren
Identificeer prestatieknelpunten in uw Elixir-code met benchmarktools en profileringstechnieken.
Elixir benchmarken en profileren is een gratis Elixir en Phoenix: schaalbare backendontwikkeling-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Elixir en Phoenix: schaalbare backendontwikkeling. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.
Prestaties: snelheid en efficiëntie
In softwareontwikkeling verwijst performance naar hoe snel en efficiënt je applicatie werkt. Dit is belangrijk voor een goede gebruikerservaring en voor het beheren van serverbronnen.
Trage applicaties kunnen gebruikers frustreren, waardoor ze afhaken. Voor backendsystemen kunnen slechte prestaties leiden tot hogere infrastructuurkosten of het onvermogen om gebruikersbelasting te verwerken.
- Responsiviteit: Hoe snel het systeem reageert op invoer van de gebruiker.
- Doorvoer: Hoeveel bewerkingen het in de loop van de tijd kan verwerken.
- Brongebruik: Hoeveel CPU, geheugen of netwerk het verbruikt.
Wat is benchmarking?
Benchmarking is het meten van de prestaties van een stuk code of een systeem onder specifieke omstandigheden. Hiermee krijg je inzicht in hoe snel verschillende onderdelen van je code worden uitgevoerd.
Je gebruikt benchmarking vaak om verschillende implementaties van dezelfde logica te vergelijken. Welke manier om een lijst te verwerken is bijvoorbeeld sneller? Door ze vaak uit te voeren en de resultaten te middelen, krijg je betrouwbare gegevens.
Eenvoudige handmatige tijdmeting
Elixir biedt eenvoudige hulpmiddelen om de uitvoeringstijd te meten. We kunnen System.monotonic_time/0 en System.convert_time_unit/3 gebruiken om een globale indruk te krijgen.
Laten we de tijd meten van een eenvoudige lijstbewerking. De tijd wordt gegeven in systeemeigen eenheden en daarna omgerekend naar microseconden.
defmodule MyTimer do
def run_and_time(fun) do
start_time = System.monotonic_time(:nanosecond)
result = fun.()
end_time = System.monotonic_time(:nanosecond)
duration = System.convert_time_unit(end_time - start_time, :nanosecond, :microsecond)
IO.puts "Function returned: #{inspect(result)}"
IO.puts "Execution took: #{duration} µs"
end
def example_task do
1..1_000_000 |> Enum.map(fn x -> x * 2 end)
end
end
# To run this in an IEx session or script:
MyTimer.run_and_time(fn -> MyTimer.example_task() end)Maak kennis met Benchee: de benchmarktool van Elixir
Hoewel handmatige tijdmeting nuttig is, is deze niet robuust genoeg voor serieuze benchmarking. Factoren zoals garbagecollection, CPU-belasting en opwarmtijden kunnen de resultaten vertekenen.
Benchee is een populaire Elixir-bibliotheek voor nauwkeurige en betrouwbare benchmarking. Deze voert je code vele malen uit, berekent statistieken en presenteert duidelijke resultaten.
- Verwerkt opwarmperioden.
- Voert statistische analyses uit (gemiddelde, standaardafwijking).
- Vergelijkt eenvoudig meerdere functies.
Eerste benchmark met Benchee
Om Benchee te gebruiken, voeg je doorgaans {:benchee, "~> 1.0", only: :dev} toe aan de afhankelijkheden in mix.exs en voer je mix deps.get uit.
Zo definieer je een eenvoudige benchmark. Deze code staat meestal in een bestand zoals bench/my_benchmark.exs en wordt uitgevoerd met mix bench.
defmodule MyBenchmarks do
use Benchee.Benchmark
def run do
Benchee.run %{
"list_sum" => fn -> Enum.sum(1..10_000) end
},
time: 1,
memory_time: 0.1, # Shorten for quick example
print: [fast_warning: false]
end
end
# To run this directly (after adding Benchee to mix.exs and running mix deps.get):
# MyBenchmarks.run()Implementaties vergelijken
Een van de sterke punten van Benchee is het vergelijken van verschillende aanpakken. Laten we twee manieren benchmarken om een element aan een lijst toe te voegen: met ++ (concatenatie) tegenover [new_element | list] (vooraan toevoegen en de lijst daarna omkeren als de volgorde belangrijk is).
Om effectief iets aan het *einde* toe te voegen, wordt ++ vaak gebruikt, maar vooraan toevoegen is meestal sneller. Benchee helpt dit te bevestigen.
defmodule ListAppendBenchmarks do
use Benchee.Benchmark
def run do
long_list = Enum.to_list(1..10_000)
new_element = 10_001
Benchee.run %{
"append_with_++" => fn -> long_list ++ [new_element] end,
"prepend_and_reverse" => fn -> [new_element | long_list] |> Enum.reverse() end
},
time: 1,
memory_time: 0.1
end
end
# ListAppendBenchmarks.run()Benchee-resultaten interpreteren
Wanneer Benchee wordt uitgevoerd, geeft het een tabel met statistieken:
- ips (iteraties per seconde): Hoe vaak de functie in één seconde kan worden uitgevoerd. Hoger is beter.
- average: De gemiddelde uitvoeringstijd per iteratie. Lager is beter.
- std dev (standaardafwijking): Hoe sterk de uitvoeringstijden variëren. Een lagere standaardafwijking betekent consistentere resultaten.
- median: De middelste waarde van alle uitvoeringstijden.
- memory usage: Hoeveel geheugen de bewerking gebruikt.
Let voor snelheid op ips en average, en voor consistentie op std dev.
Wat is profileren?
Waar benchmarking aangeeft hoe snel je code is, laat profileren zien waar je code tijd besteedt. Het helpt specifieke functies of coderegels te vinden die knelpunten vormen.
Een profiler houdt doorgaans het volgende bij:
- CPU-tijd: Welke functies de meeste rekenkracht gebruiken.
- Geheugengebruik: Welke onderdelen het meeste geheugen toewijzen.
- Functieaanroepen: De aanroepstack, die laat zien welke functie welke andere functie aanroept.
Dit is essentieel voor optimalisatie, omdat je je inspanningen wilt richten op de traagste onderdelen.
Basisprofilering met :eprof
Elixir, dat op de Erlang-VM draait, heeft toegang tot de krachtige ingebouwde profiler van Erlang, :eprof. Hiermee vind je CPU-knelpunten in je code.
Je gebruikt :eprof meestal interactief in een IEx-sessie. Het meet de uitvoeringstijd van functies die binnen een geprofileerd codeblok worden aangeroepen.
defmodule MyProfiledCode do
def slow_function(n) do
Enum.map(1..n, fn x -> :math.pow(x, 0.5) |> round end)
end
def entry_point do
slow_function(5_000)
end
end
# To profile in IEx:
# :eprof.start_profiling()
# MyProfiledCode.entry_point()
# :eprof.stop_profiling()
# :eprof.analyze():eprof-rapporten lezen
Na het uitvoeren van :eprof.analyze() krijg je een rapport met:
- Functieaanroepen: Hoe vaak elke functie is aangeroepen.
- Totale tijd: De totale CPU-tijd die in die functie en de onderliggende functies is besteed.
- Eigen tijd: De CPU-tijd die rechtstreeks in die functie is besteed, exclusief aanroepen van andere functies.
Let op functies met een hoge 'eigen tijd' of 'totale tijd' als mogelijke knelpunten. Daaraan zie je waar het meeste werk wordt uitgevoerd.
Controle van prestatietools
Je hebt geleerd over zowel benchmarking als profileren. Nu is het tijd om je inzicht te testen!
Samenvatting: optimaliseer je code
Gefeliciteerd! Je hebt essentiële tools verkend om de prestaties van je Elixir-toepassing te begrijpen en te verbeteren.
- Benchmarking (met Benchee) meet hoe snel code wordt uitgevoerd en vergelijkt verschillende implementaties.
- Profileren (met :eprof) laat zien waar je code de meeste tijd besteedt en brengt knelpunten aan het licht.
Met deze technieken kun je efficiëntere, snellere en schaalbare Elixir-toepassingen schrijven. Blijf oefenen, zodat prestatieanalyse een vast onderdeel van je ontwikkelproces wordt!
Leer Elixir met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Elixir benchmarken en profileren” gratis?
Ja — de volledige tekst van “Elixir benchmarken en profileren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Elixir en Phoenix: schaalbare backendontwikkeling wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Elixir en Phoenix: schaalbare backendontwikkeling bevat in totaal 4 lessen.
Wat leer ik in “Elixir benchmarken en profileren”?
Identificeer prestatieknelpunten in uw Elixir-code met benchmarktools en profileringstechnieken. Je oefent met Elixir en Phoenix: schaalbare backendontwikkeling door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Elixir en Phoenix: schaalbare backendontwikkeling te beginnen?
Ervaring vooraf is niet nodig. Elixir en Phoenix: schaalbare backendontwikkeling op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Elixir benchmarken en profileren”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Elixir en Phoenix: schaalbare backendontwikkeling?
Ja. Elke les over Elixir en Phoenix: schaalbare backendontwikkeling bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Elixir benchmarken en profileren
- Monitoring met Telemetry en metrieken
- Foutafhandeling en gestructureerde logging
- Distributed tracing met OpenTelemetry