АнглийскийФранцузскийНемецкийИтальянскийПортугальскийРусскийИспанский

Значок OnWorks

mips64el-linux-gnuabi64-gcov-5 - Интернет в облаке

Запустите mips64el-linux-gnuabi64-gcov-5 в бесплатном хостинг-провайдере OnWorks через Ubuntu Online, Fedora Online, онлайн-эмулятор Windows или онлайн-эмулятор MAC OS.

Это команда mips64el-linux-gnuabi64-gcov-5, которую можно запустить в бесплатном хостинг-провайдере OnWorks, используя одну из наших многочисленных бесплатных онлайн-рабочих станций, таких как Ubuntu Online, Fedora Online, онлайн-эмулятор Windows или онлайн-эмулятор MAC OS.

ПРОГРАММА:

ИМЯ


gcov - инструмент тестирования покрытия

СИНТАКСИС


гков [-v|--версия] [-h|--Помогите]
[-a|--all-блоки]
[-b|- ветвь-вероятности]
[-c|- количество филиалов]
[-d|--display-прогресс]
[-f|--функции-резюме]
[-i|- промежуточный формат]
[-l|--длинные имена файлов]
[-m|--распутанные-имена]
[-n|--нет вывода]
[-o|--объект-каталог каталог | файл]
[-p|--preserve-пути]
[-r|- только относительный]
[-s|--исходный префикс каталог]
[-u|--unconditional-ветви]
файлов

ОПИСАНИЕ


gcov это программа тестового покрытия. Используйте его совместно с GCC, чтобы анализировать свои программы, чтобы
помочь создать более эффективный и быстро работающий код и обнаружить непроверенные части вашего
программа. Вы можете использовать gcov как инструмент профилирования, который поможет определить, где ваша оптимизация
усилия лучше всего повлияют на ваш код. Вы также можете использовать gcov вместе с другим профилированием
инструмент, гпроф, чтобы оценить, какие части вашего кода используют наибольшее количество вычислительного времени.

Инструменты профилирования помогают анализировать производительность вашего кода. Используя профилировщик, такой как gcov
or гпроф, вы можете узнать базовую статистику производительности, например:

* как часто выполняется каждая строка кода

* какие строки кода на самом деле выполняются

* сколько вычислительного времени использует каждый раздел кода

Как только вы узнаете эти вещи о том, как работает ваш код при компиляции, вы можете посмотреть на каждый
module, чтобы увидеть, какие модули следует оптимизировать. gcov помогает определить, где работать
по оптимизации.

Разработчики программного обеспечения также используют тестирование покрытия вместе с тестовыми наборами, чтобы убедиться, что
программное обеспечение на самом деле достаточно хорошо для выпуска. Тестовые наборы могут проверить, что программа
работает как положено; программа покрытия проверяет, какая часть программы выполняется
набор тестов. Затем разработчики могут определить, какие типы тестов нужно добавить в
наборы тестов для создания как лучшего тестирования, так и лучшего конечного продукта.

Вам следует скомпилировать свой код без оптимизации, если вы планируете использовать gcov поскольку
оптимизация путем объединения нескольких строк кода в одну функцию может не дать вам так много
информации, так как вам нужно искать "горячие точки", где код использует много
компьютерное время. Точно так же, потому что gcov накапливает статистику построчно (на самом низком
разрешение), он лучше всего работает со стилем программирования, который помещает только один оператор в каждый
линия. Если вы используете сложные макросы, которые расширяются до циклов или других управляющих структур,
статистика менее полезна - они сообщают только о строке, где вызывается макрос
появляется. Если ваши сложные макросы ведут себя как функции, вы можете заменить их встроенными
функции для решения этой проблемы.

gcov создает файл журнала с именем исходный файл.gcov который указывает, сколько раз каждая строка
исходный файл исходный файл.c выполнил. Вы можете использовать эти файлы журналов вместе с гпроф в
помощь в настройке производительности ваших программ. гпроф дает вам информацию о времени
можно использовать вместе с информацией, полученной от gcov.

gcov работает только с кодом, скомпилированным с помощью GCC. Он не совместим с любым другим профилированием.
или механизм тестового покрытия.

ОПЦИИ


-h
--Помогите
Показать справку об использовании gcov (на стандартном выходе) и выйти, не выполняя никаких действий.
дальнейшая обработка.

-v
--версия
Отобразить gcov номер версии (в стандартном выводе) и выйти, не выполняя никаких действий.
дальнейшая обработка.

-a
--all-блоки
Запишите индивидуальный счетчик выполнения для каждого базового блока. Обычно gcov выводит
выполнение считается только для основных блоков строки. С помощью этой опции вы можете
определить, не выполняются ли блоки в одной строке.

-b
- ветвь-вероятности
Запишите частоту ветвления в выходной файл и запишите сводную информацию ветвления в
стандартный вывод. Эта опция позволяет вам увидеть, как часто каждая ветвь вашей программы
был взят. Безусловные переходы не будут отображаться, если только -u предоставляется вариант.

-c
- количество филиалов
Запишите частоту ветвей как количество взятых ветвей, а не в процентах
взятых веток.

-n
--нет вывода
Не создавайте gcov выходной файл.

-l
--длинные имена файлов
Создавайте длинные имена для включаемых исходных файлов. Например, если заголовочный файл хх
содержит код и был включен в файл acзатем работает gcov в файле ac
создаст выходной файл с именем ac ## xhgcov вместо xhgcov, Это может быть
полезно, если хх включен в несколько исходных файлов, и вы хотите увидеть отдельные
взносы. Если вы используете -p опция, включающие и включаемые имена файлов
будут полными путями.

-p
--preserve-пути
Сохранять полную информацию о пути в именах сгенерированных .gcov файлы. Без
В этом случае используется только компонент имени файла. С этой опцией все каталоги
используются, с / символы переведены на # персонажи, . компоненты каталога удалены
и несъемный .. компоненты переименованы в ^. Это полезно, если исходные файлы находятся в
несколько разных каталогов.

-r
- только относительный
Выводить информацию только об исходных файлах с относительным путем (после источника
префикс elision). Абсолютные пути обычно представляют собой файлы заголовков системы и охват любого
встроенные функции там обычно неинтересны.

-f
--функции-резюме
Вывод сводки для каждой функции в дополнение к сводке на уровне файла.

-o каталог | файл
--объект-каталог каталог
- объект-файл файл
Укажите либо каталог, содержащий файлы данных gcov, либо путь к объекту.
.gcnoи .gcda файлы данных ищутся с использованием этой опции. Если каталог
указано, файлы данных находятся в этом каталоге и названы по имени входного файла,
без его расширения. Если здесь указан файл, файлы данных будут названы в честь
этот файл без его расширения.

-s каталог
--исходный префикс каталог
Префикс для имен исходных файлов, который необходимо удалить при создании файлов выходного покрытия.
Эта опция полезна при построении в отдельном каталоге и пути к
исходный каталог не требуется при определении имен выходных файлов. Обратите внимание, что это
Обнаружение префикса применяется до определения, является ли исходный файл абсолютным.

-u
--unconditional-ветви
Если указаны вероятности ветвлений, включите в них вероятности безусловных ветвей.
Безусловные переходы обычно не интересны.

-d
--display-прогресс
Отобразите прогресс на стандартном выводе.

-i
- промежуточный формат
Выведите файл gcov в удобном для анализа промежуточном текстовом формате, который может использоваться Лков
или другие инструменты. На выходе получается одиночный .gcov файл на .gcda файл. Нет исходного кода
требуется.

Формат промежуточного .gcov файл представляет собой обычный текст с одной записью в строке

файл:
функция: , ,
lcount: ,
ветвь: ,

Где является
notexec (ветвь не выполнена)
взято (Отделение выполнено и взято)
nottaken (ветвь выполнена, но не взята)

Может быть несколько записи в промежуточный gcov
файл. Все записи после относятся к этому исходному файлу
до следующего Вход.

Вот пример, когда -i используется в сочетании с -b опции:

файл: array.cc
функция: 11,1, _Z3sumRKSt6vectorIPiSaIS0_EE
функция: 22,1, главная
кол-во: 11,1
кол-во: 12,1
кол-во: 14,1
филиал: 14, занято
кол-во: 26,1
ветка: 28, не принято

-m
--распутанные-имена
Отображать в выводе разобранные имена функций. По умолчанию отображается искаженная функция.
имена.

gcov должен запускаться с текущим каталогом так же, как когда вы вызывали
компилятор. В противном случае он не сможет найти исходные файлы. gcov производит файлы
под названием mangledname.gcov в текущем каталоге. Они содержат информацию о покрытии
исходного файла, которому они соответствуют. Один .gcov файл создается для каждого источника (или
header) файл, содержащий код, который был скомпилирован для создания файлов данных. В
искаженное имя часть имени выходного файла обычно является просто именем исходного файла, но может
быть чем-то более сложным, если -l or -p даны варианты. Обратитесь к этим вариантам
для получения информации.

Если вы вызовете gcov с несколькими входными файлами вклад каждого входного файла
подытожил. Обычно вы вызываете его с тем же списком файлов, что и последняя ссылка на
ваш исполняемый файл.

.gcov файлы содержат : разделенные поля вместе с исходным кодом программы. Формат
is

: :

Дополнительная информация о блоке может следовать за каждой строкой, если запрашивается параметром командной строки.
Execution_count is - для строк, не содержащих кода. Отмечены невыполненные строки #####
or ====, в зависимости от того, достижимы ли они по неисключительным путям или только
исключительные пути, такие как обработчики исключений C ++ соответственно.

Некоторые строки информации в начале номер строчки нуля. Эти строки преамбулы
формы

-: 0: :

Порядок и количество этих строк преамбулы будут увеличены как gcov разработка
прогрессирует --- не рассчитывайте на то, что они останутся неизменными. Использовать день найти конкретный
преамбула.

Дополнительная информация о блоке имеет вид



информация удобочитаем, но разработан, чтобы быть достаточно простым для машинного анализа
тоже.

При печати процентов 0% и 100% печатаются только тогда, когда значения точно, 0% и
100% соответственно. Другие значения, которые обычно округляются до 0% или 100%:
вместо этого печатается как ближайшее не граничное значение.

Когда используешь gcov, вы должны сначала скомпилировать свою программу с двумя специальными параметрами GCC:
-fprofile-дуги -ftest-охват. Это говорит компилятору сгенерировать дополнительные
информация, необходимая gcov (в основном блок-схема программы), а также включает
дополнительный код в объектных файлах для создания необходимой дополнительной информации профилирования
пользователя gcov. Эти дополнительные файлы помещаются в каталог, в котором находится объектный файл.
располагается.

Запуск программы приведет к генерации выходных данных профиля. Для каждого исходного файла
составлено с -fprofile-дуги, сопутствующий .gcda файл будет помещен в объектный файл
каталог.

Бег gcov с именами исходного файла вашей программы в качестве аргументов теперь будет выводить список
кода вместе с частотой выполнения для каждой строки. Например, если ваша программа
называется tmp.c, это то, что вы видите, когда используете базовый gcov средство:

$ gcc -fprofile-arcs -ftest-покрытие tmp.c
$ a.out
$ gcov tmp.c
90.00% из 10 строк исходного кода выполняются в файле tmp.c
Создание tmp.c.gcov.

Файл tmp.c.gcov содержит вывод из gcov, Вот пример:

-: 0: Источник: tmp.c
-: 0: График: tmp.gcno
-: 0: Данные: tmp.gcda
-: 0: Ходов: 1
-: 0: Программ: 1
-: 1: # включить
-: 2:
-: 3: int main (пусто)
1: 4: {
1: 5: int i, всего;
-: 6:
1: 7: всего = 0;
-: 8:
11: 9: для (i = 0; i <10; i ++)
10: 10: всего + = i;
-: 11:
1:12: если (всего! = 45)
#####: 13: printf ("Ошибка \ n");
-: 14: еще
1:15: printf ("Успех \ n");
1:16: возврат 0;
-: 17:}

Когда вы используете -a вариант, вы получите количество отдельных блоков, и результат будет выглядеть
как это:

-: 0: Источник: tmp.c
-: 0: График: tmp.gcno
-: 0: Данные: tmp.gcda
-: 0: Ходов: 1
-: 0: Программ: 1
-: 1: # включить
-: 2:
-: 3: int main (пусто)
1: 4: {
1: 4-блок 0
1: 5: int i, всего;
-: 6:
1: 7: всего = 0;
-: 8:
11: 9: для (i = 0; i <10; i ++)
11: 9-блок 0
10: 10: всего + = i;
10: 10-блок 0
-: 11:
1:12: если (всего! = 45)
1: 12-блок 0
#####: 13: printf ("Ошибка \ n");
$$$$$: 13-блок 0
-: 14: еще
1:15: printf ("Успех \ n");
1: 15-блок 0
1:16: возврат 0;
1: 16-блок 0
-: 17:}

В этом режиме каждый базовый блок отображается только в одной строке - последней строке блока. А
многострочный блок будет вносить вклад только в счетчик выполнения этой последней строки, а другие
Строки не будут показаны как содержащие код, если предыдущие блоки не заканчиваются на этих строках. В
отображается общее количество выполнений в строке, а последующие строки показывают счетчики выполнения
для отдельных блоков, которые заканчиваются на этой строке. После каждого блока считается ветвь и звонки.
блока будет отображаться, если -b предоставляется вариант.

Из-за способа вызова инструментов GCC счетчик вызовов может отображаться после строки без
отдельные блоки. Как видите, строка 13 содержит базовый блок, который не был выполнен.

Когда вы используете -b вариант, ваш результат будет выглядеть так:

$ gcov -b tmp.c
90.00% из 10 строк исходного кода выполняются в файле tmp.c
80.00% из 5 веток выполнено в файле tmp.c
80.00% из 5 веток, взятых хотя бы один раз в файле tmp.c
50.00% из 2 вызовов выполнено в файле tmp.c
Создание tmp.c.gcov.

Вот образец полученного tmp.c.gcov файл:

-: 0: Источник: tmp.c
-: 0: График: tmp.gcno
-: 0: Данные: tmp.gcda
-: 0: Ходов: 1
-: 0: Программ: 1
-: 1: # включить
-: 2:
-: 3: int main (пусто)
функция main вызвала 1 вернула 1 блок выполнено 75%
1: 4: {
1: 5: int i, всего;
-: 6:
1: 7: всего = 0;
-: 8:
11: 9: для (i = 0; i <10; i ++)
ветка 0 занята 91% (провал)
отделение 1 занято 9%
10: 10: всего + = i;
-: 11:
1:12: если (всего! = 45)
ветка 0 занята 0% (провал)
отделение 1 занято 100%
#####: 13: printf ("Ошибка \ n");
вызов 0 никогда не выполнялся
-: 14: еще
1:15: printf ("Успех \ n");
звонок 0 вызвал 1 вернулся 100%
1:16: возврат 0;
-: 17:}

Для каждой функции печатается строка, показывающая, сколько раз функция вызывается, как
сколько раз он возвращается и какой процент блоков функции был выполнен.

Для каждого базового блока после последней строки базового блока печатается строка, описывающая
ветвь или вызов, завершающий базовый блок. Может быть несколько веток и звонков
указывается для одной исходной строки, если на этой строке заканчивается несколько базовых блоков.
В этом случае каждому филиалу и звонку присваивается номер. Нет простого способа
сопоставьте эти ветви и вызовите исходные конструкции. В целом же самый низкий
Пронумерованная ветвь или вызов будет соответствовать самой левой конструкции в исходной строке.

Для ветки, если она была выполнена хотя бы один раз, то процент, указывающий количество
раз, когда ветвь была взята, деленная на количество раз, когда ветвь выполнялась, будет
напечатаны. В противном случае печатается сообщение «никогда не выполняется».

Для звонка, если он был выполнен хотя бы один раз, то процент, указывающий количество
количество возвращенных вызовов, деленное на количество выполненных вызовов, будет
напечатаны. Обычно это 100%, но может быть меньше для функций, которые вызывают "exit" или
"longjmp", поэтому они не могут возвращаться каждый раз при их вызове.

Счетчики выполнения являются кумулятивными. Если программа-пример была выполнена снова без
удаление .gcda файла, подсчет количества раз, когда каждая строка в источнике
выполнено будет добавлено к результатам предыдущего запуска. Это потенциально полезно
несколькими способами. Например, его можно использовать для накопления данных по нескольким
программа работает как часть набора проверки тестов или для обеспечения более точных долгосрочных
информация за большое количество запусков программы.

Данные в .gcda файлы сохраняются непосредственно перед выходом из программы. Для каждого
исходный файл, скомпилированный с -fprofile-дуги, код профилирования сначала пытается прочитать в
существующий .gcda файл; если файл не соответствует исполняемому (разное количество базовых
количество блоков) он проигнорирует содержимое файла. Затем он добавляет в новое исполнение
считает и, наконец, записывает данные в файл.

. gcov с НКУ Оптимизация

Если вы планируете использовать gcov чтобы помочь оптимизировать ваш код, вы должны сначала скомпилировать вашу программу
с двумя специальными опциями GCC: -fprofile-дуги -ftest-охват. Помимо этого, вы можете
использовать любые другие параметры GCC; но если вы хотите доказать, что каждая строчка в вашей программе
был выполнен, вам не следует одновременно компилировать с оптимизацией. На некоторых машинах
оптимизатор может исключить некоторые простые строки кода, комбинируя их с другими строками.
Например, такой код:

если (а! = б)
с = 1;
еще
с = 0;

на некоторых машинах можно скомпилировать в одну инструкцию. В этом случае нет возможности
gcov для расчета отдельных счетчиков выполнения для каждой строки, потому что нет отдельных
код для каждой строки. Следовательно gcov вывод выглядит так, если вы скомпилировали программу
с оптимизацией:

100: 12: если (a! = B)
100: 13: с = 1;
100: 14: еще
100: 15: с = 0;

Выходные данные показывают, что этот блок кода, объединенный оптимизацией, выполнен 100 раз.
В каком-то смысле этот результат верен, потому что была только одна инструкция, представляющая
все четыре строки. Однако вывод не указывает, сколько раз результат
было 0 и сколько раз результат был 1.

Встроенные функции могут создавать неожиданное количество строк. Количество строк показано для
исходный код встроенной функции, но то, что отображается, зависит от того, где находится функция
встроенный, или если он не встроенный.

Если функция не встроена, компилятор должен выдать внешнюю копию
функция в любом объектном файле, который в ней нуждается. Если файлA.o и файлB.o оба содержат из
строчные тела конкретной встроенной функции, они также будут содержать покрытие
имеет значение для этой функции. Когда файлA.o и файлB.o связаны вместе, линкер будет,
во многих системах выберите одно из этих внешних тел для всех вызовов этой функции,
и удалите или проигнорируйте другой. К сожалению, счетчики покрытия он не уберет.
для неиспользуемого тела функции. Следовательно, при инструментировании все, кроме одного использования этой функции
покажет нулевое количество.

Если функция встроена в нескольких местах, блочная структура в каждом месте может
не быть таким же. Например, условие теперь может быть вычислено во время компиляции в
некоторые экземпляры. Поскольку будет показан охват всех случаев использования встроенной функции
для одних и тех же исходных строк подсчет строк может показаться непоследовательным.

Долго работающие приложения могут использовать средства «_gcov_reset» и «_gcov_dump» для
ограничить сбор профилей интересующей программной областью. Вызов "_gcov_reset (void)"
сбросит все счетчики профиля на ноль, а вызов "_gcov_dump (void)" вызовет
информация профиля, собранная в этот момент, будет сброшена в .gcda выходные файлы.

Используйте mips64el-linux-gnuabi64-gcov-5 в Интернете с помощью сервисов onworks.net


Ad


Ad

Новейшие онлайн-программы для Linux и Windows