Benchmarking i profilowanie Elixir
Zidentyfikuje Pan/Pani wąskie gardła wydajnościowe w kodzie Elixir za pomocą narzędzi do benchmarkingu i technik profilowania.
Benchmarking i profilowanie Elixir to bezpłatna lekcja Elixir & Phoenix: Scalable Backend Development na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Elixir & Phoenix: Scalable Backend Development, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Elixir & Phoenix: Scalable Backend Development zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
Performance: Speed & Efficiency
In software development, performance refers to how fast and efficiently your application runs. It's crucial for a good user experience and managing server resources.
Slow applications can frustrate users, leading to abandonment. For backend systems, poor performance can mean higher infrastructure costs or an inability to handle user loads.
- Responsiveness: How quickly the system responds to user input.
- Throughput: How many operations it can handle over time.
- Resource Usage: How much CPU, memory, or network it consumes.
What is Benchmarking?
Benchmarking is the process of measuring the performance of a piece of code or a system under specific conditions. It helps you understand how fast different parts of your code execute.
You often use benchmarking to compare different implementations of the same logic. For example, which way of processing a list is faster? By running them many times and averaging the results, you get reliable data.
Simple Manual Timing
Elixir provides basic tools to measure execution time. We can use System.monotonic_time/0 and System.convert_time_unit/3 to get a rough idea.
Let's try timing a simple list operation. The time is given in native units, then converted to microseconds.
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)Meet Benchee: Elixir's Benchmarker
While manual timing is useful, it's not robust enough for serious benchmarking. Factors like garbage collection, CPU load, and warm-up times can skew results.
Benchee is a popular Elixir library designed for accurate and reliable benchmarking. It runs your code many times, calculates statistics, and presents clear results.
- Handles warm-up periods.
- Performs statistical analysis (average, standard deviation).
- Compares multiple functions easily.
First Benchee Benchmark
To use Benchee, you'd typically add {:benchee, "~> 1.0", only: :dev} to your mix.exs dependencies and run mix deps.get.
Here's how you define a simple benchmark. This code would usually be in a file like bench/my_benchmark.exs and run with 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()Comparing Implementations
One of Benchee's strengths is comparing different approaches. Let's benchmark two ways to append an element to a list: using ++ (concatenation) vs. [new_element | list] (prepense, then reverse if order matters).
For appending to the *end* effectively, ++ is common, but prepending is often faster. Benchee helps confirm this.
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()Deciphering Benchee Results
When Benchee runs, it outputs a table of statistics:
- ips (iterations per second): How many times the function can execute in one second. Higher is better.
- average: The average execution time per iteration. Lower is better.
- std dev (standard deviation): How much the execution times vary. A lower standard deviation means more consistent results.
- median: The middle value of all execution times.
- memory usage: How much memory the operation consumes.
Focus on ips and average for speed, and std dev for consistency.
What is Profiling?
While benchmarking tells you how fast your code is, profiling tells you where your code is spending its time. It helps pinpoint specific functions or lines of code that are bottlenecks.
A profiler typically tracks:
- CPU time: Which functions consume the most processing power.
- Memory usage: Which parts allocate the most memory.
- Function calls: The call stack, showing who calls whom.
This is crucial for optimizing, as you want to focus your efforts on the slowest parts.
Basic Profiling with :eprof
Elixir, running on the Erlang VM, has access to Erlang's powerful built-in profiler, :eprof. It helps you find CPU hotspots in your code.
You typically use :eprof interactively in an IEx session. It measures the execution time of functions called within a profiled block.
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()Reading :eprof Reports
After running :eprof.analyze(), you'll get a report showing:
- Function calls: How many times each function was called.
- Total time: The total CPU time spent in that function and its children.
- Self time: The CPU time spent directly in that function, excluding calls to other functions.
Look for functions with high 'self time' or 'total time' as potential bottlenecks. This indicates where the most work is being done.
Performance Tool Check
You've learned about both benchmarking and profiling. Now, let's test your understanding!
Summary: Optimize Your Code
Congratulations! You've explored essential tools for understanding and improving your Elixir application's performance.
- Benchmarking (with Benchee) measures how fast code runs and compares different implementations.
- Profiling (with :eprof) identifies where your code spends most of its time, pinpointing bottlenecks.
By using these techniques, you can write more efficient, faster, and scalable Elixir applications. Keep practicing to make performance analysis a regular part of your development workflow!
Często zadawane pytania
Czy lekcja „Benchmarking i profilowanie Elixir” jest bezpłatna?
Tak — pełny tekst „Benchmarking i profilowanie Elixir” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Elixir & Phoenix: Scalable Backend Development, przejdź na CoddyKit PRO. Kurs Elixir & Phoenix: Scalable Backend Development zawiera 4 lekcji w sumie.
Co nauczysz się w „Benchmarking i profilowanie Elixir”?
Zidentyfikuje Pan/Pani wąskie gardła wydajnościowe w kodzie Elixir za pomocą narzędzi do benchmarkingu i technik profilowania. Ćwiczysz Elixir & Phoenix: Scalable Backend Development z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Elixir & Phoenix: Scalable Backend Development?
Nie wymagamy żadnego doświadczenia. Elixir & Phoenix: Scalable Backend Development w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Benchmarking i profilowanie Elixir”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Elixir & Phoenix: Scalable Backend Development?
Tak. Każda lekcja Elixir & Phoenix: Scalable Backend Development zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Benchmarking i profilowanie Elixir
- Monitorowanie za pomocą Telemetry i metryk
- Obsługa błędów i logowanie strukturalne
- Śledzenie rozproszone za pomocą OpenTelemetry