[Time] Lua - Ora corrente in millisecondi


Answers

Io uso LuaSocket per ottenere maggiore precisione.

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

Ciò naturalmente aggiunge una dipendenza, ma funziona bene per uso personale (ad esempio negli script di benchmarking).

Question

C'è un modo comune per ottenere l'ora corrente in o con millisecondi?

C'è os.time() , ma fornisce solo secondi interi.




Kevlar è corretto.

Un'alternativa a una DLL personalizzata è Lua Alien




Ho creato una soluzione adatta per lua su Windows. Fondamentalmente ho fatto ciò che suggeriva Kevlar, ma con una libreria condivisa anziché una DLL. Questo è stato testato usando cygwin.

Ho scritto un codice C lua compatibile, lo ho compilato in una libreria condivisa (file .so tramite gcc in cygwin), e poi lo ho caricato in lua usando package.cpath e richiedendo "". Scritto uno script dell'adattatore per comodità. Ecco tutta la fonte:

prima il codice 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;
}

-

-

Ora è possibile caricarlo in uno script lua, HighResTimer.lua.

Nota: ho compilato HighResTimer.c su una libreria condivisa, 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

-

-

e infine, utilizzare il timer, 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: tutti i commenti sono stati scritti dopo aver incollato il codice sorgente nell'editor dei post, quindi tecnicamente non è stato verificato, ma si spera che i commenti non abbiano infastidito nulla. Sarò sicuro di tornare e fornire una correzione se lo fa.