Pourquoi les horloges sont-elles utilisées dans les ordinateurs?

Comme je le sais, une horloge contrôle toutes les opérations logiques, mais elle limite également la vitesse d'un ordinateur car les portes doivent attendre que l'horloge passe de faible à élevée ou élevée à faible selon le composant. Si aucune horloge n'était incorporée, les portes changeraient aussi vite qu'elles le pourraient chaque fois que la commande leur serait donnée, alors pourquoi cela n'augmenterait-il pas la vitesse des ordinateurs et pourquoi des horloges sont-elles utilisées?

Les horloges sont utilisées dans les ordinateurs pour la simple raison que la plupart sinon la totalité de la circuituité est une logique séquentielle synchrone .

Dans un circuit synchrone, un oscillateur électronique appelé horloge génère une séquence d'impulsions répétitives appelée signal d'horloge qui est distribuée à tous les éléments de mémoire du circuit.

Maintenant, cela peut ne pas sembler satisfaisant et accordé, vous vous demanderez raisonnablement "pourquoi les circuits synchrones sont-ils utilisés dans les ordinateurs?" mais c'est aussi une question facile à répondre :

Le principal avantage de la logique synchrone est sa simplicité. Les portes logiques qui effectuent les opérations sur les données nécessitent un temps limité pour répondre aux modifications de leurs entrées. C'est ce qu'on appelle le retard de propagation. L'intervalle entre les impulsions d'horloge doit être suffisamment long pour que toutes les portes logiques aient le temps de répondre aux changements et que leurs sorties se "stabilisent" à des valeurs logiques stables, avant que l'impulsion d'horloge suivante ne se produise. Tant que cette condition est remplie (en ignorant certains autres détails), le circuit est garanti stable et fiable. Ceci détermine la vitesse de fonctionnement maximale d'un circuit synchrone.

Un domaine de recherche actif est le calcul asynchrone où la plupart sinon la totalité des circuits est une logique séquentielle asynchrone .

Imaginez que vous ayez un entier de 8 bits envoyé de la mémoire à une ALU pour un calcul et (au moins pour cet exemple) que le circuit de mémoire fournit les signaux sur les 8 lignes de données avant que l'ALU ne les requiert et à des moments légèrement différents.

L'utilisation d'une horloge ici garantirait que les 8 lignes de données contenaient la valeur correcte pour l'entier représenté pour un cycle d'horloge et que l'ALU "collecterait" ces données au cours du même cycle d'horloge.

Je me rends compte que ce n'était probablement pas la meilleure description, essentiellement sans une horloge garantissant la cohérence des données serait beaucoup plus difficile que toute augmentation possible de la vitesse en valait la peine, vous rencontriez beaucoup de problèmes de condition de course.

Un circuit comme une unité arithmétique et logique prendra quelques nombres comme entrées et produira un nombre comme sortie. Cela peut garantir que dans un certain laps de temps, tous les bits de la sortie auront atteint leur état final correct, mais le temps réel pour que les bits de sortie deviennent valides peut varier considérablement en fonction d'une variété de facteurs.

Il serait possible de construire une ALU avec une entrée "valide" et une sortie "valide", et de spécifier que si l'entrée "valide" est faible pendant un temps suffisant avant qu'un calcul ne soit effectué, et que les entrées de données contiennent le les valeurs souhaitées avant que l'entrée "valide" ne monte, la sortie "valide" n'ira pas jusqu'à ce que les bits de sortie soient en fait corrects. Une telle conception nécessiterait probablement environ deux fois plus de circuits qu'une ALU conventionnelle [fondamentalement, elle devrait savoir si chaque bit était "connu" pour être nul ou "connu" pour être un; sa sortie "valide" deviendrait vraie une fois que l'état de chaque bit de sortie serait connu].

Pour aggraver les choses, permettre aux parties d'un processeur qui seraient capables de fonctionner plus rapidement de le faire ne sera utile que si elles n'attendent pas tout le temps pour que les parties plus lentes jouent le rattrapage. Pour que cela se produise, il doit y avoir une logique pour décider quelle partie de la machine est "en avance" à un moment donné et sélectionner un plan d'action en fonction de cela. Malheureusement, ce type de décision est l'une des plus difficiles à prendre de manière fiable pour l'électronique. Décider de manière fiable lequel des deux événements s'est produit en premier n'est généralement facile que si l'on peut garantir qu'il n'y aura jamais de "rappels". Supposons qu'un séquenceur de mémoire gère une demande de l'unité de traitement # 1 et que l'unité # 1 ait une autre demande en attente après cela. Si l'unité # 2 soumet une demande avant que la première demande de # 1 ne soit terminée, l'unité de mémoire doit gérer cela; sinon, il devrait traiter la prochaine demande de l'unité n ° 1. Cela semblerait être une conception raisonnable, mais cela finit par être étonnamment problématique. Le problème est que s'il y a un moment tel qu'une demande reçue avant ce moment qui sera traitée immédiatement, et une demande reçue après cela devra attendre, le temps nécessaire pour déterminer si une demande dépasse le délai sera à peu près inversement proportionnelle à la différence entre le moment où la demande a été reçue et le délai. Le temps nécessaire à l'unité de mémoire pour déterminer qu'une demande de # 2 a dépassé le délai d'une femptoseconde peut dépasser considérablement le temps qui aurait été nécessaire pour traiter une deuxième demande de l'unité # 1, mais l'unité ne peut pas traiter l'une ou l'autre demande jusqu'à ce qu'elle décide laquelle traiter en premier.

Le fait que tout fonctionne sur une horloge commune élimine non seulement la nécessité pour les circuits de déterminer quand la sortie d'un calcul est valide, mais permet également d'éliminer les "appels fermés" de synchronisation. Si tout dans le système fonctionne sur une horloge de 100 MHz, aucun signal ne change en réponse à une horloge jusqu'à 1 ns après le front d'horloge, et tout ce qui va se produire en réponse à un front d'horloge se produit dans les 7 ns, alors tout ce qui va se passer avant un un front d'horloge particulier "gagnera" d'au moins 3 ns, et tout ce qui n'arrivera qu'après un front d'horloge "perdra" d'au moins 1 ns. Déterminer si un signal se présente avant ou après l'horloge, lorsqu'il est garanti qu'il ne sera pas "proche", est beaucoup plus facile que de déterminer lequel des deux signaux chronométrés arbitrairement se produit en premier.

Les systèmes numériques peuvent être synchrones ou asynchrones . Sur les systèmes asynchrones, la sortie peut changer à tout moment, différent des systèmes synchrones, qui dépendent de l' horloge pour changer ses sorties.

La plupart des systèmes numériques sont synchrones (même s'ils peuvent avoir des parties asynchrones) car le projet et l'analyse des défauts peuvent être effectués plus facilement, car les sorties ne peuvent changer qu'avec l'horloge.

Je l'ai à peu près copié Digital Systems: Principles and Applications, 10th edition by R. J. Tocci et al.

Eh bien, si vous concevez un système synchrone, vous avez une fréquence d'horloge cible et vous concevez la logique pour effectuer tous les calculs au cours d'un cycle sur une période d'horloge. Cela signifie également que vous devez incorporer une marge de sécurité pour permettre diverses conditions, telles qu'une faible tension d'alimentation, une température élevée et une puce "lente". Les puces synchrones sont conçues pour que le chemin logique le plus long (calcul le plus lent) se termine à temps dans toutes ces conditions défavorables. Par conséquent, lorsque les conditions ne sont pas terribles, vous aurez beaucoup plus de temps / marge entre le moment où la logique termine son fonctionnement et l'horloge suivante verrouille le résultat. Parce que vous (généralement) ne pouvez pas changer votre fréquence d'horloge, vous perdez cette vitesse.

Il existe des paradigmes de logique complètement asynchrone, par exemple celui que je connais est la logique de convention NULL. En utilisant des traits larges pour décrire ce qui se passe, le circuit logique est capable d'identifier quand un calcul est terminé et est capable de créer efficacement ses propres signaux "d'horloge". Cela permet au circuit de fonctionner aussi vite que possible et présente des avantages modestes en termes de puissance et d'interférence électromagnétique. Malheureusement, vous payez une pénalité pour la nature asynchrone en termes de densité de conception ainsi que de performances optimales. De plus, bien que les outils logiciels de conception synchrone et de validation soient matures, une grande partie de la conception et de la validation des conceptions asynchrones est toujours manuelle, ce qui entraîne un effort accru pour la conception et la construction d'une conception asynchrone.

Cela néglige également complètement le cas où parfois vous avez besoin d' une horloge pour qu'une application spécifique soit une référence temporelle. Par exemple, votre carte son ne peut pas fonctionner de manière asynchrone car elle doit mettre à jour l'ADC ou le DAC à une fréquence d'échantillonnage précise et précise, sinon l'audio sera déformé.

Si aucune horloge n'était incorporée, les portes changeraient aussi vite qu'elles le pourraient chaque fois que la commande leur serait donnée, alors pourquoi cela n'augmenterait-il pas la vitesse des ordinateurs et pourquoi des horloges sont-elles utilisées?

Pour le dire simplement: parce que les humains ne sont pas des êtres super intelligents et doivent prendre des raccourcis pour rendre possible la conception de circuits à un milliard d'éléments.

Lorsque nos suzerains de machines montent, ils peuvent très bien se débarrasser de l'horloge, surmonter des minuties minuscules comme rendre un circuit sans horloge pouvant être fabriqué malgré les variations de processus, et profiter de certains gains de vitesse.

Pour développer un peu: les choses discrètes et prévisibles sont plus faciles à analyser et à concevoir rationnellement. Comme énorme avantage supplémentaire, ils s'auto-corrigent (dans ce cas, le timing s'auto-corrige). C'est la raison pour laquelle nous utilisons la logique numérique en premier lieu. (De même, en programmation, nous utilisons souvent des entiers au lieu de virgule flottante, des structures de contrôle familières au lieu de goto-spaghetti et des langages avec quelques règles claires au lieu de langages très "flexibles" où vous n'êtes jamais sûr de ce qui va se passer. jusqu'à ce que le code s'exécute.)