Elixir og Phoenix: Skalerbar backendutvikling · leksjon

Benchmarking og profilering av Elixir

Identifiser ytelsesflaskehalser i Elixir-koden din ved hjelp av benchmarkverktøy og profileringsteknikker.

Leksjon 1 av 412 trinn

Benchmarking og profilering av Elixir er en gratis leksjon i Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Elixir og Phoenix: Skalerbar backendutvikling, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

Ytelse: Hastighet og effektivitet

Innen programvareutvikling viser ytelse til hvor raskt og effektivt applikasjonen kjører. Dette er avgjørende for en god brukeropplevelse og for håndtering av serverressurser.

Treg programvare kan frustrere brukerne og føre til at de slutter å bruke den. For backend-systemer kan dårlig ytelse føre til høyere infrastrukturkostnader eller manglende evne til å håndtere belastningen fra brukerne.

Responsivitet: Hvor raskt systemet svarer på brukerinput.
Gjennomstrømning: Hvor mange operasjoner det kan håndtere over tid.
Ressursbruk: Hvor mye CPU, minne eller nettverk det bruker.

Hva er benchmarking?

Benchmarking er prosessen med å måle ytelsen til et kodestykke eller et system under bestemte forhold. Det hjelper Dem å forstå hvor raskt ulike deler av koden kjører.

Benchmarking brukes ofte til å sammenligne ulike implementasjoner av samme logikk. Hvilken måte å behandle en liste på er for eksempel raskest? Ved å kjøre dem mange ganger og beregne gjennomsnittet får De pålitelige data.

Enkel manuell tidsmåling

Elixir tilbyr grunnleggende verktøy for å måle kjøretid. Vi kan bruke System.monotonic_time/0 og System.convert_time_unit/3 for å få en grov idé.

La oss prøve å ta tiden på en enkel listeoperasjon. Tiden oppgis i opprinnelige enheter og konverteres deretter til 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 benchmarkverktøy

Selv om manuell tidsmåling er nyttig, er den ikke robust nok for seriøs benchmarking. Faktorer som søppelrydding, CPU-belastning og oppvarmingstid kan forvrenge resultatene.

Benchee er et populært Elixir-bibliotek som er utviklet for nøyaktig og pålitelig benchmarking. Det kjører koden mange ganger, beregner statistikk og presenterer tydelige resultater.

Håndterer oppvarmingsperioder.
Utfører statistisk analyse (gjennomsnitt, standardavvik).
Sammenligner enkelt flere funksjoner.

Den første Benchee-benchmarken

For å bruke Benchee vil De vanligvis legge til {:benchee, "~> 1.0", only: :dev} i avhengighetene i mix.exs og kjøre mix deps.get.

Slik definerer De en enkel benchmark. Denne koden vil vanligvis ligge i en fil som bench/my_benchmark.exs og kjøres 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()

Sammenligne implementasjoner

En av Benchee sine styrker er å sammenligne ulike fremgangsmåter. La oss måle ytelsen til to måter å legge et element til i en liste på: ved å bruke ++ (konkatenering) kontra [new_element | list] (legg til først, og reverser deretter hvis rekkefølgen er viktig).

For å legge til effektivt på *slutten* er ++ vanlig, men det er ofte raskere å legge til først. Benchee hjelper deg med å bekrefte dette.

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()

Tolkning av Benchee-resultater

Når Benchee kjører, skriver det ut en tabell med statistikk:

ips (iterasjoner per sekund): Hvor mange ganger funksjonen kan kjøres i løpet av ett sekund. Høyere er bedre.
average: Gjennomsnittlig kjøretid per iterasjon. Lavere er bedre.
std dev (standardavvik): Hvor mye kjøretidene varierer. Et lavere standardavvik betyr mer konsistente resultater.
median: Middelverdien av alle kjøretidene.
memory usage: Hvor mye minne operasjonen bruker.

Fokuser på ips og average for hastighet, og på std dev for konsistens.

Hva er profilering?

Mens ytelsesmåling forteller deg hvor rask koden din er, forteller profilering deg hvor koden bruker tiden sin. Det hjelper deg med å finne bestemte funksjoner eller kodelinjer som utgjør flaskehalser.

En profilerer sporer vanligvis:

CPU-tid: Hvilke funksjoner som bruker mest prosesseringskraft.
Minnebruk: Hvilke deler som allokerer mest minne.
Funksjonskall: Kallstakken, som viser hvem som kaller hvem.

Dette er avgjørende for optimalisering, siden du bør konsentrere innsatsen om de tregeste delene.

Grunnleggende profilering med :eprof

Elixir, som kjører på Erlang VM, har tilgang til Erlangs kraftige innebygde profilerer, :eprof. Den hjelper deg med å finne CPU-flaskehalser i koden.

Vanligvis bruker du :eprof interaktivt i en IEx-økt. Den måler kjøretiden til funksjoner som kalles i en profilert kodeblokk.

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()

Lese :eprof-rapporter

Etter at du har kjørt :eprof.analyze(), får du en rapport som viser:

Function calls: Hvor mange ganger hver funksjon ble kalt.
Total time: Den totale CPU-tiden som ble brukt i funksjonen og underfunksjonene den kaller.
Self time: CPU-tiden som ble brukt direkte i funksjonen, uten kall til andre funksjoner.

Se etter funksjoner med høy «self time» eller «total time» som mulige flaskehalser. Dette viser hvor mesteparten av arbeidet blir utført.

Kontroll av ytelsesverktøy

Du har lært om både ytelsesmåling og profilering. Nå skal vi teste forståelsen din!

Besvar den i den interaktive leksjonen

Oppsummering: Optimaliser koden din

Gratulerer! Du har utforsket viktige verktøy for å forstå og forbedre ytelsen til Elixir-applikasjonen din.

Ytelsesmåling (med Benchee) måler hvor raskt koden kjører og sammenligner ulike implementasjoner.
Profilering (med :eprof) finner ut hvor koden bruker mest tid, og identifiserer flaskehalser.

Ved å bruke disse teknikkene kan du skrive mer effektive, raskere og skalerbare Elixir-applikasjoner. Fortsett å øve, slik at ytelsesanalyse blir en naturlig del av arbeidsflyten i utviklingen din!

Gratis å komme i gang

Lær deg Elixir med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Benchmarking og profilering av Elixir» gratis?

Ja – hele teksten i «Benchmarking og profilering av Elixir» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Elixir og Phoenix: Skalerbar backendutvikling-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Elixir og Phoenix: Skalerbar backendutvikling inneholder totalt 4 leksjoner.

Hva lærer jeg i «Benchmarking og profilering av Elixir»?

Identifiser ytelsesflaskehalser i Elixir-koden din ved hjelp av benchmarkverktøy og profileringsteknikker. Du øver på Elixir og Phoenix: Skalerbar backendutvikling med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Elixir og Phoenix: Skalerbar backendutvikling?

Ingen tidligere erfaring er nødvendig. Elixir og Phoenix: Skalerbar backendutvikling på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Benchmarking og profilering av Elixir»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Elixir og Phoenix: Skalerbar backendutvikling-leksjonen?

Ja. Alle Elixir og Phoenix: Skalerbar backendutvikling-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Elixir og Phoenix: Skalerbar backendutvikling