Erlang OTP: Distributed & Fault-Tolerant Systems Programming · 강의

Erlang 프로파일링 기법

Erlang에 내장된 프로파일링 도구를 활용하여 성능 병목을 식별하고 애플리케이션 코드를 최적화합니다.

Erlang 프로파일링 기법은(는) CoddyKit의 무료 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 강의입니다. 이것은 4개 중 1번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 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!

자주 묻는 질문

“Erlang 프로파일링 기법” 강의는 무료인가요?

네 — “Erlang 프로파일링 기법” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Erlang OTP: Distributed & Fault-Tolerant Systems Programming 강의 전체를 잠금 해제할 수 있습니다. Erlang OTP: Distributed & Fault-Tolerant Systems Programming 강의에는 총 4개의 강의가 포함되어 있습니다.

“Erlang 프로파일링 기법”에서 뭘 배우나요?

Erlang에 내장된 프로파일링 도구를 활용하여 성능 병목을 식별하고 애플리케이션 코드를 최적화합니다. 브라우저에서 직접 실행하는 실습 코드로 Erlang OTP: Distributed & Fault-Tolerant Systems Programming을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

Erlang OTP: Distributed & Fault-Tolerant Systems Programming을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 Erlang OTP: Distributed & Fault-Tolerant Systems Programming은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 1번째 강의입니다.

“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(으)로 돌아가기