Erlang OTP: Distributed & Fault-Tolerant Systems Programming · 课时

Erlang 性能分析技术

使用 Erlang 内置的性能分析工具识别性能瓶颈并优化应用代码。

第 1 / 4 课11 个步骤

Erlang 性能分析技术 是 CoddyKit 上的免费 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Profile Erlang Code?

Ever wonder why your Erlang application feels a bit sluggish? That's where profiling comes in!

Profiling is like giving your code an X-ray. It helps you:

Spot performance bottlenecks.
Understand how functions spend their time.
Optimize resource usage (CPU, memory).

In Erlang, profiling is crucial for building efficient, high-performance systems.

Meet `fprof`: CPU & Memory

One of Erlang's most powerful built-in profiling tools is fprof. It's designed to give you detailed insights into how your program uses system resources.

fprof can profile:

CPU usage: Which functions are consuming the most processing time?
Memory usage: How much memory each function allocates.

It's great for deep dives into specific parts of your code.

Profiling CPU with `fprof`

Let's see fprof in action! This example creates a CPU-intensive calculation and then uses fprof to measure where the time is spent.

Run this code and observe the output, which will be the fprof report.

-module(cpu_profiler).
-export([run/0, long_calculation/1]).

% A function designed to consume CPU time
long_calculation(N) ->
    lists:foldl(fun(I, Acc) -> math:sqrt(I) + Acc end, 0.0, lists:seq(1, N)).

run() ->
    io:format("~n--- Starting fprof CPU profiling ---~n"),
    fprof:start([cpu]), % Start profiling for CPU
    _Result = long_calculation(100000), % Call the function to profile
    fprof:stop(), % Stop collecting data
    fprof:profile(), % Process collected data
    io:format("~n--- fprof CPU Report ---~n"),
    fprof:analyse({dest, user}), % Print the analysis to the console
    io:format("--- End fprof CPU Report ---~n"),
    ok.

Deciphering `fprof` Reports

The fprof report can look a bit intimidating at first! Here are the key columns to focus on:

acc (Accumulated): Total time spent in a function, including time in functions it calls.
self (Self time): Time spent directly in this function, excluding time in functions it calls. This helps pinpoint the exact bottleneck.
calls: How many times the function was called.

Look for functions with high self times to find areas for optimization.

`fprof` for Memory Usage

While we focused on CPU, fprof can also help with memory usage. By calling fprof:start([memory]), you can track memory allocation per function.

Memory profiling helps identify "memory leaks" or functions that allocate excessively large data structures, which can be critical for long-running systems.

The report structure is similar, but focuses on bytes allocated rather than CPU cycles.

`eprof`: Time-Based Profiling

Another useful tool is eprof. While fprof is very detailed, eprof provides a simpler, more high-level overview of execution times.

eprof is excellent for quickly identifying which functions take the longest to run, without the deep call-graph analysis of fprof.

It's often used for a quick check before diving into more detailed profiling.

Running an `eprof` Test

Let's use eprof to measure the execution time of a list manipulation operation. This gives a clear picture of how long the function itself takes.

Run this example and check the output for execution statistics.

-module(time_profiler).
-export([run/0, quick_operation/1]).

% A function that processes a list
quick_operation(N) ->
    lists:map(fun(I) -> I * 2 end, lists:seq(1, N)).

run() ->
    io:format("~n--- Starting eprof execution time profiling ---~n"),
    eprof:start(), % Start eprof
    _Result = quick_operation(50000), % Call the function
    eprof:stop(), % Stop collecting data
    io:format("~n--- eprof Report ---~n"),
    eprof:log({dest, user}), % Print the log to console
    eprof:stop_profiling(), % Clean up eprof
    io:format("--- End eprof Report ---~n"),
    ok.

Interpreting `eprof` Statistics

eprof output is simpler than fprof. It typically shows you:

{, , }: The function being reported.
{calls, N}: How many times this function was called.
{total, Time}: The total execution time for all calls to this function.
{average, Time}: The average execution time per call.

This helps you quickly see which functions are cumulatively taking the most time.

Basic Tracing with `dbg`

While primarily a debugging tool, dbg can also be used for basic tracing to see function calls in real-time. It's less about performance metrics and more about understanding flow.

This example shows how to set a trace on a function and then call it. The trace output typically appears directly in the shell as the code runs.

-module(dbg_example).
-export([run/0, simple_func/1]).

simple_func(X) ->
    io:format("Inside simple_func with ~p~n", [X]),
    X * 2.

run() ->
    io:format("~n--- Starting dbg trace for simple_func ---~n"),
    dbg:tracer(), % Start the tracer process
    dbg:p(all, call), % Trace all process calls (optional, but good for context)
    dbg:tp(dbg_example, simple_func, []), % Set trace pattern on simple_func/1
    io:format("Calling simple_func(5)...~n"),
    _Result = simple_func(5),
    io:format("Calling simple_func(10)...~n"),
    _Result2 = simple_func(10),
    dbg:stop_clear(), % Stop tracing and clear patterns
    io:format("--- dbg trace finished ---~n"),
    ok.

Profiling Tool Check

You've learned about Erlang's powerful profiling tools. Now, let's test your understanding!

Consider a scenario where you suspect a specific function is causing high CPU load due to complex calculations within its own body, rather than in functions it calls.

在交互式课程中回答

Profiling Power-Up!

Great job! You've taken your first steps into Erlang profiling.

We covered:

fprof: For detailed CPU and memory profiling, using self time to pinpoint bottlenecks.
eprof: For a high-level overview of function execution times (total and average).
dbg: A brief look at its use for basic function call tracing to understand program flow.

These tools are your allies in building efficient and robust Erlang applications. Keep exploring them!

免费开始

用 AI 导师学习 Erlang — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 12
课程: 48

免费开始学习查看完整课程

常见问题解答

「Erlang 性能分析技术」课时是免费的吗？

是的 — 「Erlang 性能分析技术」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程的其余内容，请升级到 CoddyKit PRO。 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程共包含 4 节课。

「Erlang 性能分析技术」这节课中我会学到什么？

使用 Erlang 内置的性能分析工具识别性能瓶颈并优化应用代码。你通过在浏览器中直接运行的动手代码来练习 Erlang OTP: Distributed & Fault-Tolerant Systems Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「Erlang 性能分析技术」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课中编写并运行代码吗？

能。每节 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Erlang OTP: Distributed & Fault-Tolerant Systems Programming