Я хочу измерить время выполнения для петель на различных платформах, таких как php, c, python, Java, javascript . Как я могу это измерить? Я знаю эти платформы, поэтому говорю об этих:
for (i = 0; i
Создан 12 ноя.
Mohit Jain
Было бы полезно, если бы вы объяснили, почему вы хотите это сделать (если только не для того, чтобы узнать, как это сделать). Есть ли какой-то конкретный код, который вы пытаетесь оптимизировать? Вы сравниваете разные языки? — Edan Maor
Без тела в цикле многие компиляторы поймут, что у цикла нет побочного эффекта, и просто оптимизируют его. Практически невозможно измерить время, необходимое для «пустых» структур, таких как «if» без тела и «while» без тела. — S.Lott
Добавление инкремента или чего-то подобного в тело цикла серьезно повлияет на результат, потому что время, необходимое для увеличения, того же порядка величины, что и инструкции обработки временного цикла. — n0rd
12 ответы
Обратите внимание, что это также зависит от того, чего именно вы хотите достичь: заботитесь ли вы о времени ожидания вашей программы из-за того, что она была вытеснена системным планировщиком? Во всех приведенных выше решениях учитывается фактическое время, прошедшее, но также учитывается время, когда другие процессы выполняются вместо вашего собственного.
Как рассчитать время выполнения макета на контроллере RUIDA из программы RDWorks. часть 2
Если вас это не волнует, все вышеперечисленные решения подойдут. Если вам все равно, вам, вероятно, понадобится какое-то программное обеспечение для профилирования, чтобы на самом деле увидеть, сколько времени занимает цикл. Я бы начал с программы, которая ничего не делает, кроме вашего цикла и (по крайней мере, в среде Linux) делает time you-prg-executable . Затем я бы поинтересовался, есть ли инструменты, которые работают как time . Не уверен, но я бы посмотрел на JRat для java и gcc gcov для C и C ++. Несомненно, есть аналогичные инструменты для других языков. Но, конечно, вам нужно посмотреть, дают ли они реальное время или нет.
Создан 12 ноя.
Хотя для C ++ был дан ответ, из вашего описания («[Вы] не хотите ничего измерять в цикле») похоже, что вы пытаетесь измерить время, которое требуется программе для итерации по пустому петля. Пожалуйста, будьте осторожны: это не только займет разное время для разных платформ и процессоров, но многие компиляторы оптимизируют такие циклы, эффективно отображая ответ как «0» для любого размера цикла.
Создан 12 ноя.
u может добавить простое уравнение, например int x = 0; затем продолжайте увеличивать его внутри цикла. — Мохит Джайн
Я слышал о компиляторах, которые все еще могут найти ответ без цикла. — Дядя Бен
И что делает его еще более сложным; компилятор java продолжает оптимизацию, чем чаще он сталкивается с частями кода. Так что первая итерация (если есть тело) вполне может быть медленнее последней. — посторонний
Javascript
start = new Date; for(var i = 0; i < 1000000; i++) <>time = new Date — start;
Источник: stackovergo.com
Как рассчитать полное Рабочее время в Excel. #Трюк за 30 секунд
Русские Блоги
Если вы считаете, что две программы занимают примерно одинаковое количество времени, лучший способ определить, какая программа быстрее, — это, вероятно, кодировать их и запускать.
В общем, есть концентрированные идеи алгоритмов, и мы всегда готовы как можно скорее удалить эти плохие идеи алгоритмов. Поэтому нам обычно нужно анализировать алгоритмы. Не только это, но и способность анализировать. Мало того, что способность выполнять анализ часто дает возможность Chattel вычислять приоритетные алгоритмы. Вообще говоря, анализ также может точно определить узкое место, и эти места заслуживают тщательного кодирования.
Чтобы упростить анализ, мы примем следующее соглашение: не существует конкретной единицы времени. Поэтому мы отбрасываем некоторые ведущие константы, а также отбрасываем члены более низкого порядка, поэтому нам нужно вычислить время выполнения больших O. Поскольку Big O является верхней границей, мы должны быть осторожны и никогда не недооценивать время выполнения программы. Фактически, результаты анализа дают гарантию того, что программа может быть прекращена в течение определенного периода времени. Процедура может закончиться рано, но она никогда не может быть неправильной.
Простой пример: 1 ^ 3 + 2 ^ 3 + 3 ^ 3 + 4 ^ 3 + . + n ^ 3 + .
public static int sum(int n) < int partialSum; partialSum = 0; for (int i = 1; i return partialSum; >
Анализ этого сегмента программы прост.
Все заявления не считают время. partalSum = 0, и возвращаемое PartualSum каждый занимает единицу времени. partSum + = i * i * i занимает 4 единицы времени для каждого выполнения (два умножения, одно сложение и одно назначение) и 4 N единиц времени для N исполнений Цикл for подразумевает накладные расходы при инициализации i, тестировании i
Если вы анализируете все эти задачи каждый раз, когда анализируете программу, эта задача быстро станет бременем. Так как у нас большой результат O, есть много ярлыков, которые можно использовать, не влияя на конечный результат. Например, partSum + = i * i * i, который выполняется каждый раз, очевидно, похож на O (1), и глупо точно вычислять, равен ли он 2, 3 или 4 и т. Д., Потому что это не имеет значения. Циклы int partSum и for явно не важны, поэтому неразумно проводить здесь время. Это дает нам некоторые правила.
Правило 1-для цикла
Время выполнения цикла for самое большее умножает время выполнения этих операторов внутри цикла for на количество итераций.
Правило 2-Вложенное для цикла
Проанализируйте эти циклы изнутри. Общее время выполнения оператора внутри группы вложенных циклов является произведением времени выполнения оператора на размер всех циклов for в группе. Например, следующий фрагмент программы — O (N ^ 2)
for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) System.out.println();
Правило 3-Последовательные высказывания
Время выполнения каждого оператора может быть суммировано (это означает, что максимальное значение является временем выполнения). Например, следующий фрагмент программы показывает стоимость O (N), а затем O (N ^ 2), поэтому итоговое значение Количество также O (N ^ 2), игнорируя при этом O (N)
for (int i = 1; i < n; i++) < System.out.println(); >for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) System.out.println();
Правило 4-if / else утверждение
if(condition) S1 else S2
Время выполнения оператора if / else никогда не превышает время выполнения оценки плюс общее время выполнения более старых в S1 и S2, то есть время выполнения не превышает время выполнения оценки плюс большее из S1 или S2 Продолжительность
Другие законы — это медитация, но основная стратегия анализа — работать изнутри (или самой глубокой частью). Если есть вызовы методов, то эти вызовы должны быть проанализированы в первую очередь. Если существует рекурсивный процесс, то есть несколько случаев: если рекурсия на самом деле представляет собой просто цикл for, покрытый тонкой завесой (его легко преобразовать в цикл for), анализ прост. Следующая рекурсия на самом деле является циклом for:
public static long factorial(int n)
Это особый пример, но когда рекурсия используется нормально, трудно преобразовать ее в структуру цикла. В этом случае при анализе будут разработаны рекурсивные отношения.
public static long fib(int n)
Если программа закодирована и N выполняется около 40, эффективность программы особенно низкая. Пусть T (N) будет временем выполнения функции fib (n). Если N = 0 или N = 1, время выполнения является константой, поскольку эта константа не важна и для удобства расчета мы можем установить T (0) = T (1) = 1. Время пробега для других значений N измеряется на основе времени пробега базового случая. Если N> 2, время выполнения — это время принятия решения плюс время выполнения в операторе else, а оператор else состоит из одной домашней проблемы и двух вызовов метода. Первым вызовом метода является время выполнения fib (n-1) и T (N-1). Время работы fib (n) можно получить по аналогии:
T (N) = T (N-1) + T (N-2) +2 и
Легко сделать вывод, что по индукции T (N)> = fib (N). А по fib (N) = fib (N-1) + fib (N-2) с помощью индукции можно получить fib (N)> = (3/2) ^ N и T (N)> = (3/2) ^ N, видно, что время работы увеличивается в геометрической прогрессии.
Причина, по которой эта программа работает медленно, заключается в том, что предстоит выполнить еще много работы. В выражении fib (n-1) + fib (n-2), когда вызывается fib (n-1), fib (n-2) фактически вычисляется один раз, и эта информация отбрасывается, а затем после + FIB (n-2) рассчитывается один раз. Отброшенная информация, объединенная вместе рекурсивно, приводит к огромному времени выполнения. Это может быть лучшим примером «вычисления чего-либо не более одного раза», но это не должно отпугивать вас от рекурсии и использовать ее.
Источник: russianblogs.com
Как рассчитать скорость выполнения Java-программ
Как вы оцениваете время выполнения Java-программы? Я не уверен, какой класс я должен использовать, чтобы сделать это. Я вроде ищу что-то вроде:
// Some timer starts here for (int i = 0; i < length; i++) < // Do something >// End timer here System.out.println(«Total execution time: » + totalExecutionTime);
George Mic 04 апр. 2010, в 00:36
Поделиться
Поделиться:
13 ответов
Лучший ответ
final long startTime = System.currentTimeMillis(); for (int i = 0; i < length; i++) < // Do something >final long endTime = System.currentTimeMillis(); System.out.println(«Total execution time: » + (endTime — startTime));
bua 03 апр. 2010, в 22:38
Поделиться
это действительно должно быть nanoTime на самом деле
Eugene 07 нояб. 2012, в 15:35
Не должно быть nanoTime. Смотрите ответ Ру.
fabspro 12 фев. 2013, в 13:56
Есть ли какая-то конкретная причина, по которой вы использовали «финал» здесь? Что было бы иначе, если бы вы опустили это ключевое слово?
dijxtra 06 авг. 2013, в 08:03
wchargin 28 авг. 2013, в 17:12
Тестируемый код, наряду с измерениями времени, должен запускаться несколько раз, а первый результат должен быть отброшен. Первый, скорее всего, будет включать время загрузки класса и т. Д. При запуске умножается на несколько раз, и, конечно, вы получите среднее значение, которое будет более полезным и надежным.
Arun Ramakrishnan 19 фев. 2016, в 06:38
Показать ещё 3 комментария
Имейте в System#nanoTime() что есть некоторые проблемы, когда System#nanoTime() не может надежно использоваться на многоядерном процессоре для записи истекшего времени. каждое ядро поддерживает свой собственный TSC (счетчик меток времени): этот счетчик используется для получения нано время (на самом деле это количество тактов с момента загрузки процессора).
Следовательно, если ОС не выполняет некоторую деформацию времени TSC для синхронизации ядер, то, если поток будет запланирован на одном ядре при начальном считывании времени, а затем переключен на другое ядро, относительное время может время от времени казаться скачкообразным и вперед.
Я наблюдал это некоторое время назад на AMD/Solaris, где прошедшие времена между двумя временными точками иногда возвращались либо как отрицательные значения, либо как неожиданно большие положительные числа. Был патч ядра Solaris и настройка BIOS, необходимая для принудительного включения AMD PowerNow! выкл, который, казалось, решил это.
Кроме того, существует (AFAIK) еще не исправленная ошибка при использовании java System#nanoTime() в среде VirtualBox; вызывая у нас всевозможные странные проблемы с многопоточностью, так как большая часть пакета java.util.concurrency зависит от времени nano.
Источник: overcoder.net