Forbedre ytelsen til Go-programmene dine ved å bruke profileringsteknikken.
Profilering er en teknikk som vanligvis brukes i programvareutviklingssyklusen for å analysere ytelsen til en program, vanligvis for en sammenligning mellom programmer eller for å identifisere flaskehalser og forbedringsområder for en program. Profilering innebærer å måle og analysere ulike beregninger som minnebruk, CPU-utnyttelse, utførelsestid og annen statistikk på systemnivå.
Profilering har som mål å identifisere deler av et program som bruker mest ressurser, slik at det kan optimaliseres for bedre ytelse. Profilering kan også hjelpe med feilsøking, optimalisering av minneadministrasjon og samtidig justering.
Profilering i Go
Det finnes mange verktøy for profilering i Go. Noen populære verktøy inkluderer Gos innebygde pprof-profileringsverktøy og populære tredjepartspakker som Go Tool Trace og Go-Torch-pakkene.
De pprof pakken er en del av kjøretid pakke. De pprof pakken gir funksjonalitet for å skrive kjøretidsprofileringsdata i formater som pprof visualiseringsverktøy kan tolke.
Slik kan du importere pprof pakke inn i Go-programmene dine:
import"pprof"
Go gir flere kommandoer og flagg å jobbe med kildekoden. Kjør følgende verktøy kommando for å få tilgang til profileringsresultater i ulike formater.
gå verktøy pprof
Kommandoen gir ut bruksdetaljene om pprof kommando.
CPU-profilering i Go
CPU-profilering måler tiden et program bruker på å utføre funksjoner. CPU-profilering er nyttig for å identifisere deler av koden som bruker mest CPU-tid.
De pprof pakken inneholder funksjoner for å samle CPU-profiler, starte og stoppe CPU-profilering, og en funksjon for å skrive profildata til filer.
Slik starter og stopper du en CPU-profil og skriver dataene til en profileringsfil:
import (
"os"
"runtime/pprof"
)funchoved-() {
f, feil := os. Skape("cpu_profile.prof")
hvis feil!= null {
panikk(feil)
}
utsette f. Lukk()feil = pprof. StartCPU-profil (f)
hvis feil!= null {
panikk(feil)
}
utsette pprof. StopCPUProfile()
// kode som skal profileres
}
De hoved- funksjonen oppretter en fil og lukker filstrømmen med en utsette uttalelse og Lukk funksjonen til filforekomsten. De StartCPU-profil funksjonen starter en CPU-profil og skriver dataene til filen, og StopCPU-profil lukker profilstrømmen med en utsette uttalelse. Etter å ha startet og stoppet CPU-profilen, kan du fortsette å skrive koden du vil analysere.
Her er resultatet av å kjøre pprof kommando med profilfilen fra programmet:
Kjører pprof kommando med en fil starter et interaktivt skall som lar deg utforske profileringsdataene. Du kan bruke kommandoer som topp og liste for å se funksjonene som tar mest tid å utføre.
Minneprofilering i Go
Minneprofilering er en teknikk som brukes til å identifisere minnelekkasjer og dyr minnebruk i kode ved å måle minnebruken til funksjoner i kode.
Du kan starte en minneprofil med WriteHeapProfile funksjon. De WriteHeapProfile funksjonen tar inn filforekomst og skriver profildataene til filen.
import (
"os"
"runtime/pprof"
)funchoved-() {
f, feil := os. Skape("mem_profile.prof")
hvis feil!= null {
panikk(feil)
}
utsette f. Lukk()feil = pprof. WriteHeapProfile (f)
hvis feil!= null {
panikk(feil)
}
// kode som skal profileres
}
De hoved- funksjonen oppretter en profileringsfil, og WriteHeapProfile funksjonen tar inn filforekomsten som et argument og returnerer en skrivefeiltype etter å ha skrevet til filen. Du kan videre håndtere feilen i henhold til dine krav.
Blokker profilering med Go
Blokkprofilering måler et programs ventetid for synkroniseringsprimitiver, for eksempel mutexes og kanaler. Blokkprofilering er nyttig for å identifisere deler av koden som kan forårsake blokkering.
De Se opp funksjonen returnerer profilen med navnet på en spesifisert streng, og Skrive til funksjonen til Se opp funksjonen skriver et pprof-formatert øyeblikksbilde av profilen til filen.
Slik kan du implementere blokkprofilering for Go-programmene dine:
import (
"os"
"runtime/pprof"
)funchoved-() {
f, feil := os. Skape("block_profile.prof")
hvis feil!= null {
panikk(feil)
}
utsette f. Lukk()feil = pprof. Se opp("blokkere").Skriv til (f, 0)
hvis feil!= null {
panikk(feil)
}
// kode som skal profileres
}
Programmet lager en fil for lagring av blokkprofildata, ser etter blokker med Se opp funksjon, og skriver blokkprofildataene til filen.
Spor profilering med Go
Sporingsprofilering er en teknikk for å måle utførelsen av et program, inkludert goroutineplanlegging og systemanrop. Sporingsprofilering er nyttig for å identifisere ytelsesflaskehalser og forstå interaksjonene mellom ulike programdeler.
De spore pakken inneholder funksjoner for sporingsprofilering. Denne pakken er også en del av kjøretid pakke.
import (
"os"
"runtime/trace"
)funchoved-() {
f, feil := os. Skape("spor ut")
hvis feil!= null {
panikk(feil)
}
utsette f. Lukk()feil = spor. Start (f)
hvis feil!= null {
panikk(feil)
}
utsette spore. Stoppe()
// kode som skal profileres
}
Programmet oppretter en sporingsfil for å lagre sporingsdataene, starter sporingen med Start funksjon som tar inn filforekomsten og returnerer en feiltype, og utsetter sporingen med Stoppe funksjon.
Go gir også verktøy for formatering av kildekode. Ved siden av profileringsverktøyene kan du bruke formateringsverktøyene til å opprettholde kodestandarder. De gofmt tool er et innebygd formateringsverktøy som du kan bruke til å formatere Go-kildekoden din basert på spesifiserte regler for pakkene dine.
