Erlang-profilingtechnieken
Gebruik de ingebouwde profilingtools van Erlang om prestatieknelpunten te identificeren en uw applicatiecode te optimaliseren.
Erlang-profilingtechnieken is een gratis Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen bevat in totaal 4 lessen.
Waarom Erlang-code profileren?
Vraagt u zich weleens af waarom uw Erlang-toepassing wat traag aanvoelt? Daar komt profilering van pas!
Profilering is alsof u uw code met röntgenstralen bekijkt. Het helpt u om:
- Prestatieknelpunten op te sporen.
- Te begrijpen hoe functies hun tijd besteden.
- Het gebruik van bronnen zoals CPU en geheugen te optimaliseren.
In Erlang is profilering cruciaal voor het bouwen van efficiënte systemen met hoge prestaties.
Maak kennis met `fprof`: CPU en geheugen
Een van de krachtigste ingebouwde profileringstools van Erlang is fprof. Deze is ontworpen om u gedetailleerd inzicht te geven in de manier waarop uw programma systeembronnen gebruikt.
Met fprof kunt u het volgende profileren:
- CPU-gebruik: Welke functies gebruiken de meeste verwerkingstijd?
- Geheugengebruik: Hoeveel geheugen elke functie toewijst.
Deze tool is uitstekend geschikt voor een grondige analyse van specifieke delen van uw code.
CPU profileren met `fprof`
Laten we fprof in actie bekijken! In dit voorbeeld wordt een CPU-intensieve berekening uitgevoerd, waarna fprof meet waar de tijd aan wordt besteed.
Voer deze code uit en bekijk de uitvoer. Dit is het fprof-rapport.
-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.`fprof`-rapporten ontcijferen
Het fprof-rapport kan er in eerste instantie wat intimiderend uitzien! Dit zijn de belangrijkste kolommen waarop u moet letten:
acc(cumulatief): De totale tijd die in een functie wordt besteed, inclusief de tijd in functies die deze aanroept.self(eigen tijd): De tijd die rechtstreeks in deze functie wordt besteed, exclusief de tijd in functies die deze aanroept. Hiermee kunt u het exacte knelpunt vinden.calls: Het aantal keer dat de functie is aangeroepen.
Zoek naar functies met hoge self-tijden om gebieden voor optimalisatie te vinden.
`fprof` voor geheugengebruik
Hoewel we ons op CPU's richtten, kan fprof ook helpen bij geheugengebruik. Door fprof:start([memory]) aan te roepen, kunt u de geheugentoewijzing per functie volgen.
Geheugenprofilering helpt bij het opsporen van "geheugenlekken" of functies die buitensporig grote gegevensstructuren toewijzen. Dit kan cruciaal zijn voor systemen die lang actief blijven.
De structuur van het rapport is vergelijkbaar, maar richt zich op toegewezen bytes in plaats van CPU-cycli.
`eprof`: tijdgebaseerde profilering
Een andere nuttige tool is eprof. Terwijl fprof zeer gedetailleerd is, biedt eprof een eenvoudiger overzicht op hoger niveau van uitvoeringstijden.
eprof is uitstekend geschikt om snel vast te stellen welke functies het langst duren, zonder de diepgaande analyse van de aanroepgrafiek van fprof.
Deze tool wordt vaak gebruikt voor een snelle controle voordat u dieper in de profilering duikt.
Een `eprof`-test uitvoeren
Laten we eprof gebruiken om de uitvoeringstijd van een bewerking voor lijstmanipulatie te meten. Dit geeft een duidelijk beeld van hoelang de functie zelf duurt.
Voer dit voorbeeld uit en controleer de uitvoer op uitvoeringsstatistieken.
-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.`eprof`-statistieken interpreteren
De uitvoer van eprof is eenvoudiger dan die van fprof. U ziet doorgaans het volgende:
{: De gerapporteerde functie., , } {calls, N}: Het aantal keer dat deze functie is aangeroepen.{total, Time}: De totale uitvoeringstijd voor alle aanroepen van deze functie.{average, Time}: De gemiddelde uitvoeringstijd per aanroep.
Zo ziet u snel welke functies bij elkaar opgeteld de meeste tijd kosten.
Basistracering met `dbg`
Hoewel dbg voornamelijk een foutopsporingstool is, kunt u deze ook gebruiken voor basistracering om functieaanroepen in realtime te bekijken. Het gaat hierbij minder om prestatiestatistieken en meer om inzicht in de programmastroom.
In dit voorbeeld ziet u hoe u een trace op een functie instelt en deze vervolgens aanroept. De trace-uitvoer verschijnt doorgaans rechtstreeks in de shell terwijl de code wordt uitgevoerd.
-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.Controle van de profileringstools
U hebt geleerd over de krachtige profileringstools van Erlang. Laten we nu uw begrip testen!
Denk aan een situatie waarin u vermoedt dat een specifieke functie een hoge CPU-belasting veroorzaakt door complexe berekeningen in de functie zelf, en niet in functies die deze aanroept.
Profilering naar een hoger niveau!
Goed gedaan! U hebt uw eerste stappen in Erlang-profilering gezet.
We hebben het volgende behandeld:
fprof: Voor gedetailleerde CPU- en geheugenprofilering, waarbij u met deself-tijd knelpunten kunt vinden.eprof: Voor een overzicht op hoog niveau van uitvoeringstijden van functies (totalenaverage).dbg: Een korte kennismaking met het gebruik ervan voor basistracering van functieaanroepen om inzicht te krijgen in de programmastroom.
Deze tools helpen u bij het bouwen van efficiënte en robuuste Erlang-toepassingen. Blijf ze verkennen!
Leer Erlang met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Erlang-profilingtechnieken” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen, waaronder “Erlang-profilingtechnieken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen bevat in totaal 4 lessen.
Wat leer ik in “Erlang-profilingtechnieken”?
Gebruik de ingebouwde profilingtools van Erlang om prestatieknelpunten te identificeren en uw applicatiecode te optimaliseren. Je oefent met Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen te beginnen?
Ervaring vooraf is niet nodig. Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Erlang-profilingtechnieken”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen?
Ja. Elke les over Erlang OTP: programmeren van gedistribueerde en fouttolerante systemen bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Erlang-profilingtechnieken
- Gedistribueerde systemen traceren en debuggen
- Integratie van metrics en monitoring
- Geheugenanalyse en garbagecollection-tuning