Qual è il modo migliore per uscire da un ciclo dopo un tempo trascorso di 30ms in C ++

StackOverflow https://stackoverflow.com/questions/946167

  •  09-09-2019
  •  | 
  •  

Domanda

Qual è il modo migliore per uscire da un loop come vicino a 30ms possibile in C ++. Polling spinta: microsec_clock? Polling QTIME? Qualcos'altro?

Qualcosa di simile: 

A = now;
for (blah; blah; blah) {
    Blah();
    if (now - A > 30000)
         break;
}

Dovrebbe funzionare su Linux, OS X e Windows.

I calcoli nel circuito sono per aggiornare una simulazione. Ogni 30ms, vorrei aggiornare la finestra.

È stato utile?

Soluzione

Il frammento di codice di esempio in questo link praticamente fa ciò che si vuole:

http://www.cplusplus.com/reference/clibrary/ctime/ orologio /

Tratto dal loro esempio: 

void runwait ( int seconds )
{
   clock_t endwait;
   endwait = clock () + seconds * CLOCKS_PER_SEC ;
   while (clock() < endwait)
   {
      /* Do stuff while waiting */
   }
}

Altri suggerimenti

  

I calcoli nel ciclo sono per   l'aggiornamento di una simulazione. Ogni 30ms, mi piacerebbe   desidera aggiornare la finestra.

Hai pensato di usare le discussioni? Ciò che si descrive sembra l'esempio perfetto del motivo per cui si dovrebbe usare le discussioni al posto di timer.

Il filo processo principale mantiene curando l'interfaccia utente, e hanno una QTimer impostato 30ms per aggiornarlo. Si blocca un QMutex di avere accesso ai dati, esegue l'aggiornamento, e rilascia il mutex.

Il secondo filo (vedi QThread ) fa la simulazione. Per ciascun ciclo, si blocca il QMutex, fa i calcoli e rilascia il mutex quando i dati sono in uno stato stabile (adatto per l'aggiornamento UI).

Con la tendenza su processori multi-core, si dovrebbe pensare sempre più sull'utilizzo di thread sull'utilizzo timer. Le applicazioni benefici automaticamente dalla maggiore potenza (più core) di nuovi processori.

Anche se questo non risponde alla domanda, che potrebbe dare un altro sguardo alla soluzione. Che cosa circa l'inserimento del codice di simulazione e l'interfaccia utente in diversi thread? Se si utilizza Qt, aggiornamento periodico può essere realizzato utilizzando un timer o anche QThread :: msleep ( ) . È possibile adattare il filettato Mandelbrot esempio per soddisfare le vostre necessità.

Se avete bisogno di fare il lavoro fino a quando un certo lasso di tempo, quindi di docflabby risposta è spot-on. Tuttavia, se avete solo bisogno di aspettare, non fare nulla, fino a quando un determinato periodo di tempo è trascorso, quindi si dovrebbe utilizzare usleep()

Risposta breve è: non è possibile, in generale, ma è possibile se si esegue sul sistema operativo destra che a giusto hardware

.

È possibile avvicinarsi a 30ms su tutto il sistema operativo di utilizzare una chiamata di montaggio su sistemi Intel e qualcos'altro su altre architetture. Io scavare il riferimento e modificare la risposta per includere il codice quando lo trovo.

Il problema è l'algoritmo di time-slicing e come vicino alla fine della vostra fetta volta che sono su un multi-tasking OS.

Su alcuni tempo reale OS, c'è una chiamata di sistema in una libreria di sistema si può fare, ma non sono sicuro di quello che sarebbe chiamata.

modifica: LOL! Qualcuno ha già pubblicato un frammento simile su SO: per fornire il tempo in nano secondi utilizzando C ++

VonC ha ottenuto il commento con il codice assembly del timer della CPU in esso.

Secondo la vostra domanda, ogni 30ms si desidera aggiornare la finestra. Ho scritto un'applicazione simile, una volta che l'hardware sondato ogni 500ms per cose simili. Anche se questo non risponde direttamente alla tua domanda, ho le seguenti followup:

  • Sei sicuro che Blah (), per l'aggiornamento del viewport, può eseguire in meno di 30ms in ogni caso?
  • sembra più in esecuzione Blah () sarebbe fatto meglio da un callback timer.
  • E 'molto difficile trovare un oggetto Timer libreria che spingerà su un intervallo di 30 ms per fare gli aggiornamenti in un quadro grafica. In Windows XP ho scoperto che il timer standard di API Win32 che spinge i messaggi di finestra sul timer intervallo di scadenza, anche su un 2 GHz P4, non poteva fare aggiornamenti più veloce di un intervallo di 300ms, non importa quanto in basso ho impostato l'intervallo di sincronizzazione per il Timer. Mentre ci sono stati i timer ad alte prestazioni disponibili nelle API Win32, hanno molte limitazioni, e cioè che non si può fare qualsiasi IPC (come i widget aggiornamento dell'interfaccia utente) in un ciclo come quello che lei citata.
  • In sostanza, il risultato è che devi pianificare con molta attenzione come si desidera avere verificano gli aggiornamenti. Potrebbe essere necessario utilizzare i thread, e guardare come si desidera aggiornare la finestra.

Solo alcune cose a cui pensare. Mi hanno colti di sorpresa quando ho lavorato sul mio progetto. Se avete pensato queste cose attraverso già, si prega di ignorare la mia risposta:. 0)

Si potrebbe prendere in considerazione solo l'aggiornamento del viewport ogni N passi di simulazione piuttosto che ogni millisecondi K. Se questo è (diciamo) una seria applicazione commerciale, allora probabilmente stai andando a voler andare via multi-thread suggerito altrove, ma se (ad esempio) è per uso personale o limitata pubblico e ciò che siete veramente interessati a è i dettagli di ciò che è si sta simulando, poi ogni-N-passi è semplice, portatile e potrebbe essere abbastanza buono per essere andare avanti con.

Vedere QueryPerformanceCounter e QueryPerformanceFrequency

Se si utilizza Qt, ecco un modo semplice per fare questo: 

QTimer* t = new QTimer( parent ) ;
t->setInterval( 30 ) ; // in msec
t->setSingleShot( false ) ;
connect( t, SIGNAL( timeout() ), viewPort, SLOT( redraw() ) ) ;

È necessario specificare viewPort e redraw(). Quindi avviare il timer con t->start().

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top