Elixir og Phoenix: Skalerbar backend-udvikling · Lektion

Benchmarking og profilering af Elixir

Find flaskehalse i Deres Elixir-kode med benchmarkingværktøjer og profileringsteknikker.

Lektion 1 af 412 trin

Benchmarking og profilering af Elixir er en gratis Elixir og Phoenix: Skalerbar backend-udvikling-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Elixir og Phoenix: Skalerbar backend-udvikling, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

Ydeevne: Hastighed og effektivitet

I softwareudvikling henviser ydeevne til, hvor hurtigt og effektivt din applikation kører. Det er afgørende for en god brugeroplevelse og for håndteringen af serverressourcer.

Langsomme applikationer kan frustrere brugerne og få dem til at opgive dem. For backend-systemer kan dårlig ydeevne betyde højere infrastrukturudgifter eller manglende evne til at håndtere brugerbelastning.

Reaktionsevne: Hvor hurtigt systemet reagerer på brugerinput.
Gennemløb: Hvor mange operationer det kan håndtere over tid.
Ressourceforbrug: Hvor meget CPU, hukommelse eller netværk det bruger.

Hvad er benchmarking?

Benchmarking er processen med at måle ydeevnen for et stykke kode eller et system under bestemte betingelser. Det hjælper dig med at forstå, hvor hurtigt forskellige dele af din kode udføres.

Du bruger ofte benchmarking til at sammenligne forskellige implementeringer af den samme logik. Hvilken måde at behandle en liste på er f.eks. hurtigst? Ved at køre dem mange gange og beregne gennemsnittet af resultaterne får du pålidelige data.

Enkel manuel tidsmåling

Elixir tilbyder grundlæggende værktøjer til at måle udførelsestid. Vi kan bruge System.monotonic_time/0 og System.convert_time_unit/3 til at få en grov idé.

Lad os prøve at måle tiden for en enkel listeoperation. Tiden angives i indbyggede enheder og konverteres derefter 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ød Benchee: Elixirs benchmarkværktøj

Selvom manuel tidsmåling er nyttig, er den ikke robust nok til seriøs benchmarking. Faktorer som affaldsindsamling, CPU-belastning og opvarmningstider kan skævvride resultaterne.

Benchee er et populært Elixir-bibliotek, der er udviklet til præcis og pålidelig benchmarking. Det kører din kode mange gange, beregner statistik og præsenterer tydelige resultater.

Håndterer opvarmningsperioder.
Udfører statistisk analyse (gennemsnit, standardafvigelse).
Sammenligner nemt flere funktioner.

Første Benchee-benchmark

For at bruge Benchee vil du typisk tilføje {:benchee, "~> 1.0", only: :dev} til afhængighederne i mix.exs og køre mix deps.get.

Sådan definerer du et enkelt benchmark. Denne kode vil normalt ligge i en fil som bench/my_benchmark.exs og blive kørt 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()

Sammenligning af implementeringer

En af Benchees styrker er at sammenligne forskellige fremgangsmåder. Lad os benchmarke to måder at føje et element til en liste på: ved hjælp af ++ (sammenkædning) kontra [new_element | list] (sæt elementet foran, og vend derefter listen, hvis rækkefølgen er vigtig).

Hvis du effektivt vil føje noget til slutningen, er ++ almindeligt at bruge, men det er ofte hurtigere at sætte elementet foran. Benchee hjælper dig med at bekræfte 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()

Sådan fortolker du Benchee-resultater

Når Benchee kører, udskriver det en tabel med statistikker:

ips (iterationer pr. sekund): Hvor mange gange funktionen kan udføres på ét sekund. Højere er bedre.
gennemsnit: Den gennemsnitlige udførelsestid pr. iteration. Lavere er bedre.
std. afvigelse (standardafvigelse): Hvor meget udførelsestiderne varierer. En lavere standardafvigelse betyder mere ensartede resultater.
median: Den midterste værdi af alle udførelsestider.
hukommelsesforbrug: Hvor meget hukommelse operationen bruger.

Fokuser på ips og gennemsnit for hastighed og på std. afvigelse for ensartethed.

Hvad er profilering?

Benchmarking fortæller dig, hvor hurtigt din kode er, mens profilering fortæller dig, hvor din kode bruger sin tid. Det hjælper med at finde bestemte funktioner eller kodelinjer, der udgør flaskehalse.

En profiler holder typisk øje med:

CPU-tid: Hvilke funktioner der bruger mest processorkraft.
Hukommelsesforbrug: Hvilke dele der allokerer mest hukommelse.
Funktionskald: Kaldstakken, som viser, hvem der kalder hvem.

Det er afgørende for optimering, fordi du bør fokusere din indsats på de langsomste dele.

Grundlæggende profilering med :eprof

Elixir kører på Erlang VM og har adgang til Erlangs effektive indbyggede profiler, :eprof. Den hjælper dig med at finde CPU-hotspots i din kode.

Du bruger typisk :eprof interaktivt i en IEx-session. Den måler udførelsestiden for funktioner, der kaldes inden for en profileret blok.

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

Sådan læser du :eprof-rapporter

Efter du har kørt :eprof.analyze(), får du en rapport, der viser:

Funktionskald: Hvor mange gange hver funktion blev kaldt.
Samlet tid: Den samlede CPU-tid, der blev brugt i funktionen og dens underordnede funktioner.
Egen tid: Den CPU-tid, der blev brugt direkte i funktionen, uden kald til andre funktioner.

Se efter funktioner med høj 'egen tid' eller 'samlet tid' som mulige flaskehalse. Det viser, hvor det meste arbejde udføres.

Kontrol af ydeevneværktøjer

Du har lært om både benchmarking og profilering. Nu kan du teste din forståelse!

Besvar den i den interaktive lektion

Opsummering: Optimér din kode

Tillykke! Du har udforsket vigtige værktøjer til at forstå og forbedre ydeevnen i din Elixir-applikation.

Benchmarking (med Benchee) måler, hvor hurtigt kode kører, og sammenligner forskellige implementeringer.
Profilering (med :eprof) identificerer, hvor din kode bruger mest tid, og finder flaskehalse.

Ved at bruge disse teknikker kan du skrive mere effektive, hurtigere og skalerbare Elixir-applikationer. Bliv ved med at øve dig, så analyse af ydeevne bliver en fast del af din udviklingsproces!

Gratis at komme i gang

Lær Elixir med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Benchmarking og profilering af Elixir” gratis?

Ja — hele teksten til “Benchmarking og profilering af Elixir” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Elixir og Phoenix: Skalerbar backend-udvikling-kurset, skal du opgradere til CoddyKit PRO. Elixir og Phoenix: Skalerbar backend-udvikling-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Benchmarking og profilering af Elixir”?

Find flaskehalse i Deres Elixir-kode med benchmarkingværktøjer og profileringsteknikker. Du øver dig i Elixir og Phoenix: Skalerbar backend-udvikling med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Elixir og Phoenix: Skalerbar backend-udvikling?

Der kræves ingen tidligere erfaring. Elixir og Phoenix: Skalerbar backend-udvikling på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Benchmarking og profilering af Elixir”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Elixir og Phoenix: Skalerbar backend-udvikling-lektion?

Ja. Alle Elixir og Phoenix: Skalerbar backend-udvikling-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Elixir og Phoenix: Skalerbar backend-udvikling