prog:: profileОтобразите данные о синхронизации вызовов вложенной функции
Блокноты MuPAD® будут демонтированы в будущем релизе. Используйте live скрипты MATLAB® вместо этого.
Live скрипты MATLAB поддерживают большую часть функциональности MuPAD, хотя существуют некоторые различия. Для получения дополнительной информации смотрите, Преобразовывают Notebook MuPAD в Live скрипты MATLAB.
prog::profile(stmt)
prog::profile(stmt) оценивает оператор stmt MuPAD® и отображения, синхронизирующие данные всех вызовов вложенной функции, дополнительно график со структурой вызова.
prog::profile измеряет и отображает использование времени библиотечных функций. Функции ядра не измеряются. Для каждой функции, вызванной во время оценки stmt, prog::profile распечатывает время, проведенное в этой функции и количестве вызовов.
prog::profile может быть полезным в искании строго ограниченных во времени функций и ненужных вызовов вложенной функции.
stmt мог читать целый тестовый файл, также.
Прием, чтобы наблюдать также ядро функционирует, должен вызвать prog::trace с функцией ядра в качестве аргумента. prog::trace берет процедуру обертки библиотеки вокруг функции ядра, которая имеет то же имя и может быть найдена в выводе prog::profile, когда функция ядра используется во время оценки stmt. Использование времени функции обертки является почти нулем.
Первая часть вывода является таблицей со значениями синхронизации для каждой процедуры, вторая часть является графиком, который представляет информацию о зависимостях между всеми измеренными функциями, когда stmt оценен.
Таблица содержит несколько столбцов, которые описаны ниже.
Каждая строка показывает все данные одной функции (вызвал “функцию”), который был измерен prog::profile. Существует одна специальная запись: первая запись называется procedure entry point. Это показывает сумму всех функций и reperesents оценка stmt.
"percent usage of all"
время, проведенное в функции относительно всего времени, используемого для оценки stmt (в проценте)
"time self per single call"
значение "time self", разделенный на сумму всех вызовов функции (в milli секунды)
"time self"
все время, проведенное в теле функции, т.е. сумме всех вызовов, без времени, используемого всеми другими измеренными функциями, вызванными функцией (в milli секунды)
"time children per single call"
значение "time children", разделенный на сумму всех вызовов функции (в milli секунды)
"time children"
сумма всего времени (self и children) потраченный во всех функциях, которые вызваны функцией непосредственно
"calls/normal exit"
количество всех вызовов функции, которые оставляют функцию без ошибок
"calls/remember exit"
количество всех вызовов функции, которые возвращают помнившее значение ядром, помнит механизм (и не вызывает тело функции),
"calls/errors"
количество всех вызовов функции, которые оставляют функцию с ошибкой
["[index] function name"]
индекс функции (присвоенный prog::profile) и имя функции
Индекс присвоен каждой функции, в порядке убывания использования времени, чтобы идентифицировать и найти функцию в графе вызовов, который описан теперь.
Вторая часть вывода prog::profile является графиком зависимости. Это показывает каждую функцию, их родительские элементы (функции, которые вызывают функцию непосредственно), и их дочерние элементы (функции, которые вызваны от функции непосредственно), вместе с синхронизацией информации и количества вызовов.
Каждая часть графика, который разделяется горизонтальными строками минус char, принадлежит одной функции. Это содержит несколько столбцов:
"index"
индекс, присвоенный уникальный для функции
"%time"
процент функции на целом времени выполнения
"self"
сумма всех случаев используется функцией (в milli секунды)
"children"
сумма всех случаев, используемых дочерними элементами функции (в milli секунды)
"called"
количество всех вызовов функции
["[index] name"]
индекс и имя функции
Существует два вида записей: функция, которая принадлежит части, имеет свой индекс в первом столбце части, и в этом столбце, только их имя распечатано.
Все другие функции (родительские элементы и дочерние элементы функции) только распечатаны в этом столбце с их индексом и называют вместе с маленьким добавлением отступа для выделения функции, которая принадлежит части.
Родительские элементы расположены выше самой функции, все дочерние элементы записаны ниже строки с функцией, часть принадлежит.
Поскольку более подробное объяснение строк в части графика видит первый пример.
Мы задаем три функции f, g и h. prog::profile отображает время, проведенное в каждой функции и количестве вызовов его:
f := proc()
local t;
begin
t := time();
while time() < 10 + t do nothing end_while
end_proc:
g := proc()
local t;
begin
f();
t := time();
while time() < 10 + t do nothing end_while;
f()
end_proc:
h := proc() begin g(), f(), g() end_proc:prog::profile(h()):
percent usage of all | time self per
single call | | time self | | | time
children per single call | | | | time children
| | | | | calls/normal exit | |
| | | | calls/remember exit | | |
| | | | calls/errors | | | |
| | | | [index] funct. name -----------------------------------------------------------------
100.0 70.0 70.0 . . 1 . . [0] proc. entry pt.
-----------------------------------------------------------------
71.4 10.0 50.0 . . 5 . . [1] f 28.6 10.0
20.0 20.0 40.0 2 . . [2] g . . . 70.0
70.0 1 . . [3] h -----------------------------------------------------------------
index %time self children called [index] name -----------------------------------------------------------------
[0] 100.0 70 0 1 proc. entry point
0 70 1 [3] h -----------------------------------------------------------------
40 0 4 [2] g
10 0 1 [3] h [1] 71.4
50 0 5 f -----------------------------------------------------------------
20 40 2 [3] h [2]
28.6 20 40 2 g
40 0 4 [1] f -----------------------------------------------------------------
[3] 0.0 0 70 1 h
10 0 1 [1] f
20 40 2 [2] g -----------------------------------------------------------------
Time sum: 70 ms (Вывод сокращен немного, потому что страница является слишком маленькой.)
Строки приведенной выше таблицы описаны следующее:
percent usage of all | time self per
single call | | time self | | | time
children per single call | | | | time children
| | | | | calls/normal exit | |
| | | | calls/remember exit | | |
| | | | calls/errors | | | |
| | | | [index] funct. name -----------------------------------------------------------------
100.0 70.0 70.0 . . 1 . . [0] proc. entry pt.
----------------------------------------------------------------- Целый вызов функции берет процент 100 времени (конечно), 70.0 milli секунды и называется однажды (оценка stmt) без ошибки.
71.4 10.0 50.0 . . 5 . . [1] f
Функциональный f берет процент 71.4 всего времени оценки в его теле. Это использует 10.0 milli секунды на вызов в среднем (в этом случае точно), их дочерние элементы (если существующий) не использует измеримого времени (потому что это не имеет никаких дочерних элементов), и это называется временами 5 и возвращается без ошибок. f имеет индекс 1.
28.6 10.0 20.0 20.0 40.0 2 . . [2] g
Функциональный g берет проценты 28.6 всего времени, которые являются 20.0 milli секунды и 10.0 milli секунды в среднем на вызов. Их дочерние элементы используют 20.0 milli секунды пред вызов в среднем и общее количество 40.0, и g называется дважды и возвращается без ошибок. g получает индекс 2.
. . . 70.0 70.0 1 . . [3] h
Функциональное использование h почти никакое время оценки, их дочерние элементы используют 70.0 milli секунды в среднем и общее количество 70.0, и h назван однажды и закончен без ошибок. h получает индекс 3.
Части графика выше описаны следующее:
index %time self children called
[index] name -----------------------------------------------------------------
[0] 100.0 70 0 1 proc entry point
0 70 1 [3] h ----------------------------------------------------------------- Целый вызов функции берет проценты 100 времени оценки (по определению), которые являются 70.0 milli секунды, и это называется однажды.
Это вызывает однажды функциональный h с индексом [3] (в качестве аргумента prog::profile), и h использует 70.0 milli секунды времени, которые проведены в дочерних элементах h, не в теле.
index %time self children called
[index] name -----------------------------------------------------------------
40 0 4 [2] g
10 0 1 [3] h [1] 71.4
50 0 5 f ----------------------------------------------------------------- Функциональный f тратит процент 71.4 целого времени оценки. Это использует 50.0 milli секунды, их дочерние элементы не использует измеримого времени, и это называется временами 5.
f имеет два родительских элемента и никакие дочерние элементы.
f вызван его родительским g временами 4 и h однажды.
f тратит 40 milli секунды отдельно (в его теле), когда это называется от g (первая строка в части f), и f тратит 10 milli секунды в его теле, когда это называется от h (вторая строка).
index %time self children called
[index] name -----------------------------------------------------------------
20 40 2 [3] h [2]
28.6 20 40 2 g
40 0 4 [1] f ----------------------------------------------------------------- Функциональный g берет процент 28.6 всего времени, 20 milli секунды в его теле и их дочернее взятие 40 milli секунды. g называется дважды.
g называется от h дважды и тратит мс 20 в своем теле и мс 40 в его дочерних элементах.
g вызывает функциональный f четыре раза, и f тратит мс 40 в своем теле, когда это называется от g.
index %time self children called
[index] name -----------------------------------------------------------------
[3] 0.0 0 70 1 h
10 0 1 [1] f
20 40 2 [2] g ----------------------------------------------------------------- Функциональный h не занимает почти времени оценки, их дочерние элементы тратит 70.0 milli секунды, и h называется однажды.
h вызывает функции f и g непосредственно, f однажды и g дважды.
f использует мс 10 в своем теле, когда это называется от h, и g использует мс 20 в своем теле и мс 40 в его дочерних элементах.
|
Оператор MuPAD |
Результат stmt
Синхронизации, отображенные prog::profile, сгенерированы ядром.
Оценка stmt в prog::profile берет частично существенно дольше, чем оценка stmt непосредственно. Это дополнительное время не влияет на валидность синхронизаций, т.е. если prog::profile сообщает о f, берущем в три раза более долго, чем g, то это также имеет место при оценке stmt непосредственно.