En standard C lua, non. Vous devrez vous contenter de secondes, à moins que vous ne souhaitiez modifier vous-même l’interpréteur lua pour que os.time utilise la résolution souhaitée. Cela peut être inacceptable, cependant, si vous écrivez du code pour que d’autres personnes s’exécutent par elles-mêmes et non comme une application Web où vous avez le plein contrôle de l’environnement.

Edit: une autre option consiste à écrire votre propre petite DLL en C qui étend lua avec une nouvelle fonction qui vous donnerait les valeurs souhaitées, et exiger que la DLL soit dissortingbuée avec votre code à quiconque l’utilisera.

J’utilise LuaSocket pour obtenir plus de précision.

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

Cela ajoute une dépendance bien sûr, mais fonctionne bien pour un usage personnel (dans les scripts de benchmarking par exemple).

Si vous souhaitez effectuer un benchmark, vous pouvez utiliser os.clock comme indiqué par le doc:

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

J’ai fait une solution adaptée pour lua sous Windows. J’ai essentiellement fait ce que Kevlar a suggéré, mais avec une bibliothèque partagée plutôt qu’une DLL. Cela a été testé avec cygwin.

J’ai écrit du code C compatible lua, l’ai compilé dans une bibliothèque partagée (fichier .so via gcc dans cygwin), puis l’ai chargé dans lua en utilisant package.cpath et nécessite “”. A écrit un script d’adaptateur pour plus de commodité. Voici toute la source:

d’abord le code C, HighResTimer.c

 //////////////////////////////////////////////////////////////// //HighResTimer.c by Cody Duncan // //comstack with: gcc -o Timer.so -shared HighResTimer.c -llua5.1 //comstackd in cygwin after installing lua (cant remember if I // installed via setup or if I downloaded and comstackd lua, // probably the former) //////////////////////////////////////////////////////////////// #include  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; } 

–

–

Maintenant, laissez-le charger dans un script lua, HighResTimer.lua.

Remarque: J’ai compilé le fichier HighResTimer.c dans une bibliothèque partagée, 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 

–

–

et enfin, utiliser la 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"); 

Note: Tous les commentaires ont été écrits après avoir collé le code source dans l’éditeur de publication, donc techniquement, cela n’a pas été testé, mais j’espère que les commentaires ne sont pas compliqués. Je serai sûr de revenir et de fournir un correctif si c’est le cas.

lua obtenir milliseconde

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 

comme le dit waqas

comparer et tester

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 

sortie

 lua get_millisecond.lua 1490186718 1490186718 268570540 1490186718.2686 1490186718 1490186718 268662191 1490186718.2687 1490186718 1490186718 268782765 1490186718.2688 

Le Kevlar est correct.

Une alternative à une DLL personnalisée est Lua Alien

Si vous utilisez lua avec nginx / openresty, vous pouvez utiliser ngx.now () qui retourne un flottant avec une précision en millisecondes

dans openresty il y a une fonction ngx.req.start_time .

De la documentation:

Renvoie un nombre à virgule flottante représentant l’horodatage (y compris les millisecondes en tant que partie décimale) lors de la création de la demande en cours.

Vous pouvez utiliser la fonction gettimeofday de C: http://www.opengroup.org/onlinepubs/000095399/functions/gettimeofday.html

Ici, la bibliothèque ‘ul_time’, la fonction sec_usec réside dans la table globale ‘time’ et retourne les secondes, les useconds. Copiez DLL dans le dossier Lua, ouvrez-le avec require ‘ul_time’.

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