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"]
индекс и имя функции
Существует два вида записей: функция, которая принадлежит части, имеет свой индекс в первом столбце части, и в этом столбце, только их имя распечатано.
Все другие функции (родительские элементы и дочерние элементы функции) только распечатаны в этом столбце с их индексом и называют вместе с маленьким добавлением отступа для выделения функции, которая принадлежит части.
Родительские элементы расположены выше самой функции, все дочерние элементы записаны ниже линии с функцией, часть принадлежит.
Поскольку более подробное объяснение линий в части графика видит первый пример.
Мы задаем три функции fG и 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 \times.
f имеет два родительских элемента и никакие дочерние элементы.
f вызван его родительским g4 времена и 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 миллисекунды. 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 непосредственно.