Sto cercando l'equivalente in Qt per GetTickCount()Ottenere il tempo trascorso in Qt
Qualcosa che mi permetterà di misurare il tempo necessario per un segmento di codice per l'esecuzione come in:
uint start = GetTickCount();
// do something..
uint timeItTook = GetTickCount() - start;
qualche suggerimento?
Che ne dici di QTime? A seconda della piattaforma, dovrebbe avere una precisione di 1 millesimo di secondo. Codice sarebbe simile a questa:
QTime myTimer;
myTimer.start();
// do something..
int nMilliseconds = myTimer.elapsed();
penso che probabilmente è meglio usare QElapsedTimer dato che questo è il motivo per cui la classe esiste in primo luogo. È stato introdotto con Qt 4.7. Si noti che è anche immune al cambio orario dell'orologio del sistema.
Esempio utilizzo:
#include <QDebug>
#include <QElapsedTimer>
...
...
QElapsedTimer timer;
timer.start();
slowOperation(); // we want to measure the time of this slowOperation()
qDebug() << timer.elapsed();
Anche se la prima risposta è stata accettata, il resto delle persone che leggono le risposte dovrebbe considerare sivabudh 's suggerimento.
QElapsedTimer può anche essere utilizzato per calcolare il tempo in nanosecondi.
Esempio di codice:
QElapsedTimer timer;
qint64 nanoSec;
timer.start();
//something happens here
nanoSec = timer.nsecsElapsed();
//printing the result(nanoSec)
//something else happening here
timer.restart();
//some other operation
nanoSec = timer.nsecsElapsed();
Ancora: questo misura in tempo reale, non il tempo della CPU consumato dal processo. –
Lo calcola prendendo il numero di tick del processore che l'applicazione ha consumato e moltiplicando per il numero di nanosecondi per Tick. Misura il tempo della CPU consumato dal processo. –
Misura il tempo trascorso da 'start()', non il tempo consumato dal processo. È un timer in tempo reale. Quando il processo viene anticipato (a causa del multitasking), il tempo continua a passare e QElapsedTimer misurerà anche quello. QElapsedTimer sarebbe praticamente inutile se smettesse di misurare il tempo quando il processo è stato anticipato. –
una strategia generale è quello di chiamare il metodo osservato più volte. 10 chiamate forniscono una precisione di 1,5 ms, 100 una di 0,15 ms.
Questo non sta rispondendo alla domanda. Vuole una funzione per dargli un modo di misurare il tempo delle chiamate; gli stai dicendo come ridurre l'errore in una serie di misurazioni. – itsbruce
Se si desidera utilizzare QElapsedTimer, è necessario considerare il sovraccarico di questa classe.
Ad esempio, il seguente codice eseguito sulla mia macchina:
static qint64 time = 0;
static int count = 0;
QElapsedTimer et;
et.start();
time += et.nsecsElapsed();
if (++count % 10000 == 0)
qDebug() << "timing:" << (time/count) << "ns/call";
mi dà questo output:
timing: 90 ns/call
timing: 89 ns/call
...
Si dovrebbe misurare questo per se stessi e rispettare l'overhead per il vostro tempismo.
Sono d'accordo. Ho provato QElapsedTimer. Sembra avere un sovraccarico associato all'uso della classe. Ma molto minore. La differenza non è molto. Ma QTime sembrava darmi un tempo di esecuzione un po 'più veloce. Ho misurato il codice di sgranatura numerica di 4 metodi (3 volte con QTime e 3 con QElapsedTimer). Il timer QElapsed misurava in media 8,046 secondi e QTime misurava in media 8,016 secondi, con una differenza di 30 ms. Non significativo per la maggior parte degli scopi, ma forse è per la precisione assoluta. Stava eseguendo QT 5.3.1 a 32 bit su un PC Windows 7 64 bit Intel i5. – te7
Vedere la discussione qui http://www.qtcentre.org/threads/62883-Semplice-stopwatch-to-time-some-code?p=278558#post278558 – te7
Spendendo le risposte precedenti, ecco una macro che fa tutto per te.
#include <QDebug>
#include <QElapsedTimer>
#define CONCAT_(x,y) x##y
#define CONCAT(x,y) CONCAT_(x,y)
#define CHECKTIME(x) \
QElapsedTimer CONCAT(sb_, __LINE__); \
CONCAT(sb_, __LINE__).start(); \
x \
qDebug() << __FUNCTION__ << ":" << __LINE__ << " Elapsed time: " << CONCAT(sb_, __LINE__).elapsed() << " ms.";
E quindi è possibile utilizzare semplici come:
CHECKTIME(
// any code
for (int i=0; i<1000; i++)
{
timeConsumingFunc();
}
)
uscita:
onSpeedChanged: 102 Tempo impiegato: 2 ms.
Sulla mia macchina virtuale WinXP sembra avere solo 10 ms di precisione - qualcuno può confermare/negare questo? Ottengo valori di 0, 10 e 20 per un'operazione che sto testando. –
Windows non è accurato come un sistema operativo simile a UNIX durante il cronometraggio. –
IIRC, su Windows XP la risoluzione di clock di sistema riportata in fabbrica è 15ms, ma con alcune semplici chiamate Winapi dipendenti da Windows è ancora possibile ottenere una risoluzione migliore se solo c'è 1ms o meglio RTSC sulla scheda madre – quetzalcoatl