Alle moderne computers werken synchroon. Dat betekent dat er 1 centrale klok aanwezig in iedere computer die op vaste intervallen pulsen afgeeft. Alle andere onderdelen in je computer ontvangen die puls en sturen of ontvangen gegevens enkel op die pulsen. De klok in iedere PC draait aan 4,77 MHz om exact te zijn.
Natuurlijk draait je processor wat sneller en je RAM ook... Om dat te bereiken wordt dan met multipliers gewerkt: het basissignaal wordt dan als het ware opgesplitst.
Waarom draaien computer synchroon? Wel dat is omdat ieder component "weet" dat data klaar moet zijn op iedere puls. Dus ieder component moet precies binnen 1 puls zijn werk kunnen doen.
Het probleem is dat ieder component verondersteld wordt even snel zijn werk af te krijgen, en dat is natuurlijk niet realistisch. Daarom wordt de maximaal haalbare kloksnelheid deze van het traagste component.
In een asynchrone systeem heb je geen centrale klok. Daarin werkt iedere component aan zijn maximumsnelheid. Meteen heb je wel een timing-probleem:
Beeld je een assemblage-lijn in: om een taak uit te voeren zijn een aantal handelingen nodig die door verschillende mensen gedaan worden (dus verschillende stappen). Vooraleer een taak kan beginnen moet de vorige taak afgewerkt zijn.
In een synchroon systeem is er iemand die op gezette tijden op een trommel slaat. Iedereen weet dat hij zijn werk moet voltooien tussen twee slagen op de trommel. In zo'n systeem heeft iemand die weinig werk te verrichten heeft sneller gedaan, maar dan zit die maar wat te wachten tot er terug op de trommel geslagen wordt (hij moet wachten op de tragere collega's).
In een asynchroon systeem is er geen trommel. Iedereen werkt hier aan zijn maximumsnelheid. Natuurlijk kan niet iedereen even snel zijn werk afhandelen, dus stelt zich een timing-probleem. Momenteel worden er 2 oplossingen aangehaald:
- Tussen iedere 2 personen wordt een voorraad aangelegd. Als de volgende dan trager werkt, dan zal de voorraad telkens aangevuld worden. Voordeel van deze manier van werken is dat de traagste schakel altijd aan het werk blijft waardoor die het minst mogelijke tijd verliest. Hier stelt zich echter wel het probleem dat de voorraadplaats vol dreigt te raken.
- Iedere persoon gebruikt een signaal om aan te geven dat die klaar is om werk te ontvangen van de vorige in de schakel. Pas als dat signaal ontvangen wordt, mag de vorige zijn werk aan hem afgeven. Groen licht wordt pas gegeven wanneer de handelingen van de persoon zelf afgewerkt zijn en wanneer die persoon zijn werk heeft kunnen doorschuiven naar de volgende.
Tegenwoordig worden beide oplossingen samen gebruikt. Voor de taagste componenten wordt een buffer aangelegd. Het trage component neemt het werk uit de buffer zolang er werk in de buffer aanwezig is. Deze persoon geeft groen licht zolang er nog plaats aanwezig is in de buffer. Bij de snelste componenten hoef je dan geen buffer te hebben en heb je enkel het groen-licht signaal.
Het systeem zoals hier uitgelegd is nog niet compleet, en is dus wat simplistisch (bv. er moet nog een signaal zijn die gegeven wordt door iedere persoon aan de volgende om aan te geven dat er werk klaarstaat). Hieruit zou je echter wel een idee moeten krijgen van de extra complexiteit van een asynchroon systeem.
Een aantal gevolgen ervan zijn:
- Je kan de performance van een chip niet meer uitdrukken in Hz: iedere component werkt immers steeds aan zijn maximumsnelheid.
- Doordat de traagste componenten steeds aan hun maximumsnelheid werken worden ze ook beter benut waardoor je de bottleneck niet verergert.