Время выполнения команды Linux

Если вам нужна более высокая точность, используйте %N с датой (и используйте bc для сравнения, поскольку $(()) обрабатывает только целые числа).

Вот как это сделать:

Если вы собираетесь использовать время позже для вычислений, узнайте, как использовать параметр -f в /usr/bin/time для вывода кода, который экономит время. Вот некоторый код, который я недавно использовал для получения и сортировки времени выполнения целого класса студенческих программ:

Позже я объединил все файлы $timefile и передал вывод в интерпретатор Lua. Вы можете сделать то же самое с Python или bash или с любым вашим любимым синтаксисом. Мне нравится эта техника.

Примечание. Полный путь /usr/bin/time необходим, потому что, хотя какое время говорит вам об обратном, если вы просто запустите time , будет запущена версия времени вашей оболочки, которая не принимает никаких аргументов.

Если вам нужна точность только до секунды, вы можете использовать встроенную переменную $SECONDS, которая подсчитывает количество секунд, в течение которых работает оболочка.

Вы можете использовать время и подоболочку () :

Или в той же оболочке <> :

@StasBekman не соответствует действительности, сначала используется ( & ) (новый контекст, подоболочка), а затем используется < & >(та же оболочка, тот же контекст)

Ага! Я внимательно присматривался к этим двум и не увидел разницы. Спасибо, что разъяснили, что <> vs ().

Нет необходимости использовать теги -lphtread или -o. Просто нужно использовать команду времени, которая лучше объясняет принятый ответ.

Это был пример. У моего Perform.c есть многопоточность, поэтому мне нужен -lpthread, а для простой идентификации это -o per.

одним из возможных простых методов (который может не соответствовать потребностям разных пользователей) является использование оболочки PROMPT. Это простое решение, которое может оказаться полезным в некоторых случаях. Вы можете использовать функцию подсказок bash, как показано в примере ниже:

Приведенная выше команда изменит приглашение оболочки на:

Каждый раз, когда вы запускаете команду (или нажимаете Enter), возвращаясь к командной строке, в ней будет отображаться текущее время.

примечания:
1) имейте в виду, что если вы ждали некоторое время, прежде чем вводить следующую команду, то это время необходимо учитывать, т. е. время, отображаемое в приглашении оболочки, является отметкой времени, когда отображалось приглашение оболочки. , а не при вводе команды. некоторые пользователи предпочитают нажимать клавишу Enter, чтобы получить новое приглашение с новой отметкой времени, прежде чем они будут готовы к следующей команде.
2) Существуют другие доступные параметры и модификаторы, которые можно использовать для изменения командной строки bash, см. ( man bash ) для получения более подробной информации.

Я хочу отображать время выполнения скрипта.

В настоящее время я делаю следующее:

Это просто показывает время начала и окончания сценария. Можно ли отображать детализированные выходные данные, такие как время процессора/время ввода-вывода и т. д.?

@CiroSantilli烏坎事件2016六四事件法轮功 Я думаю, что предложенная вами ветка по-прежнему недостаточна для устранения влияния временных событий.

Есть команда, которую вы можете запустить, а затем она автоматически запускает все команды unix, забыли, как это включить?

19 ответов 19

Просто используйте время при вызове скрипта:

а "реальное", вероятно, то, что люди хотят знать - "Реальное время настенных часов - время от начала до конца звонка"

Если времени нет,

или, если вам нужна точность до доли секунды и у вас установлен bc,

Обратите внимание, что это работает, только если вам не нужна точность до доли секунды. Для некоторых целей это может быть приемлемо, для других нет. Для немного большей точности (например, вы по-прежнему вызываете дату дважды, так что вы могли бы лучше всего получить точность в миллисекундах на практике, а возможно и меньше), попробуйте использовать date +%s.%N . ( %N – это наносекунды, начиная с целой секунды.)

@ChrisH О. Хорошо, указывая на это; арифметическое расширение bash возможно только для целых чисел. Я вижу два очевидных варианта; либо отбросьте период в строке формата даты (и обработайте результирующее значение как наносекунды с начала эпохи), поэтому используйте date +%s%N , либо используйте что-то более способное, например bc, чтобы вычислить фактическое время выполнения из двух значений, как предлагает jwchew. Тем не менее, я считаю, что этот подход является неоптимальным; время значительно лучше, если оно доступно, по причинам, изложенным выше.

В дополнение к комментарию @rubo77, если ваш скрипт занимает несколько часов, используйте hours=$((runtime / 3600)); минуты=$(((время выполнения % 3600)/60)); секунд=$(( (время выполнения % 3600) % 60 )); echo "Время выполнения: $часы:$минуты:$секунды (чч:мм:сс)"

Просто вызовите время без аргументов после выхода из скрипта.

С ksh ​​или zsh вместо этого вы также можете использовать время. При использовании zsh time также будет отображать время настенных часов в дополнение к процессорному времени пользователя и системы.

Чтобы сохранить статус завершения вашего скрипта, вы можете сделать это:

Или вы также можете добавить ловушку на ВЫХОД:

Таким образом, время будет вызываться при выходе из оболочки, и статус выхода будет сохранен.

Также обратите внимание, что все bash , ksh и zsh имеют специальную переменную $SECONDS, которая автоматически увеличивается каждую секунду. Как в zsh, так и в ksh93 эта переменная также может быть сделана с плавающей запятой (с набором -F SECONDS ), чтобы получить большую точность. Это только время настенных часов, а не процессорное время.

Устраняет ли ваш подход влияние временных событий? - Я думаю, что ваш подход близок к подходу, представленному ранее. - - Я думаю, что подход timeit, представленный в коде MATLAB, может быть здесь полезен.

Привет, @Stéphane Chazelas. Я обнаружил, что время не дает времени стены, верно? например, bash -c 'время прерывания EXIT;sleep 2'

@Binarus, да, эта функция исходит от ksh. В отличие от ksh93/zsh, помимо того, что bash не поддерживает плавающую точку, он также сломан в том, что после того, как вы установите SECONDS в 0, он изменится на 1 с 0 на 1 секунду позже (поскольку он учитывает только результат time(), который имеет только полная секундная детализация).

Большое спасибо за подсказку. Таким образом, в bash требуется не менее одной секунды и не более двух секунд, пока он не изменится на 1 после установки его на 0. Однако я думаю, что это не нарушит чьи-либо сценарии, потому что ни один разумный человек не будет использовать средство измерения с 1 с разрешение для измерения промежутков времени в одну или две секунды. Я обычно использую его для проверки промежутков времени в 30 секунд и более, и там, где не важно, 31 это или 29 секунд на самом деле. Но еще раз большое спасибо за то, что вы обратили наше внимание на это тонкое и очень интересное различие между различными оболочками.

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

Надеюсь, кому-то это будет полезно!

[edit] Вам нужно подсчитать все символы в определении поля в bash printf, если вы хотите, чтобы секунды дополнялись до 2 цифр перед точкой, вы должны определить ее как% 07.4f (все цифры и точки также учитываются в поле длины) поэтому строка должна выглядеть так: LC_NUMERIC=C printf "Общее время выполнения: %d:%02d:%02d:%07.4f\n" $dd $dh $dm $ds

Я думаю, что нет другого (только bash) способа, кроме использования 'bc' для выполнения вычислений. Кстати, действительно хороший сценарий ;)

Остерегайтесь того, что дата FreeBSD не поддерживает точность до доли секунды и просто добавляет литерал « N » к метке времени.

Очень хороший скрипт, но мой bash не обрабатывает доли секунды. Я также узнал, что /1 в bc эффективно удаляет это, поэтому я добавил @/1@ к вычислению $ds, и теперь он очень хорошо отображает вещи!

bc поддерживает модуль: dt2=$(echo "$dt%86400" | bc) . Просто говорю. Кстати, я предпочитаю форму dt2=$(bc, но это сугубо личное.

Я пока ничего не знаю о bc, но деление на 86400 вызывает у меня недоверие по следующей причине: есть дни, в которых нет 86400 секунд, например дни, когда время переключается с летнего времени на нормальное время и наоборот наоборот, или дни с дополнительными секундами. Если такие дни являются частью промежутка времени, который вы хотите вычислить, т. е. находятся между res1 и res2 (включая эти значения), ваш скрипт, вероятно, не будет работать.

Мой метод для bash:

Это показывает прошедшее время, но не показывает "детализированные выходные данные, такие как время процессора, время ввода-вывода", как запрошено в вопросе.

Тем, кто ищет ответ на поставленный вопрос, скорее всего, это решение покажется полезным. Ваш комментарий лучше адресовать вопросу ОП.

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

Лично мне нравится заключать весь код скрипта в какую-нибудь "основную" функцию, например так:

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

Это лучшее решение. единственная проблема в том, что вы не можете получить доступ к аргументам скрипта из main .Чтобы передать аргументы функции, вам нужно вызвать time main "$@" в последней строке

Этот вопрос довольно старый, но в попытке найти мой любимый способ сделать это эта ветка поднялась высоко. и я удивлен, что никто не упомянул об этом:

perf — это инструмент для анализа производительности, включенный в ядро ​​в разделе tools/perf и часто доступный для установки в виде отдельного пакета («perf» в CentOS и «linux-tools» в Debian/Ubuntu). В Linux Kernal perf Wiki есть гораздо больше информации об этом.

Запуск 'perf stat' дает довольно много подробностей, включая среднее время выполнения в самом конце:

perf stat теперь жалуется на сообщение "Возможно, у вас нет разрешения на сбор статистики". если вы не запустите некоторые команды с помощью sudo , что делает его бесполезным во всех сценариях, где вы не полностью владеете целевой машиной.

Потрясающе, спасибо! Намного более детальное решение, чем время, которое предлагают другие. В частности, время не применимо к измерению решений для конкуренции за код (поскольку оно не печатает время в миллисекундах и меньше), в отличие от вашего решения.

Да, это вызывает Python, но если вы можете смириться с этим, то это довольно хорошее и лаконичное решение.

Учтите, что запуск этой команды python в подоболочке и чтение ее вывода займет несколько миллионов наносекунд в большинстве современных систем. То же самое для текущей даты .

"Несколько миллионов наносекунд" означает несколько миллисекунд. Люди, синхронизирующие bash-скрипты, обычно не очень беспокоятся об этом (если только они не запускают несколько миллиардов скриптов в мегасекунду).

Обратите также внимание, что, даже если вычисления выполняются внутри процесса Python, значения полностью собираются до вызова Python. Время выполнения скрипта будет измерено корректно, без лишних «миллионов наносекунд».

time main выше намного чище. да, мы можем жить с большим количеством деградации, но без нее намного лучше, так что давайте останемся инженерами!

Небольшая функция оболочки, которую можно добавить перед командами для измерения их времени:

Затем используйте его в своем скрипте или в командной строке следующим образом:

Чем это действительно отличается от других уже данных ответов, которые используют дату до и после сценария и выводят разницу между ними?

Какая красивая вещь. Вы можете поместить после него любую команду, и она выведет результат в приятном, удобочитаемом виде. Мне очень нравится использовать его для временных сборок. Пример:

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

Обратите внимание, что dt_min округляется от 0,01666666666. (1 секунда = столько минут) до 0,017 в данном случае, так как я использую функцию printf для округления. Сон 1; часть ниже - это то, где вы бы вызвали свой скрипт для запуска и времени, но вместо этого я просто сплю в течение 1 секунды ради этой демонстрации.

По теме:

Используя только bash, также можно измерить и рассчитать продолжительность времени для части сценария оболочки (или истекшее время для всего сценария):

теперь вы можете либо просто напечатать разницу:

если вам нужна только дополнительная продолжительность, сделайте следующее:

Вы также можете сохранить продолжительность в переменной:

^ ЭТО ответ, ребята. Или проще: $SECONDS в конце. Это ВСТРОЕННАЯ переменная Bash. Все остальные ответы просто делают дополнительную работу, чтобы заново изобрести это колесо.

Функция синхронизации на основе SECONDS , ограниченная только степенью детализации второго уровня, не использует никаких внешних команд:

Использовать встроенное время bash?

Принятое решение с использованием времени записывает в stderr .
Решение, использующее время, записывает данные в стандартный вывод.
В решениях, использующих $SECONDS, отсутствует точность до доли секунды.
Другие решения включают вызов внешних программ, таких как date или perf, что неэффективно.
Если вас устраивает любой из них, используйте его.

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

Выберите один из следующих вариантов анализа вывода времени в соответствии с вашими потребностями:
Самый короткий вариант, в котором стандартный вывод $Cmd записывается в стандартный вывод и ничего не записывается в стандартный вывод:

Более длинный вариант, в котором исходный stdout и stderr отделены друг от друга:

Самый сложный вариант включает в себя закрытие дополнительных файловых дескрипторов, так что $Cmd вызывается как бы без этой временной оболочки вокруг него, а команды lvm, такие как vgs, не жалуются на утечку файловых дескрипторов:

Вы даже можете подделать сложение с плавающей запятой в bash, не вызывая bc, что было бы намного медленнее:

Читайте также:

  
• Кнопка "Поделиться" в Windows 7 не активна
  
• Гипервизор песочницы Windows не найден
  
• Команда Cut в Linux
  
• Репозиторий файлов драйверов C windows system32 можно удалить
  
• Восстановление файлов Linux