Question de temps - Page 1

Voilà j'ai besoin d'une fonction capable de sauter un nombre précis de cycles tout en ayant un série de données synchronisé.

Voilà ce que possède la liste de données 1:
120,142,85,41,23 cycles
La liste de données 2:
54,53,65,41,111,230 cycles

On suppose que les listes débutes toutes en même temps au terme 0.
Chaque nombre dans chaque liste représente un octet.

Le but serait pas exemple d'avancer rapidement d'un nombre de cycles déterminé à l'avance (20 je pense) et de trouver dans ce cas le nombre d'octets à sauté et de plus synchroniser correctement les listes, il ne faut absolument pas qu'il y est une marge d'erreur, si il y a une différence de 1 cycle entre chaque liste, c'est pas bon.

Je pense à une méthode barbare, de ce pointer sur l'octet voulu, de récupérer son temps totale et avec une boucle for parcourir cette durées, si dépasse alors octet suivant... mais elle est très lente.
Peut être qu'il y a surement une astuce en faisant un modulo...?

Déjà, tu ne pourras sauter qu'un nombre de n*4 cycles.

Bon disons alors 32 cycles et pourquoi n*4?
Tu as une idée ça m'interesse, même un début pour que j'essaye de commencer?

C juste une question de calculs...

Ah bon, il me suffit d'une piste et je peux avancer, je voudrais un truc le plus précis possible et rapide.

Une instruction prend au minimum 4 cycles, donc ta précision sera de 4 cycles.
Ensuite, tu auras besoin de plus de 4 cycles pour commencer ta temporisation (un saut au milieu d'une séquence de nop [il me semble que c'est ce que Pollux fait] prendra au moins 14 cycles, je pense, par exemple)

Oui, ça c'est assez secondaire mais important en effet, ce que je recherche plutôt c'est que c'est chiffres désigne une durée et qye par exemple si je recule de 32 durées je dois savoir sur quel octet tomber dans les 2 listes et jouer un nombre de cycles correspondant à des durées restante.
En fait il me manque juste le point de départ de l'algo.

Ecrit l'algo de parcourt en asm pur. Compte les cycles pour chaque lecture, puis decompte le temps du calcul lui-meme et du saut.



Bonne chance.

J'oubliais mulu a un temps d'execution variable en plus

Good luck

Une instruction prend au minimum 4 cycles, donc ta précision sera de 4 cycles. Ensuite, tu auras besoin de plus de 4 cycles pour commencer ta temporisation (un saut au milieu d'une séquence de nop [il me semble que c'est ce que Pollux fait] prendra au moins 14 cycles, je pense, par exemple)

C pas terrible... On peut avoir une précision de 2 cycles avec des shifts Donc tu peux toujours commencer par un shift.

J'oubliais mulu a un temps d'execution variable en plus

Par pas de 2 aussi, et vu la différence d'overhead avec lsl, c'est pas une super idée

J'ai appliqué une idée et ça marche du tonnerre.

Explique

Au passage, je note l'idée de Pollux d'utiliser les shifts pour avoir une précision de 2 cycles

Oui j'utilise en effet la même méthode que Pollux avec des section de nop, bien sûr dépendant du processeur donc 12 MHz. En fin de compte je peux me permettre des écarts de cycles.

Non mais l'idée de Pollux ce n'est pas celle des nop, c'est celle d'utiliser les shifts dont le nombre de cycle dépend du décallage, selon un multiple de 2. Ce qui permet d'avoir une précision de 2 cycles (à partir d'un nombre minimum de cycles, tout de même).

Bah tu utilises une instruction de décalage pour te caler à 2 cycles près et après tu peux faire des pas de 4 cycles

Oui, sinon il faut initialiser autant de registres que de shifts si on ne veut utiliser que des shifts, et il y a un gros overhead en plus...

Ouai donc je vais rester dans ma solution de nop.