time - online - Lua-Hora actual en milisegundos

tiempo unix

Question

¿Hay alguna forma común de obtener la hora actual en milisegundos o con ella?

Hay os.time() , pero solo proporciona segundos completos.

Answer 1

lua obtener milisegundo

os.time ()

os.time()
return sec //only

posix.lock_gettime (clk)

https://luaposix.github.io/luaposix/modules/posix.time.html#clock_gettime

require''posix''.clock_gettime(0)
return sec, nsec

linux / time.h // man clock_gettime

/*
 * The IDs of the various system clocks (for POSIX.1b interval timers):
 */
#define CLOCK_REALTIME                  0
#define CLOCK_MONOTONIC                 1
#define CLOCK_PROCESS_CPUTIME_ID        2
#define CLOCK_THREAD_CPUTIME_ID         3
#define CLOCK_MONOTONIC_RAW             4
#define CLOCK_REALTIME_COARSE           5
#define CLOCK_MONOTONIC_COARSE          6

socket.gettime ()

http://w3.impa.br/~diego/software/luasocket/socket.html#gettime

require''socket''.gettime()
return sec.xxx

como waqas dice

comparar y probar

get_millisecond.lua

local posix=require''posix''
local socket=require''socket''

for i=1,3 do
    print( os.time() )
    print( posix.clock_gettime(0) )
    print( socket.gettime() )
    print''''
    posix.nanosleep(0, 1) -- sec, nsec
end

salida

lua get_millisecond.lua
1490186718
1490186718      268570540
1490186718.2686

1490186718
1490186718      268662191
1490186718.2687

1490186718
1490186718      268782765
1490186718.2688

Answer 2

En el estándar C lua, no. Tendrá que conformarse con segundos, a menos que esté dispuesto a modificar el intérprete lua usted mismo para tener tiempo de usar la resolución que desee. Sin embargo, eso puede ser inaceptable si está escribiendo código para que otras personas lo ejecuten por sí mismas y no algo así como una aplicación web en la que tenga el control total del entorno.

Editar: otra opción es escribir su propia pequeña DLL en C que amplíe lua con una nueva función que le daría los valores que desea, y requiere que se distribuya dll con su código a quien lo vaya a usar.

Answer 3

Hice una solución adecuada para lua en Windows. Básicamente hice lo que sugirió Kevlar, pero con una biblioteca compartida en lugar de una DLL. Esto ha sido probado usando cygwin.

Escribí un código C compatible con lua, lo compilé en una biblioteca compartida (archivo .so vía gcc en cygwin) y luego lo cargué en lua usando package.cpath y requiero "". Escribió un script de adaptador por conveniencia. Aquí está toda la fuente:

primero el código C, HighResTimer.c

////////////////////////////////////////////////////////////////
//HighResTimer.c by Cody Duncan
//
//compile with:  gcc -o Timer.so -shared HighResTimer.c -llua5.1
//compiled in cygwin after installing lua (cant remember if I 
//   installed via setup or if I downloaded and compiled lua, 
//   probably the former)
////////////////////////////////////////////////////////////////
#include <windows.h>

typedef unsigned __int64 u64;
double mNanoSecondsPerCount;

#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"


int prevInit = 0;
int currInit = 0;
u64 prevTime = 0;
u64 currTime = 0;
u64 FrequencyCountPerSec;

LARGE_INTEGER frequencyTemp;
static int readHiResTimerFrequency(lua_State *L)
{
    QueryPerformanceFrequency(&frequencyTemp);
    FrequencyCountPerSec = frequencyTemp.QuadPart;
    lua_pushnumber(L, frequencyTemp.QuadPart);
    return 1;
}

LARGE_INTEGER timerTemp;
static int storeTime(lua_State *L)
{
    QueryPerformanceCounter(&timerTemp);

    if(!prevInit)
    {
        prevInit = 1;
        prevTime = timerTemp.QuadPart;
    }
    else if (!currInit)
    {
        currInit = 1;
        currTime = timerTemp.QuadPart;
    }
    else
    {
        prevTime = currTime;
        currTime = timerTemp.QuadPart;
    }

    lua_pushnumber(L, timerTemp.QuadPart);
    return 1;
}

static int getNanoElapsed(lua_State *L)
{
    double mNanoSecondsPerCount = 1000000000/(double)FrequencyCountPerSec;
    double elapsedNano = (currTime - prevTime)*mNanoSecondsPerCount;
    lua_pushnumber(L, elapsedNano);
    return 1;
}


int luaopen_HighResolutionTimer (lua_State *L) {

    static const luaL_reg mylib [] = 
    {
        {"readHiResTimerFrequency", readHiResTimerFrequency},
        {"storeTime", storeTime},
        {"getNanoElapsed", getNanoElapsed},
        {NULL, NULL}  /* sentinel */
    };

    luaL_register(L,"timer",mylib);

    return 1;
}

-

-

Ahora vamos a cargarlo en un script de lua, HighResTimer.lua.

Nota: compilé HighResTimer.c en una biblioteca compartida, Timer.so

#!/bin/lua
------------------------------------
---HighResTimer.lua by Cody Duncan
---Wraps the High Resolution Timer Functions in
---   Timer.so
------------------------------------

package.cpath = "./Timer.so"     --assuming Timer.so is in the same directory
require "HighResolutionTimer"    --load up the module
timer.readHiResTimerFrequency(); --stores the tickFrequency


--call this before code that is being measured for execution time
function start()
    timer.storeTime();
end

--call this after code that is being measured for execution time
function stop()
    timer.storeTime();
end

--once the prior two functions have been called, call this to get the 
--time elapsed between them in nanoseconds
function getNanosElapsed()
    return timer.getNanoElapsed();
end

-

-

y finalmente, utilice el temporizador, TimerTest.lua.

#!/bin/lua
------------------------------------
---TimerTest.lua by Cody Duncan
---
---HighResTimer.lua and Timer.so must 
---   be in the same directory as 
---   this script.
------------------------------------

require ''./HighResTimer'' 

start();
for i = 0, 3000000 do io.write("") end --do essentially nothing 3million times.
stop();

--divide nanoseconds by 1 million to get milliseconds
executionTime = getNanosElapsed()/1000000; 
io.write("execution time: ", executionTime, "ms/n");

Nota: Todos los comentarios se escribieron después de pegar el código fuente en el editor de publicaciones, por lo que técnicamente esto no se ha probado, pero es de esperar que los comentarios no confundieran nada. Me aseguraré de volver y proporcionar una solución si lo hace.

Answer 4

Kevlar es correcto.

Una alternativa a una DLL personalizada es Lua Alien

Answer 5

Puede usar la función C gettimeofday: http://www.opengroup.org/onlinepubs/000095399/functions/gettimeofday.html

Aquí la biblioteca C ''ul_time'', la función sec_usec reside en la tabla global ''time'' y devuelve segundos, useconds. Copie la carpeta DLL a Lua, ábrala con require ''ul_time''.

http://depositfiles.com/files/3g2fx7dij

Answer 6

Si está usando lua con nginx / openresty, puede usar ngx.now() que devuelve un flotante con precisión de milisegundos

Answer 7

Si quiere hacer un benchmark, puede usar os.clock como lo muestra el documento:

local x = os.clock()
local s = 0
for i=1,100000 do s = s + i end
print(string.format("elapsed time: %.2f/n", os.clock() - x))

Answer 8

Uso LuaSocket para obtener más precisión.

require "socket"
print("Milliseconds: " .. socket.gettime()*1000)

Esto agrega una dependencia, por supuesto, pero funciona bien para uso personal (en scripts de evaluación comparativa, por ejemplo).

Answer 9

en openresty hay una función ngx.req.start_time .

De los documentos:

Devuelve un número de coma flotante que representa la marca de tiempo (incluidos milisegundos como la parte decimal) cuando se creó la solicitud actual.