Modo efficace per saltare tick / frames in un loop?

Question

Modo efficace per saltare tick / frames in un loop?

#1 da (2 voti)

1

main does a loop, and every iteration it increments a tick by one

Ad esempio, supponiamo che fosse in python perché è facile scrivere:

def main():
    tick = 0
    while True:
        tick += 1

Voglio attivare molti eventi diversi ogni tick n-in-x.

Quindi potrei saltare le zecche nove-su-dieci usando il modulo:

if ticks % 10 == 0:
    act()

La mia preoccupazione è che l'operazione di modulo è generalmente costosa in informatica. (Immagino sia costoso perché i college mi dicono che la divisione in generale è costosa)

Se avessi, diciamo un migliaio [oh ok un centinaio di miliardi] di casi diversi, non vorrei passare il tempo in eccesso solo per qualificare i casi di zecche.

Ma voglio anche che ogni caso sia ignorante di tutti gli altri casi.

Quindi sono curioso di sapere cosa gli altri potrebbero raccomandare come super-pass-n-out-of-x-ticks.

Nota: Python è solo per un esempio, io sono non interessato ai concetti solo per python .

loops

posta ThorSummoner 06.04.2016 - 07:06

fonte

1 risposta

Leggi altre domande sui tag loops

Inizializzazione oggetto «pesante»: all'interno di ogni thread o all'esterno e quindi passarlo ai thread come parametro? Esprimere complessità in base alla lunghezza della chiave

score 2 · Answer 1

La semplice soluzione per non usare il modulo è mantenere un tick-counter per ogni caso e, quando si innesca, resettarlo a 0.

Un'alternativa è di mantenere il "tempo" del prossimo punto di innesco e incrementare questo punto quando viene attivato. cioè, se vuoi sparare ogni 10 tick, confronta il tick tick a 10 e quando scocca, incrementa la variabile del trigger point a 20. Questo ti fa risparmiare molti contatori che incrementano ma al costo di mantenere i valori di trigger per ogni caso .

Oppure potresti avere un singolo contatore e un singolo punto trigger che viene ricalcolato per riflettere il successivo tempo di innesco. cioè se hai un innesco per sparare ogni 10 zecche e un altro ogni 25 zecche, il punto di innesco verrebbe cambiato in 10, 20, 25, 30 dopo ogni invocazione. Il costo qui viene passato al momento in cui viene attivato il trigger (che presumo sia un'operazione ragionevolmente lunga)

(Ho usato queste tecniche da solo, ma di solito per ritardi temporali in cui il ricalcolo dei valori di data / ora è più intensivo dal punto di vista computazionale rispetto a un intero e il ritardo tra le zecche è relativamente lungo)

Ora questo potrebbe non essere più veloce dell'uso del modulo, il consumo di memoria potrebbe essere sufficiente a causare errori di cache che è un ordine di grandezza maggiore di qualsiasi operazione matematica FPU. Se hai avuto molti, molti casi memorizzati in un array, questo è un probabile risultato.

Naturalmente, potresti essere in grado di usare un po 'più di matematica per gestire il modulo e la tua CPU potrebbe essere migliore o peggiore nel calcolarla . Ad esempio, se il valore del modulo è un multiplo di 2, è possibile utilizzare il bit shifting e il mascheramento per determinare se viene raggiunto un trigger point, ovvero se si attiva ogni 8 tick, quindi il contatore corrisponde se gli ultimi 3 bit sono 0 (ovvero 8 è 00001000, 16 è 00010000, 24 è 00011000 ecc.). Il bit-masking è un'operazione molto veloce.