Benchmarking och profilering av Elixir
Identifiera prestandaflaskhalsar i din Elixir-kod med hjälp av benchmarkingverktyg och profileringstekniker.
Benchmarking och profilering av Elixir är en gratis lektion i Elixir och Phoenix: skalbar backendutveckling på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Elixir och Phoenix: skalbar backendutveckling, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Elixir och Phoenix: skalbar backendutveckling innehåller totalt 4 lektioner.
Prestanda: snabbhet och effektivitet
Inom programvaruutveckling syftar prestanda på hur snabbt och effektivt applikationen körs. Det är avgörande för en bra användarupplevelse och för hanteringen av serverresurser.
Långsamma applikationer kan frustrera användare och leda till att de lämnar dem. För backend-system kan dålig prestanda innebära högre infrastrukturkostnader eller att systemet inte klarar användarbelastningen.
- Responsivitet: Hur snabbt systemet svarar på användarens inmatning.
- Genomströmning: Hur många operationer det kan hantera över tid.
- Resursanvändning: Hur mycket CPU, minne eller nätverk det förbrukar.
Vad är benchmarking?
Benchmarking är processen att mäta prestandan hos en koddel eller ett system under specifika förhållanden. Det hjälper dig att förstå hur snabbt olika delar av koden körs.
Benchmarking används ofta för att jämföra olika implementationer av samma logik. Vilket sätt att bearbeta en lista är till exempel snabbast? Genom att köra dem många gånger och beräkna medelvärdet av resultaten får du tillförlitliga data.
Enkel manuell tidtagning
Elixir tillhandahåller grundläggande verktyg för att mäta körningstid. Vi kan använda System.monotonic_time/0 och System.convert_time_unit/3 för att få en ungefärlig uppfattning.
Vi provar att mäta tiden för en enkel listoperation. Tiden anges i inbyggda enheter och konverteras sedan till mikrosekunder.
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)Möt Benchee: Elixirs benchmarkverktyg
Manuell tidtagning är användbar, men inte tillräckligt robust för seriös benchmarking. Faktorer som skräpsamling, CPU-belastning och uppvärmningstider kan snedvrida resultaten.
Benchee är ett populärt Elixir-bibliotek som är utformat för korrekt och tillförlitlig benchmarking. Det kör koden många gånger, beräknar statistik och presenterar tydliga resultat.
- Hanterar uppvärmningsperioder.
- Utför statistisk analys (medelvärde, standardavvikelse).
- Jämför enkelt flera funktioner.
Det första Benchee-benchmarktestet
För att använda Benchee lägger du vanligtvis till {:benchee, "~> 1.0", only: :dev} bland beroendena i mix.exs och kör mix deps.get.
Så här definierar du ett enkelt benchmarktest. Den här koden skulle vanligtvis finnas i en fil som bench/my_benchmark.exs och köras med 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()Jämföra implementationer
En av Benchees styrkor är att jämföra olika tillvägagångssätt. Låt oss mäta prestandan för två sätt att lägga till ett element i en lista: med ++ (konkatenering) respektive [new_element | list] (lägg till först och vänd sedan listan om ordningen spelar roll).
För att effektivt lägga till sist är ++ vanligt, men det är ofta snabbare att lägga till först. Benchee hjälper er att bekräfta detta.
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()Tolka Benchee-resultat
När Benchee körs skriver det ut en tabell med statistik:
- ips (iterationer per sekund): Hur många gånger funktionen kan köras på en sekund. Högre är bättre.
- average: Den genomsnittliga körtiden per iteration. Lägre är bättre.
- std dev (standardavvikelse): Hur mycket körtiderna varierar. En lägre standardavvikelse innebär jämnare resultat.
- median: Det mittersta värdet av alla körtider.
- memory usage: Hur mycket minne operationen använder.
Fokusera på ips och average för hastighet, och på std dev för jämnhet.
Vad är profilering?
Medan prestandamätning talar om för er hur snabbt koden körs, visar profilering var koden tillbringar sin tid. Det hjälper er att hitta specifika funktioner eller kodrader som utgör flaskhalsar.
Ett profileringsverktyg följer vanligtvis:
- CPU-tid: Vilka funktioner som använder mest processorkraft.
- Min användning: Vilka delar som allokerar mest minne.
- Funktionsanrop: Anropsstacken, som visar vem som anropar vem.
Detta är avgörande vid optimering, eftersom ni bör fokusera era insatser på de långsammaste delarna.
Grundläggande profilering med :eprof
Elixir körs på Erlang VM och har tillgång till Erlangs kraftfulla inbyggda profileringsverktyg, :eprof. Det hjälper er att hitta CPU-hotspots i koden.
Vanligtvis använder ni :eprof interaktivt i en IEx-session. Det mäter körtiden för funktioner som anropas i ett profilerat kodblock.
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()Läsa :eprof-rapporter
Efter att ni har kört :eprof.analyze() får ni en rapport som visar:
- Funktionsanrop: Hur många gånger varje funktion anropades.
- Total tid: Den totala CPU-tiden som tillbringades i funktionen och dess underordnade funktioner.
- Egen tid: CPU-tiden som tillbringades direkt i funktionen, utan anrop till andra funktioner.
Leta efter funktioner med hög ”egen tid” eller ”total tid” som möjliga flaskhalsar. Det visar var det mesta arbetet utförs.
Kontroll av prestandaverktyg
Ni har lärt er om både prestandamätning och profilering. Nu testar vi era kunskaper!
Sammanfattning: Optimera koden
Grattis! Ni har utforskat viktiga verktyg för att förstå och förbättra prestandan i era Elixir-applikationer.
- Prestandamätning (med Benchee) mäter hur snabbt koden körs och jämför olika implementationer.
- Profilering (med :eprof) visar var koden tillbringar mest tid och identifierar flaskhalsar.
Med dessa tekniker kan ni skriva effektivare, snabbare och mer skalbara Elixir-applikationer. Fortsätt öva så att prestandaanalys blir en naturlig del av ert utvecklingsarbete!
Lär dig Elixir med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Benchmarking och profilering av Elixir” gratis?
Ja – hela texten till ”Benchmarking och profilering av Elixir” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Elixir och Phoenix: skalbar backendutveckling, kan Ni uppgradera till CoddyKit PRO. Kursen i Elixir och Phoenix: skalbar backendutveckling innehåller totalt 4 lektioner.
Vad lär jag mig i ”Benchmarking och profilering av Elixir”?
Identifiera prestandaflaskhalsar i din Elixir-kod med hjälp av benchmarkingverktyg och profileringstekniker. Ni övar på Elixir och Phoenix: skalbar backendutveckling med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Elixir och Phoenix: skalbar backendutveckling?
Du behöver inga förkunskaper. Utbildningen i Elixir och Phoenix: skalbar backendutveckling på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Benchmarking och profilering av Elixir”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Elixir och Phoenix: skalbar backendutveckling-lektionen?
Ja. Varje Elixir och Phoenix: skalbar backendutveckling-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Benchmarking och profilering av Elixir
- Övervakning med Telemetry och mätvärden
- Felhantering och strukturerad loggning
- Distribuerad spårning med OpenTelemetry