Подобрете производителността на вашите Go програми, като използвате техниката за профилиране.
Профилирането е техника, която обикновено се използва в цикъла на разработка на софтуер за анализиране на ефективността на a програма, обикновено за сравнение между програми или за идентифициране на тесни места и области на подобрение за a програма. Профилирането включва измерване и анализиране на различни показатели като използване на паметта, използване на процесора, време за изпълнение и други статистики на системно ниво.
Профилирането има за цел да идентифицира части от програма, които консумират най-много ресурси, така че да може да бъде оптимизирана за по-добра производителност. Профилирането може също да помогне при отстраняване на грешки, оптимизиране на управлението на паметта и настройка на паралелността.
Профилиране в Go
В Go има много инструменти за профилиране. Някои популярни инструменти включват вградения инструмент за профилиране pprof на Go и популярни пакети на трети страни, като пакетите Go Tool Trace и Go-Torch.
The ппроф Пакетът е част от време на изпълнение пакет. The ппроф пакетът предоставя функционалност за писане на данни за профилиране по време на изпълнение във формати, които ппроф инструментът за визуализация може да интерпретира.
Ето как можете да импортирате ппроф пакет във вашите Go програми:
импортиране"ппроф"
Go предоставя няколко команди и флагове за работа с изходния код. Изпълнете следното инструмент команда за достъп до резултатите от профилиране в различни формати.
отивам инструмент ппроф
Командата извежда подробности за използването на ппроф команда.
Профилиране на процесора в Go
Профилирането на процесора измерва времето, което програмата прекарва, докато изпълнява функции. Профилирането на процесора е полезно за идентифициране на части от кода, които консумират най-много процесорно време.
The ппроф пакетът предоставя функции за събиране на CPU профили, стартиране и спиране на CPU профилиране и функция за записване на профилни данни във файлове.
Ето как да стартирате и спрете CPU профил и да запишете данните в профилиращ файл:
импортиране (
"операционна система"
"време на изпълнение/pprof"
)функосновен() {
f, err := os. Създаване ("cpu_profile.prof")
ако грешка!= нула {
паника(грешка)
}
отлагам f. Близо()грешка = pprof. Стартирайте CPUProfile (f)
ако грешка!= нула {
паника(грешка)
}
отлагам ппроф. StopCPUProfile()
// код за профилиране
}
The основен създава файл и затваря файловия поток с a отлагам изявление и Близо функция на файловия екземпляр. The Стартирайте CPUProfile стартира CPU профил и записва данните във файла, и Спрете CPUProfile затваря потока на профила с a отлагам изявление. След като стартирате и спрете профила на процесора, можете да продължите да пишете кода, който искате да анализирате.
Ето резултата от изпълнението на ппроф команда с файла на профила от програмата:
Изпълнение на ппроф команда с файл стартира интерактивна обвивка, която ви позволява да изследвате данните за профилиране. Можете да използвате команди като Горна част и списък за да видите функциите, които отнемат най-много време за изпълнение.
Профилиране на паметта в Go
Профилирането на паметта е техника, използвана за идентифициране на изтичане на памет и скъпо използване на паметта в кода чрез измерване на използването на паметта на функциите в кода.
Можете да стартирате профил на паметта с WriteHeapProfile функция. The WriteHeapProfile функцията взема екземпляр на файл и записва данните от профила във файла.
импортиране (
"операционна система"
"време на изпълнение/pprof"
)функосновен() {
f, err := os. Създаване ("mem_profile.prof")
ако грешка!= нула {
паника(грешка)
}
отлагам f. Близо()грешка = pprof. WriteHeapProfile (f)
ако грешка!= нула {
паника(грешка)
}
// код за профилиране
}
The основен функцията създава профилиращ файл и WriteHeapProfile функцията приема екземпляра на файла като аргумент и връща тип грешка при запис след запис във файла. Можете и по-нататък третирайте грешката според вашите изисквания.
Блокиране на профилиране с Go
Профилирането на блокове измерва времето за изчакване на програмата за примитиви за синхронизация, като мутекси и канали. Профилирането на блокове е полезно за идентифициране на части от кода, които могат да причинят блокиране.
The Погледни нагоре функцията връща профила с името на определен низ и Пиши на функция на Погледни нагоре записва pprof-форматиран моментен кадър на профила във файла.
Ето как можете да приложите профилиране на блокове за вашите Go програми:
импортиране (
"операционна система"
"време на изпълнение/pprof"
)функосновен() {
f, err := os. Създаване ("block_profile.prof")
ако грешка!= нула {
паника(грешка)
}
отлагам f. Близо()грешка = pprof. Погледни нагоре("блок").WriteTo (f, 0)
ако грешка!= нула {
паника(грешка)
}
// код за профилиране
}
Програмата създава файл за съхраняване на данните за профила на блока, търси блокове с Погледни нагоре функция и записва данните за профила на блока във файла.
Проследяване на профили с Go
Профилирането на проследяване е техника за измерване на изпълнението на програма, включително планиране на рутина и системни повиквания. Профилирането на проследяване е полезно за идентифициране на тесните места в производителността и разбиране на взаимодействията между различните програмни части.
The следа пакетът предоставя функции за профилиране на проследяване. Този пакет също е част от време на изпълнение пакет.
импортиране (
"операционна система"
"време на изпълнение/проследяване"
)функосновен() {
f, err := os. Създаване ("trace.out")
ако грешка!= нула {
паника(грешка)
}
отлагам f. Близо()грешка = следа. Начало (f)
ако грешка!= нула {
паника(грешка)
}
отлагам следа. Спри се()
// код за профилиране
}
Програмата създава файл за проследяване за съхраняване на данните за проследяване, стартира програмата за проследяване с Започнете функция, която приема екземпляра на файла и връща тип грешка и отлага проследяването с Спри се функция.
Go предоставя и инструменти за форматиране на изходния код. Наред с инструментите за профилиране, можете да използвате инструментите за форматиране, за да поддържате стандарти за код. The gofmt tool е вграден инструмент за форматиране, който можете да използвате, за да форматирате своя изходен код на Go въз основа на определени правила за вашите пакети.