¿Cómo mido el tiempo de ejecución de un comando en la línea de comandos de Windows?

Respuestas:

113

Si usa Windows 2003 (tenga en cuenta que Windows Server 2008 y versiones posteriores no son compatibles) puede usar el Kit de recursos de Windows Server 2003, que contiene timeit.exe que muestra estadísticas detalladas de ejecución. Aquí hay un ejemplo, cronometrando el comando "timeit -?":

C:\>timeit timeit -?
Invalid switch -?
Usage: TIMEIT [-f filename] [-a] [-c] [-i] [-d] [-s] [-t] [-k keyname | -r keyname] [-m mask] [commandline...]
where:        -f specifies the name of the database file where TIMEIT
                 keeps a history of previous timings.  Default is .\timeit.dat
              -k specifies the keyname to use for this timing run
              -r specifies the keyname to remove from the database.  If
                 keyname is followed by a comma and a number then it will
                 remove the slowest (positive number) or fastest (negative)
                 times for that keyname.
              -a specifies that timeit should display average of all timings
                 for the specified key.
              -i specifies to ignore non-zero return codes from program
              -d specifies to show detail for average
              -s specifies to suppress system wide counters
              -t specifies to tabular output
              -c specifies to force a resort of the data base
              -m specifies the processor affinity mask

Version Number:   Windows NT 5.2 (Build 3790)
Exit Time:        7:38 am, Wednesday, April 15 2009
Elapsed Time:     0:00:00.000
Process Time:     0:00:00.015
System Calls:     731
Context Switches: 299
Page Faults:      515
Bytes Read:       0
Bytes Written:    0
Bytes Other:      298

Puede obtener TimeIt en el Kit de recursos de Windows 2003. Descárgalo aquí .

Servy
fuente
77
Este kit tiene problemas con Windows 2008 de 64 bits y no funciona en 2008 R2
Artem
¿Hay alguna manera de medir también el tiempo del kernel y / o el tiempo utilizado por los subprocesos generados?
rogerdpack
38
FYI: no creo que timeit funcione en Windows 7 de 64 bits. Obtiene el error "No se pueden consultar los datos de rendimiento del sistema (c0000004). En su lugar, utilice" Measure-Command "de PowerShell como Casey.K sugiere: stackoverflow.com/questions/673523/…
Michael La Voie
66
En Windows 7 veo "'timeit' no se reconoce como un comando interno o externo, un programa operable o un archivo por lotes".
Coronel Panic
3
No veo el comando en Windows 10, ni encuentro fácilmente un Kit de recursos para Win 10. ¿Alguien sabe cómo obtener esto para 10?
Jay Imerman el
469

Alternativamente, Windows PowerShell tiene un comando incorporado que es similar al comando "time" de Bash. Se llama "Medida-Comando". Deberá asegurarse de que PowerShell esté instalado en la máquina que lo ejecuta.

Entrada de ejemplo:

Measure-Command {echo hi}

Salida de ejemplo:

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 0
Milliseconds      : 0
Ticks             : 1318
TotalDays         : 1.52546296296296E-09
TotalHours        : 3.66111111111111E-08
TotalMinutes      : 2.19666666666667E-06
TotalSeconds      : 0.0001318
TotalMilliseconds : 0.1318
Casey.K
fuente
21
Esta es la mejor solución para usuarios de Windows 7 ya que timeit.exe no parece admitir Windows 7
Michael La Voie
14
En caso de que desee utilizar los comandos internos dos (por ejemplo: dir, echo, del, etc.) no olvide insertar "cmd / c": Measure-Command {cmd / c dir / sc: \ windows> nul}
LietKynes
77
Si va a la evaluación comparativa de una .exeen el directorio actual, utilice la siguiente: Measure-Command { .\your.exe }. PowerShell aparentemente no ejecuta cosas a pwdmenos que se le indique explícitamente.
Cristian Diaconescu
13
Sin embargo, molestamente oculta stdout.
Zitrax
13
Esto NO ES en absoluto una herramienta 'similar al comando de tiempo de Bash' . Sin embargo, es bueno saberlo ... pero: ¡no se ejecuta y vuelve a<stdout> los resultados del comando encerrado entre llaves!
Kurt Pfeifle
287

Si tu quieres

  1. Para medir el tiempo de ejecución hasta la centésima de segundo en (formato hh: mm: ss.ff)
  2. Para no tener que descargar e instalar un paquete de recursos
  3. Para parecer un gran nerd de DOS (que no lo hace)

Intente copiar el siguiente script en un nuevo archivo por lotes (por ejemplo, timecmd.bat ):

@echo off
@setlocal

set start=%time%

:: Runs your command
cmd /c %*

set end=%time%
set options="tokens=1-4 delims=:.,"
for /f %options% %%a in ("%start%") do set start_h=%%a&set /a start_m=100%%b %% 100&set /a start_s=100%%c %% 100&set /a start_ms=100%%d %% 100
for /f %options% %%a in ("%end%") do set end_h=%%a&set /a end_m=100%%b %% 100&set /a end_s=100%%c %% 100&set /a end_ms=100%%d %% 100

set /a hours=%end_h%-%start_h%
set /a mins=%end_m%-%start_m%
set /a secs=%end_s%-%start_s%
set /a ms=%end_ms%-%start_ms%
if %ms% lss 0 set /a secs = %secs% - 1 & set /a ms = 100%ms%
if %secs% lss 0 set /a mins = %mins% - 1 & set /a secs = 60%secs%
if %mins% lss 0 set /a hours = %hours% - 1 & set /a mins = 60%mins%
if %hours% lss 0 set /a hours = 24%hours%
if 1%ms% lss 100 set ms=0%ms%

:: Mission accomplished
set /a totalsecs = %hours%*3600 + %mins%*60 + %secs%
echo command took %hours%:%mins%:%secs%.%ms% (%totalsecs%.%ms%s total)

Uso

Si coloca timecmd.bat en un directorio en su ruta, puede llamarlo desde cualquier lugar como este:

timecmd [your command]

P.ej

C:\>timecmd pause
Press any key to continue . . .
command took 0:0:1.18

Si desea hacer una redirección de salida, puede citar el comando de esta manera:

timecmd "dir c:\windows /s > nul"

Esto debería manejar los comandos que se ejecutan desde antes hasta después de la medianoche, pero la salida será incorrecta si su comando se ejecuta durante 24 horas o más.

Luke Sampson
fuente
99
reemplazar cmd / c% * con % * funciona a menos que su comando sea otro archivo por lotes. Entonces tendrías que hacer timecmd call other.bat
Jesse Chisholm
2
@JesseChisholm En Windows 8 (y también he leído en Windows 7) no necesita la llamada para .bat
Brian J
44
Por alguna razón, esto solo me da salida en segundos completos ... que para mí es inútil. Quiero decir que corro timecmd pause, y siempre resulta en 1.00 segundos, 2.00 segundos, 4.00 segundos ... ¡incluso 0.00 segundos! Windows 7.
Camilo Martin
99
@CamiloMartin y otros que tuvieron esto (como yo): puede tener una configuración regional, que usa COMMA en lugar de DOT para decimal. Entonces, en este escritulo, cambie delims=:.a delims=:.,, y luego debería funcionar "en todos los ámbitos".
Tomasz Gandor
55
Hay un error aritmético grave en ese script: Pruébelo con: set start=10:10:10.10 set end=10:11:10.09Y generará: command took 0:1:-1.99 (59.99s total) Debe invertir el orden de las 4 líneas que hacen comparaciones "lss 0", de modo que el acarreo progrese correctamente de dígitos sexagesimales bajos a altos. Entonces la salida se convierte en: command took 0:0:59.99 (59.99s total)
Jean-François Larvoire
230

Jeje, la solución más simple podría ser esta:

echo %time%
YourApp.exe
echo %time%

Esto funciona en cada Windows fuera de la caja.


En el caso de una aplicación que utiliza la salida de la consola, puede ser conveniente almacenar el tiempo de inicio en una variable temporal:

set startTime=%time%
YourApp.exe
echo Start Time: %startTime%
echo Finish Time: %time%
LietKynes
fuente
163
¡¿Estas loco?! Eso implica hacer matemáticas, como, en tu cerebro. Es por eso que inventamos las computadoras, para que podamos evitar hacer cosas así.
Luke Sampson
1
¡brillante! Sin embargo, para el tiempo de CPU realmente no ayuda
Elijah Saounkine
10
Aún mejor (si su aplicación escupe resultados en la consola): set startTime=%time% \n YourApp.exe \n echo Start Time: %startTime% \n echo Finish Time: %time% (Lo siento, no pude obtener nuevas líneas en el comentario)
Jono
1
@LukeSampson, puedes usar setpara hacer los cálculos. ;-)Oh, espera, no importa, ya lo hiciste a continuación.
Synetech
2
No, esta es una mala opción. Esto le indica la hora del reloj de pared, no la hora de la CPU. Entonces, a pesar de que su línea de comando puede tomar solo 100 ms, si hay otra aplicación que acapare la CPU, su aplicación puede tomar segundos (apagada en 100 veces o más). De hecho, si su máquina se está agitando, incluso podría esperar un minuto para que se ejecute su pequeña aplicación de 100 ms. ¡Haga un seguimiento del tiempo de CPU, no del reloj de pared!
Ryan Shillington
102

Solo una pequeña expansión de la respuesta de Casey.K sobre el uso Measure-Commandde PowerShell :

  1. Puede invocar PowerShell desde el símbolo del sistema estándar, como este:

    powershell -Command "Measure-Command {echo hi}"
    
  2. Esto consumirá el resultado estándar, pero puede evitarlo agregando | Out-Defaultasí desde PowerShell:

    Measure-Command {echo hi | Out-Default}
    

    O desde un símbolo del sistema:

    powershell -Command "Measure-Command {echo hi | Out-Default}"
    

Por supuesto, puedes envolver esto en un archivo de script *.ps1o *.bat.

Vladimir Veljkovic
fuente
1
¿Qué pasa si el comando que queremos medir tiene comillas? ¿Se puede convertir esto en un script .bat en ese caso? Por ejemplomeasureTime.bat "c:\program files\some dir\program.exe"
GetFree
53

El one-liner que uso en Windows Server 2008 R2 es:

cmd /v:on /c "echo !TIME! & *mycommand* & echo !TIME!"

Siempre que mycommand no requiera comillas (que se atornilla con el procesamiento de comillas de cmd). El /v:onobjetivo es permitir que los dos valores TIME diferentes se evalúen de forma independiente en lugar de una vez en la ejecución del comando.

Arenque Nathan
fuente
Esto tampoco funcionará para los lotes de "spam", que sobrescriben la etiqueta de la primera vez e implican que debe reemplazar la computadora que realiza el cálculo, como se indica en stackoverflow.com/questions/673523/…
Val
Por lo general, puede escapar de las comillas ^en cmd (como ^")
n611x007
2
Si repite cmd / v: on para el segundo tiempo, incluso podemos hacer que mycommand contenga comillas. Ejemplo: cmd /v:on /c echo !TIME! & echo "Quoted mycommand" & cmd /v:on /c echo !TIME!.
Maarten Pennings
8
Más simple: echo %time% & *mycommand* & call echo %^time%. Ver también esta respuesta .
Aacini
Si su comando genera demasiado, tal vez sea más fácil simplemente juntar el tiempo 2:cmd /v:on /c "mycommand & echo begin=%time% endtime=!time!"
ZHANG Zikai
49

Si tiene una ventana de comandos abierta y llama a los comandos manualmente, puede mostrar una marca de tiempo en cada solicitud, por ejemplo

prompt $d $t $_$P$G

Te da algo como:

23.03.2009 15:45:50,77

C:\>

Si tiene un pequeño script por lotes que ejecuta sus comandos, tenga una línea vacía antes de cada comando, por ejemplo

(línea vacía)

myCommand.exe

(siguiente línea vacía)

myCommand2.exe

Puede calcular el tiempo de ejecución de cada comando por la información de tiempo en la solicitud. Lo mejor probablemente sería canalizar la salida a un archivo de texto para su posterior análisis:

MyBatchFile.bat > output.txt
Treb
fuente
3
Pensé que me retrasaría un par de años en la discusión para agradecerle por compartir el comando rápido. He visto muchos trucos de CMD (más de un tipo bash), pero este escapó de mi atención.
Steve Howard
Simple, elegante, sin instalación y sin escribir archivos por lotes para un comando de un solo disparo y puede cronometrar cada paso en un archivo por lotes.
Matt
26

Como otros recomiendan instalar cosas como freeware y PowerShell, también puede instalar Cygwin , que le daría acceso a muchos comandos básicos de Unix como el tiempo :

abe@abe-PC:~$ time sleep 5

real    0m5.012s
user    0m0.000s
sys 0m0.000s

No estoy seguro de cuánto agrega Cygwin.

Abe Voelker
fuente
41
Al responder preguntas de Windows, Cygwin se considera trampa :-)
mivk
14
Él ha estipulado que ResourceKit, TimeMem, ptime.exe, PowerShell y otras utilidades que los usuarios comenzaron a hacer trampa primero. Por lo tanto, el autor ha hecho que su comentario sea inapropiado antes de escribirlo.
Val
También lo he votado desde que me pareció la solución más fácil ya que el programa gratuito Cmder incluye bash! cmder.net Solo recuerde que si necesita escapar espacios en bash, use una barra negra \ justo antes del espacio, en lugar de "comillas". por ejemplo, cd / c / Programme \ Files /
lukescammell
24

No es tan elegante como algunas de las funciones de Unix, pero crea un archivo cmd que se vea así:

@echo off
time < nul
yourexecutable.exe > c:\temp\output.txt
time < nul
rem on newer windows system you can try time /T

Eso mostrará los tiempos de inicio y finalización de esta manera:

The current time is: 10:31:57.92
Enter the new time:
The current time is: 10:32:05.94
Enter the new time:
JohnW
fuente
2
Suponiendo que no necesita portabilidad en diferentes idiomas, también puede poner un findtr "actual" o algo así después de "time <nul" (buen uso de nul por cierto; siempre he usado echo. | Time, pero eso no se ve tan elegante :)). Y use "for" para extraer solo el tiempo, no el texto.
Joey
2
Si las extensiones de comando están habilitadas (es decir, la predeterminada), la versión de Win XP timetiene una /topción que solo muestra la hora actual del sistema, sin pedirle que ingrese una nueva hora. Sin embargo, cuando lo hace, solo muestra horas y minutos, lo que puede no ser lo suficientemente bueno para algunos usos. (Ver la respuesta de John Snow a esta pregunta).
Martineau
3
time /T¡solo se puede usar si el proceso se ejecuta durante varios minutos! time < nulEs más feo pero más preciso.
PhiLho
66
También podría usar el echo %time%que proporciona el mismo formato y precisión time < nul, pero evita el Enter the new time:resultado ...
aschipfl
para un uso de tiempo más preciso e independiente del entorno localwmic os get LocalDateTime
phuclv
19

Yo uso freeware llamado "GS Timer".

Simplemente haga un archivo por lotes como este:

timer
yourapp.exe
timer /s

Si necesita un conjunto de veces, simplemente canalice la salida del temporizador / s en un archivo .txt.

Puede obtenerlo aquí: las utilidades gratuitas de DOS de Gammadyne


La resolución es de 0.1 segundos.

pepoluan
fuente
44
No creo que el uso de una aplicación de terceros pueda considerarse hacerlo "con medios estándar".
Martineau
44
El interrogador quiso decir "sin instalar software adicional", ¡pero la respuesta superior (aceptada) también requiere instalar un Kit de recursos de Windows 2003 completo! De todos modos, timer.exe fue perfecto para lo que estaba buscando, ¡gracias!
Hugo
1
Este es un enlace plantado. SoftPedia es una granja de clics.
Tom A
@ Tom, explique, ¿qué quiere decir "enlace plantado"?
pepoluan
10
Aquí hay un enlace directo a la página del desarrollador: gammadyne.com/cmdline.htm#timer
Hugo
14

Estoy usando Windows XP y por alguna razón timeit.exe no me funciona. Encontré otra alternativa: PTIME. Esto funciona muy bien

http://www.pc-tools.net/win32/ptime/

Ejemplo

C:\> ptime

ptime 1.0 for Win32, Freeware - http://www.pc-tools.net/
Copyright(C) 2002, Jem Berkes <[email protected]>

Syntax: ptime command [arguments ...]

ptime will run the specified command and measure the execution time
(run time) in seconds, accurate to 5 millisecond or better. It is an
automatic process timer, or program timer.


C:\> ptime cd

ptime 1.0 for Win32, Freeware - http://www.pc-tools.net/
Copyright(C) 2002, Jem Berkes <[email protected]>

===  cd ===
C:\

Execution time: 0.015 s
Murali Krishnan
fuente
Funciona bien en Windows 8.1 también. Cambié el nombre del mío a timer.exe, porque nunca recuerdo el nombre ptime.
Brian Burns, el
11

También está TimeMem (marzo de 2012):

Esta es una utilidad de Windows que ejecuta un programa y muestra su tiempo de ejecución, uso de memoria y estadísticas de E / S. Es similar en funcionalidad a la utilidad de tiempo Unix.

Martin Moene
fuente
10

Mientras no dure más de 24 horas ...

@echo off

set starttime=%TIME%
set startcsec=%STARTTIME:~9,2%
set startsecs=%STARTTIME:~6,2%
set startmins=%STARTTIME:~3,2%
set starthour=%STARTTIME:~0,2%
set /a starttime=(%starthour%*60*60*100)+(%startmins%*60*100)+(%startsecs%*100)+(%startcsec%)

:TimeThis
ping localhost 

set endtime=%time%
set endcsec=%endTIME:~9,2%
set endsecs=%endTIME:~6,2%
set endmins=%endTIME:~3,2%
set endhour=%endTIME:~0,2%
if %endhour% LSS %starthour% set /a endhour+=24
set /a endtime=(%endhour%*60*60*100)+(%endmins%*60*100)+(%endsecs%*100)+(%endcsec%)

set /a timetaken= ( %endtime% - %starttime% )
set /a timetakens= %timetaken% / 100
set timetaken=%timetakens%.%timetaken:~-2%

echo.
echo Took: %timetaken% sec.
driblio
fuente
55
Impresionante, pero no creo que funcione si hay un 08 o 09 en las horas de inicio o finalización porque se interpretan como octales. Mi respuesta maneja eso :)
Luke Sampson
6

Aquí hay un

Versión del temporizador Postfix:

Ejemplo de uso:

tiempo de espera 1 | TimeIt.cmd

Execution took  ~969 milliseconds.

Copie y pegue esto en algún editor como, por ejemplo, Notepad ++ y guárdelo como TimeIt.cmd :

:: --- TimeIt.cmd ----
    @echo off
    setlocal enabledelayedexpansion

    call :ShowHelp

    :: Set pipeline initialization time
    set t1=%time%

    :: Wait for stdin
    more

    :: Set time at which stdin was ready
    set t2=!time!


    :: Calculate difference
    Call :GetMSeconds Tms1 t1
    Call :GetMSeconds Tms2 t2

    set /a deltaMSecs=%Tms2%-%Tms1%
    echo Execution took ~ %deltaMSecs% milliseconds.

    endlocal
goto :eof

:GetMSeconds
    Call :Parse        TimeAsArgs %2
    Call :CalcMSeconds %1 %TimeAsArgs%

goto :eof

:CalcMSeconds
    set /a %1= (%2 * 3600*1000) + (%3 * 60*1000) + (%4 * 1000) + (%5)
goto :eof

:Parse

    :: Mask time like " 0:23:29,12"
    set %1=!%2: 0=0!

    :: Replace time separators with " "
    set %1=!%1::= !
    set %1=!%1:.= !
    set %1=!%1:,= !

    :: Delete leading zero - so it'll not parsed as octal later
    set %1=!%1: 0= !
goto :eof

:ShowHelp
    echo %~n0 V1.0 [Dez 2015]
    echo.
    echo Usage: ^<Command^> ^| %~nx0
    echo.
    echo Wait for pipe getting ready... :)
    echo  (Press Ctrl+Z ^<Enter^> to Cancel)
goto :eof

^ - Basado en la versión 'Daniel Sparks'

Nadu
fuente
5

Una alternativa al tiempo de medición es simplemente "Get-Date". No tiene esa molestia con el envío de salida, etc.

$start = Get-Date
[System.Threading.Thread]::Sleep(1500)
$(Get-Date) - $start

Salida:

Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 1
Milliseconds      : 506
Ticks             : 15060003
TotalDays         : 1.74305590277778E-05
TotalHours        : 0.000418333416666667
TotalMinutes      : 0.025100005
TotalSeconds      : 1.5060003
TotalMilliseconds : 1506.0003
Rainer
fuente
Esto fue perfecto para mí
Brett Rowberry el
4

Esta es una línea que evita la expansión retrasada , lo que podría alterar ciertos comandos:

cmd /E /C "prompt $T$$ & echo.%TIME%$ & COMMAND_TO_MEASURE & for %Z in (.) do rem/ "

La salida es algo así como:

14:30:27.58$
...
14:32:43.17$ rem/ 

Para las pruebas a largo plazo reemplazan $Tpor $D, $Ty %TIME%por %DATE%, %TIME%incluir la fecha.

Para usar esto dentro de un archivo por lotes , reemplácelo %Zpor %%Z.


Actualizar

Aquí hay una línea mejorada (sin expansión tardía también):

cmd /E /C "prompt $D, $T$$ & (for %# in (.) do rem/ ) & COMMAND_TO_MEASURE & for %# in (.) do prompt"

El resultado es similar a esto:

2015/09/01, 14:30:27.58$ rem/ 
...
2015/09/01, 14:32:43.17$ prompt

Este enfoque no incluye el proceso de instanciar una nueva cmden el resultado, ni incluye los promptcomandos.

aschipfl
fuente
4

Dependiendo de la versión de Windows que esté usando, solo ejecutarlo bashlo pondrá en modo Bash. Esto le permitirá usar un montón de comandos que no están disponibles en PowerShell directamente (como el timecomando). Sincronizar su comando ahora es tan fácil como ejecutar:

# The clause <your-command> (without the angle brackets) denotes the command you want to run.
$ time <your-command>

Nota: Puede salir fácilmente del modo Bash y volver a su shell principal ejecutando exitmientras está en modo Bash.

Esto funcionó perfectamente para mí (Windows 10) después de probar otros métodos (como Measure-Command) que a veces producen estadísticas no deseadas. Espero que esto también funcione para ti.

Saddam M
fuente
2
A partir de Windows 10 1607 la mejor respuesta.
CarpeDiemKopi
2

En caso de que alguien más haya venido aquí buscando una respuesta a esta pregunta, hay una función API de Windows llamada GetProcessTimes(). No parece demasiado trabajo escribir un pequeño programa en C que inicie el comando, realice esta llamada y devuelva los tiempos de proceso.

Jeff Pratt
fuente
3
No parece demasiado trabajo descargar un pequeño programa en C que iniciaría el comando, realizaría esta llamada (y muchas más mediciones avanzadas) y devolvería los tiempos de proceso.
Elazar Leibovich
@ElazarLeibovich powershell? Puedes llamarlo desde C #.
KeyWeeUsr
@KeyWeeUsr puede usar Windows API IIRC desde PS blogs.technet.microsoft.com/heyscriptingguy/2013/06/25/…
Elazar Leibovich
2

Este es un comentario / edición a Luke Sampson agradable timecmd.baty responde a

Por alguna razón, esto solo me da salida en segundos completos ... lo que para mí es inútil. Quiero decir que ejecuto pausa timecmd, y siempre resulta en 1.00 segundos, 2.00 segundos, 4.00 segundos ... ¡incluso 0.00 segundos! Windows 7. - Camilo Martin Sep 25 '13 a las 16:00 "

En algunas configuraciones, los delimitadores pueden diferir. El siguiente cambio debería cubrir al menos la mayoría de los países occidentales.

set options="tokens=1-4 delims=:,." (added comma)

Los %time%milisegundos funcionan en mi sistema después de agregar que ','

(* porque el sitio no permite comentarios anónimos y no mantiene un buen seguimiento de la identidad a pesar de que siempre uso el mismo correo electrónico de invitado que combinado con ipv6 ip y la huella digital del navegador deberían ser suficientes para identificarme sin contraseña)

Cobarde anónimo
fuente
Comenté justo eso antes de desplazarme a tu respuesta. De todos modos, el guión de Luke podría poner a cero horas, minutos y segundos, no solo los segundos (que son centisegundos y no milisegundos, por cierto). Ver aquí: en.wiktionary.org/wiki/centisecond
Tomasz Gandor
2

Aquí está mi método, sin conversión y sin ms. Es útil para determinar las duraciones de codificación (aunque limitado a 24 horas):

@echo off

:start
REM Start time storage
set ST=%time%
echo Process started at %ST%
echo.
echo.

REM Your commands
REM Your commands
REM Your commands

:end
REM Start Time Definition
for /f "tokens=1-3 delims=:" %%a in ("%ST%") do set /a h1=%%a & set /a m1=%%b & set /a s1=%%c

REM End Time Definition
for /f "tokens=1-3 delims=:" %%a in ("%TIME%") do set /a h2=%%a & set /a m2=%%b & set /a s2=%%c

REM Difference
set /a h3=%h2%-%h1% & set /a m3=%m2%-%m1% & set /a s3=%s2%-%s1%

REM Time Adjustment
if %h3% LSS 0 set /a h3=%h3%+24
if %m3% LSS 0 set /a m3=%m3%+60 & set /a h3=%h3%-1
if %s3% LSS 0 set /a s3=%s3%+60 & set /a m3=%m3%-1

echo Start    :    %ST%
echo End    :    %time%
echo.
echo Total    :    %h3%:%m3%:%s3%
echo.
pause
ilko
fuente
1
@echo off & setlocal

set start=%time%

REM Do stuff to be timed here.
REM Alternatively, uncomment the line below to be able to
REM pass in the command to be timed when running this script.
REM cmd /c %*

set end=%time%

REM Calculate time taken in seconds, to the hundredth of a second.
REM Assumes start time and end time will be on the same day.

set options="tokens=1-4 delims=:."

for /f %options% %%a in ("%start%") do (
    set /a start_s="(100%%a %% 100)*3600 + (100%%b %% 100)*60 + (100%%c %% 100)"
    set /a start_hs=100%%d %% 100
)

for /f %options% %%a in ("%end%") do (
    set /a end_s="(100%%a %% 100)*3600 + (100%%b %% 100)*60 + (100%%c %% 100)"
    set /a end_hs=100%%d %% 100
)

set /a s=%end_s%-%start_s%
set /a hs=%end_hs%-%start_hs%

if %hs% lss 0 (
    set /a s=%s%-1
    set /a hs=100%hs%
)
if 1%hs% lss 100 set hs=0%hs%

echo.
echo  Time taken: %s%.%hs% secs
echo.
MikeM
fuente
No funciona. Obtención: paréntesis desequilibrado. Paréntesis desequilibrado. Falta operando.
Richard Sandoz
@RichardSandoz Funciona bien, no hay paréntesis desequilibrados. ¿Cómo lo estás utilizando?
MikeM
1

El siguiente script usa solo "cmd.exe" y genera el número de milisegundos desde el momento en que se crea una canalización hasta el momento en que se cierra el proceso que precede al script. es decir, escriba su comando y canalice el al script. Ejemplo: "timeout 3 | runtime.cmd" debería producir algo como "2990". Si necesita tanto la salida de tiempo de ejecución como la salida de stdin, redirija el stdin antes de la tubería, por ejemplo: "dir / s 1> temp.txt | runtime.cmd" volcaría la salida del comando "dir" a "temp.txt" e imprimiría el tiempo de ejecución en la consola.

:: --- runtime.cmd ----
@echo off
setlocal enabledelayedexpansion

:: find target for recursive calls
if not "%1"=="" (
    shift /1
    goto :%1
    exit /b
)

:: set pipeline initialization time
set t1=%time%

:: wait for stdin
more > nul

:: set time at which stdin was ready
set t2=!time!

::parse t1
set t1=!t1::= !
set t1=!t1:.= !
set t1=!t1: 0= !

:: parse t2
set t2=!t2::= !
set t2=!t2:.= !
set t2=!t2: 0= !

:: calc difference
pushd %~dp0
for /f %%i in ('%0 calc !t1!') do for /f %%j in ('%0 calc !t2!') do (
    set /a t=%%j-%%i
    echo !t!
)
popd
exit /b
goto :eof

:calc
set /a t=(%1*(3600*1000))+(%2*(60*1000))+(%3*1000)+(%4)
echo !t!
goto :eof

endlocal
Daniel Sparks
fuente
Bueno, en lugar de llamar recursivamente al guión, considera hacerlo así call :calc. Yo hice eso aquí. El código de enlace es más agradable de esta manera. : D
Nadu
Error # 1 Fallará a las 12 horas. Ejemplo: " 0 : 23: 19,42" Error # 2 fallará si el punto decimal es otra cosa que. mismo ejemplo: "0:23:19 , 42" aquí el punto decimal es, <__________> Bien intentado editar sin embargo ese tonto **** en la 'comisión de aprobación de edición' lo rechazó - 3 de 5 votaron "Esta edición también cambia gran parte de la intención original de los autores ". así que si tienes ganas de probar suerte editando o simplemente mantener los errores, entonces la 'intención original del autor permanece intacta'. facepalm
Nadu
No puede generar milisegundos cuando la resolución de su reloj apenas es capaz de 1/100 segundos de resolución.
jwdonahue
1

La respuesta de driblio puede hacerse un poco más corta (aunque no muy legible)

@echo off

:: Calculate the start timestamp
set _time=%time%
set /a _hours=100%_time:~0,2%%%100,_min=100%_time:~3,2%%%100,_sec=100%_time:~6,2%%%100,_cs=%_time:~9,2%
set /a _started=_hours*60*60*100+_min*60*100+_sec*100+_cs


:: yourCommandHere


:: Calculate the difference in cSeconds
set _time=%time%
set /a _hours=100%_time:~0,2%%%100,_min=100%_time:~3,2%%%100,_sec=100%_time:~6,2%%%100,_cs=%_time:~9,2%
set /a _duration=_hours*60*60*100+_min*60*100+_sec*100+_cs-_started

:: Populate variables for rendering (100+ needed for padding)
set /a _hours=_duration/60/60/100,_min=100+_duration/60/100%%60,_sec=100+(_duration/100%%60%%60),_cs=100+_duration%%100

echo Done at: %_time% took : %_hours%:%_min:~-2%:%_sec:~-2%.%_cs:~-2%

::prints something like:
::Done at: 12:37:53,70 took: 0:02:03.55

Para el comentario de Luke Sampson, esta versión es segura para los ojos, aunque la tarea debe completarse en 24 horas.

Alejandro
fuente
No funciona. Falta operador cuando hora de un solo dígito.
Richard Sandoz
set _time=%time: =0%soluciona el problema de la hora de un solo dígito: reemplácelo en ambos lugares.
Laur
1
  1. En el directorio donde está su programa, escriba notepad mytimer.bat, haga clic en 'sí' para crear un nuevo archivo.

  2. Pegue el código a continuación, reemplácelo YourApp.execon su programa, luego guárdelo.

    @echo off
    date /t
    time /t
    YourApp.exe
    date /t
    time /t
  3. Escriba mytimer.batla línea de comando y luego presione Entrar.

Peter Mortensen
fuente
77
time / t solo te da tiempo en HH: MM. Para cronometrar un ejecutable, generalmente necesita más precisión ... ¿Hay algo que pueda configurar para reducir las fracciones de segundo? Probé la solución de JohnW (time <nul), y eso realmente reduce el tiempo a 1 / 100s: HH: MM: SS.XX
asombro
1

mi código le da el tiempo de ejecución en milisegundos, hasta 24 horas, es insensible a la configuración regional y tiene en cuenta los valores negativos si el código se ejecuta hasta la medianoche. usa expansión demorada y debe guardarse en un archivo cmd / bat.

antes de su código:

SETLOCAL EnableDelayedExpansion

for /f "tokens=2 delims==" %%I in ('wmic os get localdatetime /format:list') do set t=%%I
set /a t1 = %t:~8,1%*36000 + %t:~9,1%*3600 + %t:~10,1%*600 + %t:~11,1%*60 + %t:~12,1%*10 + %t:~13,1% && set t1=!t1!%t:~15,3%

después de tu código:

for /f "tokens=2 delims==" %%I in ('wmic os get localdatetime /format:list') do set t=%%I
set /a t2 = %t:~8,1%*36000 + %t:~9,1%*3600 + %t:~10,1%*600 + %t:~11,1%*60 + %t:~12,1%*10 + %t:~13,1% && set t2=!t2!%t:~15,3%
set /a t2-=t1 && if !t2! lss 0 set /a t2+=24*3600000

si desea tiempo de ejecución en formato HH: mm: ss.000, agregue:

set /a "h=t2/3600000,t2%%=3600000,m=t2/60000,t2%%=60000" && set t2=00000!t2!&& set t2=!t2:~-5!
if %h% leq 9 (set h=0%h%) && if %m% leq 9 (set m=0%m%)
set t2=%h%:%m%:%t2:~0,2%.%t2:~2,3%

ENDLOCAL

variable t2contiene su tiempo de ejecución, puede echo %t2%mostrarlo.

robotik
fuente
1

Una vez que Perl haya instalado la solución de contrataciones disponible, ejecute:

C:\BATCH>time.pl "echo Fine result"
0.01063
Fine result

STDERR viene antes de los segundos medidos

#!/usr/bin/perl -w

use Time::HiRes qw();
my $T0 = [ Time::HiRes::gettimeofday ];

my $stdout = `@ARGV`;

my $time_elapsed = Time::HiRes::tv_interval( $T0 );

print $time_elapsed, "\n";
print $stdout;
Victor Mironov
fuente
0

Usando un sub para devolver el tiempo en centésimas de segundo

::tiemeit.cmd
@echo off
Setlocal EnableDelayedExpansion

call :clock 

::call your_command  or more > null to pipe this batch after your_command

call :clock

echo %timed%
pause
goto:eof

:clock
if not defined timed set timed=0
for /F "tokens=1-4 delims=:.," %%a in ("%time%") do ( 
set /A timed = "(((1%%a - 100) * 60 + (1%%b - 100)) * 60 + (1%%c - 100))  * 100 + (1%%d - 100)- %timed%"
)
goto:eof
Antoni Gual Via
fuente
0

TIMER "Lean and Mean" con formato regional, 24 horas y soporte de entrada mixta
Adaptación de Aacini cuerpo del método de sustitución , sin IF, solo uno FOR (mi solución regional)

1: archivo timer.bat colocado en algún lugar en% PATH% o el directorio actual

@echo off & rem :AveYo: compact timer function with Regional format, 24-hours and mixed input support
if not defined timer_set (if not "%~1"=="" (call set "timer_set=%~1") else set "timer_set=%TIME: =0%") & goto :eof
(if not "%~1"=="" (call set "timer_end=%~1") else set "timer_end=%TIME: =0%") & setlocal EnableDelayedExpansion
for /f "tokens=1-6 delims=0123456789" %%i in ("%timer_end%%timer_set%") do (set CE=%%i&set DE=%%k&set CS=%%l&set DS=%%n)
set "TE=!timer_end:%DE%=%%100)*100+1!"     & set "TS=!timer_set:%DS%=%%100)*100+1!"
set/A "T=((((10!TE:%CE%=%%100)*60+1!%%100)-((((10!TS:%CS%=%%100)*60+1!%%100)" & set/A "T=!T:-=8640000-!"
set/A "cc=T%%100+100,T/=100,ss=T%%60+100,T/=60,mm=T%%60+100,hh=T/60+100"
set "value=!hh:~1!%CE%!mm:~1!%CE%!ss:~1!%DE%!cc:~1!" & if "%~2"=="" echo/!value!
endlocal & set "timer_end=%value%" & set "timer_set=" & goto :eof

Uso:
timer & echo start_cmds & timeout / t 3 & echo end_cmds & timer
timer & timer "23: 23: 23,00"
timer "23: 23: 23,00" y timer
timer "13.23.23,00" y timer "03: 03: 03.00"
temporizador y temporizador "0: 00: 00.00" no y cmd / v: on / c echo hasta medianoche =! Timer_end!
La entrada ahora se puede mezclar, para aquellos cambios de formato de tiempo improbables pero posibles durante la ejecución

2: Función : temporizador incluido con el script por lotes (uso de muestra a continuación):

@echo off
set "TIMER=call :timer" & rem short macro
echo.
echo EXAMPLE:
call :timer
timeout /t 3 >nul & rem Any process here..
call :timer
echo.
echo SHORT MACRO:
%TIMER% & timeout /t 1 & %TIMER% 
echo.
echo TEST INPUT:
set "start=22:04:04.58"
set "end=04.22.44,22"
echo %start% ~ start & echo %end% ~ end
call :timer "%start%"
call :timer "%end%"
echo.
%TIMER% & %TIMER% "00:00:00.00" no 
echo UNTIL MIDNIGHT: %timer_end%
echo.
pause 
exit /b

:: para probarlo, copie y pegue las secciones de código arriba y abajo

rem :AveYo: compact timer function with Regional format, 24-hours and mixed input support 
:timer Usage " call :timer [input - optional] [no - optional]" :i Result printed on second call, saved to timer_end 
if not defined timer_set (if not "%~1"=="" (call set "timer_set=%~1") else set "timer_set=%TIME: =0%") & goto :eof
(if not "%~1"=="" (call set "timer_end=%~1") else set "timer_end=%TIME: =0%") & setlocal EnableDelayedExpansion
for /f "tokens=1-6 delims=0123456789" %%i in ("%timer_end%%timer_set%") do (set CE=%%i&set DE=%%k&set CS=%%l&set DS=%%n)
set "TE=!timer_end:%DE%=%%100)*100+1!"     & set "TS=!timer_set:%DS%=%%100)*100+1!"
set/A "T=((((10!TE:%CE%=%%100)*60+1!%%100)-((((10!TS:%CS%=%%100)*60+1!%%100)" & set/A "T=!T:-=8640000-!"
set/A "cc=T%%100+100,T/=100,ss=T%%60+100,T/=60,mm=T%%60+100,hh=T/60+100"
set "value=!hh:~1!%CE%!mm:~1!%CE%!ss:~1!%DE%!cc:~1!" & if "%~2"=="" echo/!value!
endlocal & set "timer_end=%value%" & set "timer_set=" & goto :eof

CE, DE y CS, DS significan punto final, punto final y conjunto de dos puntos, conjunto de puntos: se utiliza para compatibilidad con formatos mixtos

AveYo
fuente
0

El siguiente script emula * nix epoch time, pero es local y regional. Debe manejar los casos de borde de calendario, incluidos los años bisiestos. Si Cygwin está disponible, los valores de época se pueden comparar especificando Cygwin opción .

Estoy en EST y la diferencia reportada es de 4 horas, lo cual es relativamente correcto. Hay algunas soluciones interesantes para eliminar el TZ y las dependencias regionales, pero no noté nada trivial.

@ECHO off
SETLOCAL EnableDelayedExpansion

::
::  Emulates local epoch seconds
::

:: Call passing local date and time
CALL :SECONDS "%DATE%" "%TIME%"
IF !SECONDS! LEQ 0 GOTO END

:: Not testing - print and exit
IF NOT "%~1"=="cygwin" (
    ECHO !SECONDS!
    GOTO END
)

:: Call on Cygwin to get epoch time
FOR /F %%c IN ('C:\cygwin\bin\date +%%s') DO SET EPOCH=%%c

:: Show the results
ECHO Local Seconds: !SECONDS!
ECHO Epoch Seconds: !EPOCH!

:: Calculate difference between script and Cygwin
SET /A HOURS=(!EPOCH!-!SECONDS!)/3600
SET /A FRAC=(!EPOCH!-!SECONDS!)%%3600

:: Delta hours shown reflect TZ
ECHO Delta Hours: !HOURS! Remainder: !FRAC!

GOTO END

:SECONDS
SETLOCAL  EnableDelayedExpansion

    :: Expecting values from caller
    SET DATE=%~1
    SET TIME=%~2

    :: Emulate Unix epoch time without considering TZ
    SET "SINCE_YEAR=1970"

    :: Regional constraint! Expecting date and time in the following formats:
    ::   Sun 03/08/2015   Day MM/DD/YYYY
    ::   20:04:53.64         HH:MM:SS
    SET VALID_DATE=0
    ECHO !DATE! | FINDSTR /R /C:"^... [0-9 ][0-9]/[0-9 ][0-9]/[0-9][0-9][0-9][0-9]" > nul && SET VALID_DATE=1
    SET VALID_TIME=0
    ECHO !TIME! | FINDSTR /R /C:"^[0-9 ][0-9]:[0-9 ][0-9]:[0-9 ][0-9]" > nul && SET VALID_TIME=1
    IF NOT "!VALID_DATE!!VALID_TIME!"=="11" (
        IF !VALID_DATE! EQU 0  ECHO Unsupported Date value: !DATE! 1>&2
        IF !VALID_TIME! EQU 0  ECHO Unsupported Time value: !TIME! 1>&2
        SET SECONDS=0
        GOTO SECONDS_END
    )

    :: Parse values
    SET "YYYY=!DATE:~10,4!"
    SET "MM=!DATE:~4,2!"
    SET "DD=!DATE:~7,2!"
    SET "HH=!TIME:~0,2!"
    SET "NN=!TIME:~3,2!"
    SET "SS=!TIME:~6,2!"
    SET /A YEARS=!YYYY!-!SINCE_YEAR!
    SET /A DAYS=!YEARS!*365

    :: Bump year if after February  - want leading zeroes for this test
    IF "!MM!!DD!" GEQ "0301" SET /A YEARS+=1

    :: Remove leading zeros that can cause octet probs for SET /A
    FOR %%r IN (MM,DD,HH,NN,SS) DO (
        SET "v=%%r"
        SET "t=!%%r!"
        SET /A N=!t:~0,1!0
        IF 0 EQU !N! SET "!v!=!t:~1!"
    )

    :: Increase days according to number of leap years
    SET /A DAYS+=(!YEARS!+3)/4-(!SINCE_YEAR!%%4+3)/4

    :: Increase days by preceding months of current year
    FOR %%n IN (31:1,28:2,31:3,30:4,31:5,30:6,31:7,31:8,30:9,31:10,30:11) DO (
        SET "n=%%n"
        IF !MM! GTR !n:~3! SET /A DAYS+=!n:~0,2!
    )

    :: Multiply and add it all together
    SET /A SECONDS=(!DAYS!+!DD!-1)*86400+!HH!*3600+!NN!*60+!SS!

:SECONDS_END
ENDLOCAL & SET "SECONDS=%SECONDS%"
GOTO :EOF

:END
ENDLOCAL
bvj
fuente
Curioso sobre el voto negativo. Gracias.
bvj
0

Una solución que usa PHP puro para cmd y una env. variable:

@echo off
setlocal enableextensions

REM set start time env var
FOR /F "tokens=* USEBACKQ" %%F IN (`php -r "echo microtime(true);"`) DO ( SET start_time=%%F )

## PUT_HERE_THE_COMMAND_TO_RUN ##

REM echo elapsed time
php -r "echo 'elapsed: ' . (round(microtime(true) - trim(getenv('start_time')), 2)) . ' seconds' . mb_convert_encoding('&#13;&#10;', 'UTF-8', 'HTML-ENTITIES');"
  • sin necesidad de cygwin o utilidades no confiables. Útil cuando PHP está disponible localmente

  • la precisión y el formato de salida se pueden ajustar fácilmente

  • la misma idea se puede portar para PowerShell

mvorisek
fuente