Votre question

[Tutoriel] Architecture Globale + Annexe (Dafen)

Tags :
  • Architecture
  • Matériel
Dernière réponse : dans Matériel informatique
18 Mars 2009 20:16:51

Architecture


L’architecture de l’ordinateur, c’est simplement la manière dont est organisée la structure d’un PC :

  • Les composants qu’il comporte ;
  • La manière dont ils sont reliés et leurs relations ;
  • La place de chaque composant dans la structure.

    Introduction : Pour être très général, dans un PC, on retrouve divers composants qui fonctionnent ensemble, afin de produire au final, quelque chose qui fonctionne. On a une partie purement physique, composants, transistors ; et une partie logicielle, du bas niveau au haut niveau, c’est-à-dire, des micro-instructions interprétées en signaux électriques permettant la circulation de l’information, aux langages évolués dits de « haut niveau » qui contiennent des instructions parfois très complexes (du moins pour un processeur) nécessitant d’être interprétées ou traduites par des logiciels spécifiques.
    Partant de ce principe, on peut s’imaginer (ou interpréter cette structure) des couches qui font le passage d’un niveau à l’autre (pas forcément du physique au logiciel, car les deux se confondent souvent).

    Commençons par étudier brièvement les divers composants d’un PC pour établir son architecture.
    Les principaux composants d’un PC actuel sont :

  • Le processeur ;
  • Les mémoires ;
  • Les périphériques d’E/S (Entrée/Sortie).

    Le processeur


    Tout d’abord, il faut savoir que dans le boîtier de notre ordinateur, nous avons une grande carte de circuits imprimés, appelée plus communément Carte Mère, qui permet grâce à ses circuits imprimés le stockage de tous les composants destinés au fonctionnement du PC. Permettant la communication entre ceux-ci, on la nomme comme étant le « Système nerveux » du PC. En vérité, ce sont les Bus (des fils) qui permettent une communication plus ou moins rapide selon leur « largeur » (le nombre de fils) et surtout selon leur cycle d'horloge (Hz).

    Voyons maintenant le « Cerveau » du PC, appelé Processeur ou MicroProcesseur, appelé encore CPU (Central Processing Unit) . C’est cette puce qui contient des dizaines de millions de transistors qui interprète, traite et exécute les instructions stockées en mémoire.

    Le Processeur est composé de deux éléments principaux :

  • L’unité de Commande ;
  • L’UAL (Unité arithmétique et logique).

    Dans chacun de ces éléments, on retrouve de très petites mémoires, mais très rapides, appelés Registres, qui vont notamment servir d’unité de stockage. Ainsi, plus les registres sont larges, plus le débit d’informations stocké est élevé. Les registres ont de faibles capacités de stockage de plusieurs octets (8, 16, 32, 64). Aujourd’hui, on a globalement des tailles de registres qui varient de 32 octets à 64 octets selon les PC, ce qui permet de stocker des instructions plus grandes (nombres plus grands).

    L’Unité de Commande permet l’extraction d’instructions dans la mémoire et son décodage (en deux étapes).
    L’UAL va servir aux opérations élémentaires (addition, soustraction etc.) à partir des informations décodées.
    L’introduction d’un/des pipeline(s) dans le processeur va servir à coordonner (anticiper) ces actions pour atteindre un seuil de vitesse plus élevé, nous allons voir en quoi.

    Étudions en premier lieu l’Unité de Commande. Avant de parler de ses principaux registres, il faut savoir que pour traiter une instruction, il faut déjà aller la chercher. Les programmes/fichiers exécutés étant stockés en mémoire principale (vive), c’est dans la mémoire que l’UC (processeur) doit aller chercher les millions/milliards d’instructions à exécuter. C’est par le biais du Bus que l’UC parvient à localiser et à aller chercher (Fetch) son/ses instruction(s). On a donc une certaine latence (considérée comme longue) pendant cet accès à la mémoire.

    L’unité de commandes possède donc grossièrement deux étapes :

  • La recherche de l’instruction (FETCH)
  • Le décodage de l’instruction (DECODE), qui se divise en deux parties :
    - Analyse du type d’instruction ;
    - Analyse des paramètres/définition des opérandes.

    FETCH : Dans l’Unité de Commandes, on a un registre très important appelé Registre IP (Instruction Pointer) ou CO (Compteur Ordinal) qui pointe sur la prochaine instruction à aller chercher en mémoire et à exécuter. Il contient donc l’adresse en mémoire de l’instruction. Cette étape FETCH (ou PREFETCH = anticiper) consiste donc en un transfert de l’instruction de la mémoire principale au processeur par le biais du BUS mémoire (le plus rapide) et du FSB. C’est le Registre RI (Registre Instruction) qui va stocker cette instruction à exécuter.

    DECODE : Partons maintenant de ce registre RI (nous sommes donc toujours dans l’Unité de Commandes). Nous avons stocké une instruction, mais avant de l’exécuter, il faut définir plusieurs choses, notamment le type d’instruction et les opérandes.
    Les opérandes sont des paramètres (arguments) sur lesquelles repose l’instruction, cela peut être des adresses mémoire, des registres, valeurs littérales, étiquettes. On ne peut définir une opérande sans définir le type d’instruction. C’est pour cette raison qu’on obtient cet ordre logique.

    - En premier lieu, on a le « décodeur » (interpréteur) qui va définir le type d’instruction (OPCode = Code Opérateur). Par exemple, pour les processeurs Intel x86, on retrouve les instructions dites MMX (MultiMedia eXtensions) [calculs scalaires entiers]. On appelle ça un Jeu d’instructions. Un processeur est donc défini entre autres, par son jeu d’instructions (le type d’instructions qu’il peut gérer). 3Dnow ! est un jeu d’instructions AMD. (Les deux grandes familles de processeurs en concurrence)
    Prenons maintenant un exemple d’instruction, une instruction Assembleur (dont les opérandes sont une adresse mémoire et un Registre) : MOV AX, 0013h
    Ici, le décodeur définit que l’instruction est de type MOV AX. (déplacer vers le registre AX : Partie basse de 16 bits du Registre EAX (accumulateur)).

    - En deuxième lieu, on définit les opérandes. Ici, par exemple, on a un Registre (AX) et une adresse mémoire (0013h). En effet, une opérande peut faire partie d’une instruction, car ici, MOV AX est une instruction. Ce qui fait qu’en fait, une fois traduit, l’instruction n’a qu’un seul paramètre (opérande) puisque l’instruction a une opérande par défaut.

    Voici comment cela se passe grossomodo pour l’Unité de Commandes. Maintenant, il reste à exécuter l’instruction (par l’intermédiaire de ses opérandes notamment) et de mettre à jour les registres.

    Passons donc à l’UAL (unité de calcul), c’est cette unité qui va intervenir dans la deuxième étape du traitement d’une instruction. Les données extraites de l’instruction par le décodeur (les opérandes) vont cette fois-ci être stockées dans des Registres généraux (prévus pour ces calculs) qui vont subir une/des opération(s) par l’UAL définie par le type d’instruction lors du décodage.

    L’UAL possède donc grossièrement deux étapes :

  • L’exécution des opérations (EXECUTE)
  • Mise à jour des registres, écriture du résultat (WRITEBACK)

    EXECUTE : Voici l’étape tant attendue pour l’instruction, l’exécution. Et bien, c’est l’UAL qui s’occupe de cette étape, il va, à partir du type d’instruction et des opérandes, faire les opérations (simples) nécessaires à l’accomplissement de l’instruction. Le Registre EAX ou ACC (Accumulateur), registre interne de l’UAL, stocke une valeur initiale qui va être modifiée par l’UAL.

    WRITEBACK : L’instruction a maintenant été exécutée, les Registres sont en conséquence mis à jour, selon le type d’opération. Le Registre IP pointe vers la « nouvelle » instruction en mémoire etc. Ceci se fait très vite ! Le registre EAX peut potentiellement stocker le résultat d’une instruction, et la placer en mémoire, en attendant d’être demandée par tel programme. En fait, ce sont les instructions suivantes qui déterminent ce qu’il advient du résultat stocké temporairement dans ce registre.
    On a également le registre PSW (Program Status Word), registre d’état, qui peut stocker le signe du résultat d’une opération (positif, négatif), une retenue (carry), ou un dépassement de capacité (overflow).

    Ce cycle poursuivi par l’instruction est appelé le chemin de données.

    Maintenant, que nous avons défini brièvement les étapes effectuées par un processeur, comment évaluer sa vitesse ?

    Pour que tout ce système marche, il faut obligatoirement que toutes les actions soient pilotées et synchronisées, sinon c’est la catastrophe.
    C’est là qu’entrent en jeu d’autres paramètres, notamment deux très importants :

    - Le Séquenceur ;
    - L’horloge.

    Tous deux sont compris dans l’Unité de Commandes.

    Le séquenceur commande et contrôle le fonctionnement du système. Pour cela, il génère des signaux de contrôle pour piloter les éléments du chemin de données. Il a donc le rôle de « pilotage des actions ».

    L’horloge, elle, permet la synchronisation des éléments de l’UC. Pour cela, elle émet des signaux de manière périodique. On appelle ceci le cycle d’horloge (ou cycle machine). En bref, une opération est effectuée en un cycle. Ici, l’opération ne veut pas dire instruction, par exemple, on peut dire que l’étape FETCH est une opération. On peut ainsi, établir une certaine vitesse à partir de ce cycle d’horloge. La fréquence d’horloge (nombre de cycles horloge/s) s’exprime aujourd’hui en MHz, voire en GHz avec les processeurs plus ou moins récents (depuis la révolution informatique).
    Ainsi, quand on a un processeur de 2,2 GHZ, cela signifie qu’il y a normalement 2 milliards 200 millions cycle d’horloge par seconde, pas mal :D 
    Comme toute onde périodique, il y a un « Haut » et un « Bas » dans les signaux émis par l’horloge, cela nous resservira plus tard. On peut schématiser ceci de cette manière :

    /’\,/’\,

    L’overclocking qu’on rencontre beaucoup sur les forums d’Hardware, consiste à faire augmenter (via le BIOS ou d'autres logiciels tiers) le nombre de cycles d’horloges par seconde, dans le but d’augmenter les performances. Même si ce n’est pas le seul facteur dans les performances (il y a aussi les mémoires, les bus, l’architecture), c’est tout de même un facteur important. Pour faire de l'overclocking, il faut le faire en fonction du FSB et de la fréquence de la RAM, pour ne pas aboutir à un système instable. Un autre facteur dans l'overclocking est l'énergie véhiculée par l'alimentation, on la maîtrise via le VCore (Voltage CPU). L'augmentation de chaleur dégagée est due à l'augmentation du Vcore, par effet Joule.
    On augmente le Vcore pour donner plus de puissance au processeur quand la montée en puissance est très importante; l'apport supplémentaire d'énergie peut permettre d'obtenir un système stable alors qu'il ne l'était pas avant modification du Vcore (lors d'un overclocking bien-sûr).

    Néanmoins, cela peut être dangereux (à réserver aux addicts d'hardware), puisque les processeurs ont tout de même une certaine limite de fréquence (bridés). Cela peut donc causer par la suite, si on ne connaît pas bien sont matériels de multiples problèmes, surchauffe, surtension… (qui vont de paire)

    Attention donc également au type de processeur :

    - Processeur qui chauffent peu et ne nécessitent pas beaucoup d'énergie : :sup:
    - Pour les autres, c'est plus risqué...

    ~ Fin de la parenthèse

    Mais on peut également déterminer chez un processeur (assez approximativement) le nombres d’instructions exécutées par seconde. (ce qui revient à calculer le nombre de cycles d’horloge nécessaire à l’ensemble des étapes étudiées : FETCH, DECODE, EXECUTE, WRITEBACK).
    Selon l’architecture, il est plus pertinent dans un comparatifs d’UC de comparer cette vitesse (MIPS = Millions d’Instructions Par Seconde) que de comparer directement la fréquence d’horloge. Néanmoins, les architectures étant sensiblement les mêmes dans les PC modernes, on retrouve tout le temps cette fréquence d’horloge.

    Pour améliorer les performances, on a introduit dans le processeur ce qu’on appelle un Pipeline.
    Comme insinué tout à l’heure, le pipeline permet la coordination, mais surtout un meilleur rendement de l’UC dans le traitement des données. On pourrait l’introduire comme le père du séquenceur.

    Comme on a vu dans les étapes précédentes, si on suit bêtement ce plan, alors l’instruction précédente commence seulement à être traitée une fois que l’instruction précédente est traitée, ce qui entraîne de grosses pertes de temps inutiles. Schématisons ça. Le pipeline permet justement que le travail soit continué où il le peut pendant que telle instruction suit son cours.

    Pour cela, on divise le travail en plusieurs étages (chaque étage correspondant à un cycle d’horloge).
    On va reprendre les mêmes étapes que précédemment J

    1. FETCH
    2. DECODE1
    3. DEC0DE2
    4. EXECUTE
    5. WRITEBACK

    Prenons maintenant neuf instructions qui se suivent, respectivement : 1, 2, 3, 4, 5, 6, 7, 8 & 9.
    On a donc un pipeline à 5 étages (non physiquement, mais plutôt logiciellement), un cycle d’horloge par étage. On obtient donc grâce au système de pipeline ce type de schéma.

    Cycle 1 : FETCH(1)
    Cycle 2 : DECODE1(1), FETCH(2)
    Cycle 3 : DECODE2(1), DECODE1(2), FETCH(3)
    Cycle 4 : EXECUTE(1), DECODE2(2), DECODE1(1), FETCH(4)
    Cycle 5 : WRITEBACK(1), EXECUTE(2), DECODE2(3), DECODE1(4), FETCH(5)
    Cycle 6 : WRITEBACK(2), EXECUTE(3), DECODE2(4), DECODE1(5), FETCH(6)
    Cycle 7 : WRITEBACK(3), EXECUTE(4), DECODE2(5), DECODE1(6), FETCH(7)
    Cycle 8 : WRITEBACK(4), EXECUTE(5), DECODE2(6), DECODE1(7), FETCH(8)
    Cycle 9 : WRITEBACK(5), EXECUTE(6), DECODE2(7), DECODE1(8), FETCH(9)
    Cycle 10 : WRITEBACK(6), EXECUTE(7), DECODE2(8), DECODE1(9) …

    On devine rapidement que le traitement d’une instruction prend cinq cycles d’horloge dans cet exemple. Si on avait pas de système de pipeline, le traitement des 6 instructions aurait pris 6*5 = 30 cycles d’horloge. Avec ce système, il en prend 10. Plus le nombre d’instructions est grand, plus l’écart se creuse. Voilà donc en quoi le pipeline joue un rôle majeur dans le déroulement du chemin des données. À titre d'exemple, le Registre IP est mis à jour à chaque cycle (dans le cas présent) avec le pipeline, ce qui permet de continuer le "stockage" pendant que l'autre instruction continue son traitement.

    Il y a plusieurs types d'architectures possibles :

  • Architecture Superscalaire : Plusieurs pipelines (une par UC) qui travaillent en parallèle. Les instructions ne sont pas séparées au hasard. Chaque pipeline est spécialisé dans des types d'instructions.
  • Architecture Vectorielle : On la retrouve dans les Superordinateurs. Une instruction va s'appliquer à un ensemble de données, appelé vecteur. Une seule instruction va donc exécuter la même opération de façon parallèle sur tout le vecteur; pratique pour les calculs scientifiques.
  • Architecture Multiprocesseurs : Plusieurs UC (avec mémoire locale ou non) reliés à une mémoire partagée par le BUS.

    Aujourd’hui, la majorité des microprocesseurs utilisés font partie de la série x86.
    On a les x86-32 bits, et les x86-64 bits :
    Les processeurs de type x86-32 bits peuvent gérer un OS-32bits (Windows 32-bits par exemple), alors qu’un processeur de type x86-64 bits peut à la fois gérer un OS-32 bits ou un OS-64 bits.
    Évidemment, l’OS-64 bits ne marche que sur le processeur x86-64 bits.

    Au final, puisque les composants matériels actuels sont en général à 64 bits, un OS 64 bits permet une meilleure exploitation des capacités physiques, donc de meilleures performances.

    On rencontre maintenant des problèmes de compatibilités entre logiciels utilisés sur l’OS-32 bits et l’OS-64 bits, car les capacités contenue dans les « mots » ne sont pas les mêmes.

    Sous un Processeur-32 bits; OS-32 bits :

    - Octet = 8 bits ;
    - Word = 16 bits ;
    - Dword = 32 bits;

    Sous un Processeur-64 bits; OS-64 bits :

    - Octet = 8 bits ;
    - Word = 16 bits ;
    - Dword = 32 bits;
    - Qword = 64 bits;

    Les mots utilisés ne sont donc pas les mêmes, d’où les problèmes d’incompatibilité.

    Bien entendu, au sein de cette série x86, on s’est arrangé pour que les différents processeurs (Intel, AMD ..) acceptent globalement les mêmes jeux d’instructions ; on retrouve en général : x86, MMX, 3Dnow !, SSE (calculs scalaires flottants), SSE2, SSE3 … Cependant, ils ne les gèrent pas toujours ..

    Aujourd’hui, les Processeurs font partie de la famille des CISC (Complex Instruction Set Computer) [opposé au RISC], qui désigne un microprocesseur possédant un jeu d'instructions comprenant de très nombreuses instructions mixées à des modes d'adressages complexes.
    De nos jours, les Processeurs sont cadencés à de haute fréquences (de 2 GHz à 3Ghz en général) et sont maintenant Core 2 Duo (Processeur Double Cœur = Un seul processeur qui contient deux cœurs (UC) avec un système de mise en commun), qui ont succédé aux Dual Core (Monocore + HyperThreading). On trouve même maintenant (et ce de plus en plus), des Quad Core (Dual Core + HyperThreading), voire des vrai Quad Core à 4 quatre coeurs (2 Core 2 Duo par exemple).

    Schéma récaputilatif (sans pipeline) :



    Les Mémoires


    Sans les mémoires, on ne trouverait pas d'architecture comme on en trouve aujourd'hui. Les mémoires sont indispensables du fait qu'elles stockent (storage) les instructions et données. Un processeur, lui, stocke temporairement des instructions et les exécute.

    Il y a deux grands types de mémoire : Les mémoires volatiles et non volatiles.

    1) Les mémoires volatiles

    Les mémoires volatiles sont celle dont la perte des données sera effective à l'arrêt du système.
    On y trouve :

    - Les Registres;
    - La Mémoire Principale (Vive);
    - Les Mémoires Caches.

    Les Registres sont les petites mémoires situées dans l'UC. Il y en a peu (plusieurs dizaines) car la puce de l'UC est petite, et leur taille est très réduite (c'est surtout une question de coût !). Cependant, ce sont les plus rapides avec un temps d'accès record; c'est pour cette raison que ce sont les plus chères. Leur taille, varie, comme nous l'avons vu, selon le type de processeurs. Aujourd'hui, on a majoritairement des Processeurs 32-64 bits, donc on a des Registres qui varient pour stocker des mots (DWord ou QWord) de 32 à 64 bits.

    On trouve deux types de mémoires volatiles : Les mémoires Dynamiques et les mémoires Statiques.

    Les Mémoires Statiques (SRAM) ont leur contenu mémorisé jusqu'à extinction du PC, elles sont très rapides et très chères.
    Les Mémoires Dynamiques (DRAM) sont constituées différemment. Chaque Bit (plus petite unité adressable) doit être rafraichi (rechargé) régulièrement, grâce à des circuits logiques externes, pour éviter des pertes de données (contrairement à la SRAM). Les DRAM ont une bien plus grosse capacité de stockage.

    La Mémoire Principale est la plus grande mémoire volatile qui existe sur un PC. Plus connue sous le nom de RAM (Random Access Memory), c'est elle qui stocke les fichiers/programmes chargés par l'OS, et qui par conséquence stocke également des données/instructions.
    Anciennement DRAM, elle est maintenant SDRAM (Synchronous DRAM), c'est à dire, mi-statique et mi-dynamique, afin de bénéficier des avantages des deux systèmes (rapidité d'accès + capacité de stockage). Pilotée par l'horloge principale, c'est le processeur (ou la CM) qui l'avertit du nombre de cycles pendant lesquels elle doit fonctionner. Les mémoires actuelles, souvent larges de 64 bits (nous verrons plus tard), émetteraient 64 bits par cycle.
    Cette mémoire est stockée dans des modules DIMM (Dual Inline Memory Module). Ces modules contiennent en général 8 ou 16 circuits sur une fine plaque de circuits imprimés et deux rangées de connecteurs (ou broches) (un de chaque face) ce qui permet de transmettre 64 bits par cycle d'horloge.
    L'arrivée de la DDR (Double Data Rate) permet un débit deux fois supérieur (à la SDRAM), car elle libère tant de bits à chaque demi-cycle d'horloge, c'est à dire au front montant et au front descendant du cycle d'horloge. Cela ferait ici : 128 bits/Cycle d'horloge.
    La DDR2 utilise deux canaux séparés pour la lecture et pour l'écriture, si bien qu'elle est capable d'envoyer ou de recevoir deux fois plus de données que la DDR.
    Les barrettes actuelles stockent de quelques centaines de Mo à plusieurs Go. Sans être une mémoire lente, la mémoire cache est préférée lorsque c'est possible, le temps d'accès vers la mémoire principale étant de quelques dizaines de nanosecondes (10^-9 secondes), malgré un bus optimisé.

    Enfin, il y a le contrôleur mémoire, qui est chargé de contrôler les échanges entre le processeur et la mémoire vive, il se trouve soit sur la Carte Mère (NorthBridge), soit intégré au Processeur.

    Aujourd'hui, nous avons des mémoires qui ont une fréquence de 200 à 550 MHz. On verra souvent avec les DDR ou DDR2 des fréquences dite de 667MHz voire 800 MHz. En fait, ils prennent en compte le fait que ce type de mémoire exploite le front montant et descendant de l'horloge, mais la fréquence réelle est divisée par deux.
    La notation PC**** qu'on retrouve souvent représente le débit en Mo/s. (****) Les RAM transférant 8 octets (=64 bits) par cycles d'horloge, le **** vaut 8x la fréquence de la barrette (puisque les deux s'expriment en M..). ;) 

    Les Mémoires Caches sont de petites mémoires très rapides (SRAM = quelques nanosecondes) utilisées pour améliorer les performances du PC pour les actions les plus répétées.
    Elles ont été créées pour "palier" au problème que pose l'accès lent par le Bus du processeur à la mémoire vive. Les mots mémoires les plus utilisés y sont stockées.
    On en trouve de deux niveaux (L1 , L2) majoritairement. Aujourd'hui, elles sont toutes les deux intégrées dans la puce de l'UC, ce qui permet un accès très rapide !
    En contre partie, leur taille est très réduite. La mémoire cache L1 la plus proche du coeur du processeur est limitée à quelques dizaines de Ko contre quelques Mo pour le cache L2 (toujours une question de coût, mais la L2 est toujours plus rapide que la RAM). Le principe est simple : l'UC regarde si le mot qui l'intéresse se trouve dans la/les mémoire(s) cache(s), si c'est le cas, il se sert très rapidement dans ces caches et l'instruction est exécutée en un temps record. Sinon, il se réfère à la mémoire vive avec un temps d'accès "bien" plus long. Les instructions demandées par les programmes sont en général mis en mémoire de manière consécutive, et non aléatoire. Lorsqu'un mot est référencé, celui-ci est basculé de la grande à la petite mémoire, en vue d'une prochaine utilisation. Les entrées dans la mémoire cache se font par groupe de mots, et non par mots uniques.. Le fait d'avoir 2 caches permet à l'unité de recherche des instructions et celle des opérandes d'opérer en même temps.
    Notez qu'on trouve parfois 3 caches, le 3e cache étant plus éloigné du processeur, plus lent et plus grand.

    Nous étudierons un peu plus tard, la structure globale d'une mémoire.

    2) Les mémoires non volatiles

    Avant de parler de mémoire morte, il y a d'autres supports de mémoires non volatiles très connus appelés Mémoires Secondaires (ou mémoires de masse), citons les plus connus :

    - Disque Dur (Magnétique);
    - Disque Optiques (CD, DVD, Blue-Ray).

    Le Disque Dur est composé d'un ou de plusieurs Plateau(x) disposés verticalement recouverts d'une couche magnétique où sont stockés les données de façon binaire. Chaque plateau est divisé en pistes concentriques (espace occupé par une rotation), qui sont divisées en secteurs contigus. Les informations sont écrites à l'aide d'une Tête de lecture/écriture amorcée par un Bras du disque. Chaque plateau a deux têtes, une pour chaque surface; car un plateau a deux surfaces (en haut, et en bas). La Lecture/Écriture se fait d'une part avec le sens du déplacement du bras, pour se déplacer sur telle ou telle piste, et du positionnement (seek) de la tête sur tel ou tel secteur. On a le temps de positionnement (déplacement du bras pour atteindre la bonne piste), le temps de latence (rotationnel) (alignement du secteur sous la tête) et le temps de transfert (temps du transfert des données).
    Plus le disque tourne vite, la vitesse générale étant à 5400/7200 tours/minute, plus le positionnement sera rapide, plus la lecture/écriture est rapide. Cette durée se mesure en Millisecondes, c'est donc une mémoire lente. (comparée aux autres qui se mesurent en nanosecondes, soit n*10^6 plus rapides).
    La vitesse dépend aussi du nombre plateaux, de leur densité (capacité de stockage) et de la mémoire cache du disque dur (allant de quelques Mo à quelques dizaines de Mo) [oui ce n'est pas spécifique au CPU] servant à stocker des informations en lecture/écriture.
    En revanche, étant un dispositif assez grand, les capacités de stockage sont gigantesques, de l'ordre de centaines de Go !

    N.B : Les pistes sont en fait divisées en un certain nombre de secteurs de longueur fixe (les cercles ne sont pas du tout parfaits sur mon schéma), contenant généralement 512 octets de données et précédés d'une zone de préambule permettant à la tête de se synchroniser avant de commencer la lecture/écriture. À la fin de chaque secteur se trouve une code correcteur d'erreur. Entre deux secteurs consécutifs se trouve un espace intersecteur (gap).

    Les disque dur actuels utilisent le même type de connexion : le Bus S-ATA (Serial Advanced Technology Attachment).
    Pour le moment, comme type de mémoire, nous avons des disques à plateaux, mais l'avenir nous promet des disques durs à mémoire Flash, ce qui augmenterait beaucoup leur débit/temps d'accès (et ce qui permettrait potentiellement de shooter avec moins de risques dans le boîtier quand le PC lag :D  ).

    N.B : Ne pas confondre Bus et Type de Mémoire. Le Bus reste toujours S-ATA. En passant, le Flash serait plus rapide, notamment car les plateaux nécessitent une certaine énergie pour tourner, et ce système nécessite également un certain temps. (latence, positionnement...)



    Notez que le schéma est grandement simplifié, il y a bien plus de pistes en réalité :D  (des milliers par centimètre)



    Les Disques Optiques sont vite devenus avec le temps très commercialisés, bien que leur influence se tait aujourd'hui de plus en plus, avec les périphériques USB ou disques dur externes. La fabrication des disques optiques est une chose très méticuleuse et se fait à l'aide de lasers (rouge chez le DVD, bleu chez le Blue-Ray).
    Dans la catégorie des CD (Compact Disk), il y a eu d'abord les CD-ROM (accès en lecture seulement), les CD-R (vierges & enregistrables) et les CD-RW. (vierges, enregistrables & réinscriptibles) Le temps d'accès varie de quelques dizaines à quelques centaines de Millisecondes, c'est une mémoire très lente. La capacité de stockage est en générale de centaines de Mo à quelques Go.

    Au vue de ces différences, on peut établir facilement un schéma illustrant la hiérarchie des Mémoires :



    Enfin, dans les mémoires non volatiles, nous avons les mémoires ROM (Read Only Memory).
    On ne peut à la base, ni modifier ni supprimer le contenu. Le contenu est fixé lors de la fabrication, et la mémoire reste stocké même lorsque l'alimentation est coupée (puisque non volatile). Le BIOS (Basic Input Output System = Système élémentaire d'E/S), élément prépondérant au démarrage de l'ordinateur, se trouve dans la mémoire morte, afin d'éviter des effacement accidentels.

    Il y a plusieurs types de ROM :

    - PROM (Programmable ROM) est une mémoire qu'on peut programmer.
    - EPROM (Erasable PROM) est une mémoire qu'on peut programmer et effacer (avec des UV).
    - EEPROM (Electrically EROM) est une mémoire petite, lente, mais reprogrammable et effaçable électroniquement; on peut l'effacer octet par octet.

    Ensuite, on trouve la Mémoire Flash qui est une sorte d'EEPROM; on la retrouve dans les cartes d'appareils photo numériques, dans les cartes Mini-SD (ou Micro-SD) des téléphones portables ou encore dans les périphériques USB abondamment utilisés. Sa vitesse est rapide et elle possède une grande durée de vie.

    Comment s'organise la mémoire ?

    Comme vous le savez, la plus petite unité adressable est le bit, on le retrouvera partout dans les mémoires..

    Nous verrons un peu plus en détail les unités structurelles des RAM, mais intéressons-nous à l'organisation de la mémoire en général.
    La mémoire est composée de "cellules", numérotées par des Adresses. Elles sont là dans toutes sorte de programme, on entre plus en interaction avec dans un langage comme le C avec les pointeurs, mais encore bien plus en Assembleur (ASM).

    On a une structure de x adresse avec z bits chacune. Si une mémoire comprend x cellules (donc x adresses), elle se voit attribuer les adresse 0 à x-1.
    Toutes les cellules contiennent le même nombre de bits, et peuvent donc enregistrer chacune 2^z bits combinaisons de bits :) 
    Le choix de la structure d'une RAM se fait sur la largeur (nombre de bits par cellule). Pour une même mémoire, plus on a de cellules, moins on a de bits par cellule et inversement.

    Aujourd'hui, on retrouve majoritairement des RAM de 64 bits de largeur. Admettons que j'ai une RAM d'1 Go et de 64 bits de large. Combien d'adresses ?

    1 Go = 2^30 * 8 bits (car les adresses s'expriment en bits, mais après on utilise souvent l'hexadécimal :)  )
    64 bits = 2^6 bits (ben oui, il a bien fallu qu'il y ait un intérêt pour mettre des puissance de 2 partout)
    => 2^30 * 8/64 = 134217728 = 0x8000000 = 1000 0000 0000 0000 0000 0000 0000b

    On a donc un adressage de 0x0000000 à 0x7FFFFFF, chaque cellule ayant 64 bits de données disponibles.
    Pourquoi 0X7FFFFFF et pas 0x8000000 ? Si vous avez bien suivi, l'adressage pour x adresses se fait de 0 à x-1 :) 
    Ici, on peut parler d'adressage matériel, l'adressage logiciel se faisant en exprimant les adresses par octet.

    Exemple :


    Comme vous le constatez sur l'image, l'adresse effectif se fait en octet (ou byte).

    L'"ordonnancement" (disposition des octets) des octets (endianness) peut varier d'un processeur à l'autre. Par exemple, chez Intel, une fois traduit au niveau du processeur, les paquets de bits sont inversés. (little endian)

    Un mot sur les mots ..

    Comme dans tout système, il peut y avoir des erreurs. Lors de la transmission d'un mot d'une zone mémoire à un autre, il est possible qu'il y ait des erreurs au niveau des bits.
    Comment s'en apercevoir et corriger le tir ?

    C'est là qu'entre en jeu la notion de code correcteur d'erreurs.
    Et bien, on va intégrer ce qu'on appelle des Bits de Contrôle. Admettons un message de m bits, ajoutons x bits de contrôle, on obtient un mot de n bits. On va ajouter des bits de contrôle, dis bits de parité, de sorte à avoir au total un nombre de bits positifs pair ou impair.

    Il faut savoir qu'il y a beaucoup de codes correcteurs différents.
    Je vais les séparer par des tirets, ce sont juste des exemples simples sur lesquels on ne s'étendra pas !

    Avant d'introduire quelques notions, on doit parler de la Distance De Hamming.
    La distance de Hamming, c'est le nombre de positions au niveau desquelles les bits de deux mots de code diffèrent.

    Exemple : J'ai le mot : 00110011 et le mot : 00010010.
    La distance de Hamming est de deux, car deux bits diffèrent (en gras).

    Revenons au bit de parité avec un exemple, dont le seul bit est d'exprimer la notion de parité.
    Parité paire : J'ai un mot de 7 bits : 0100011, nous sommes dans un contexte de parité paire, donc j'ajoute un bit positif (comme ça il y aura un nombre paire de bits positifs), ce qui donne : 1001 0011. Ceci peut ensuite permettre la détection d'une éventuelle erreur (mais on ne pourrait la localiser précisément), en fait de 2k+1 erreurs (k € N), puisqu'une double erreur ne se verrait pas (paire>impaire d'une erreur à l'autre).

    Code de Hamming (7,4)

    Sur un mot de m bits, les bits ajoutés de parité portent les numéros correspondants à des puissances de 2^x jusqu'à ce que 2^x soit plus petit ou égal à m et prendront respectivement place dans le mot selon leur numéro.

    Ainsi, sur un mot de 16 bits (m), on aura 5 bits de parités (x) (donc 21 bits de mot de code (n)) qui prendront respectivement les valeurs de :

    - 2^0 = 1
    - 2^1 = 2
    - 2^2 = 4
    - 2^3 = 8
    - 2^4 = 16 (x=m) => 5 bits de parité

    N.B : Ces bits de parité prendront la place respectivement du bit 1, 2, 4, 8, 16 (c'est-à-dire, la valeur de leur puissance); ceci de la gauche vers la droite, et non de la gauche vers la droite (comme on regarde le binaire quand on fait des conversions en hexadécimal ou en décimal par exemple).

    Les bits de parité contrôlent des bits précis sur le mot, c'est ce qui va induire leur rôle contrôleur et correcteur; c'est leur position dans le mot qui détermine combien ils contrôlent de bits :

    On a Bit X qui contrôle des X-uplets à partir de X séparés par X+1 jusqu'à ce que X=N. Illustration :D  :

    Parité 1 = Bit 1 contrôle les bits : 1;3;5;7;9;11;13;15;17;19;21
    Parité 2 = Bit 2 contrôle les bits : 2,3;6,7;10,11;14,15;18,19;
    Parité 3 = Bit 4 contrôle les bits : 4,5,6,7;12,13,14,15;20,21
    Parité 4 = Bit 8 contrôle les bits : 8,9,10,11,12,13,14,15
    Parité 5 = Bit 16 contrôle les bits : 16,17,18,19,20,21

    Les bits contrôlés par un bit de parité doivent contenir un nombre pair de 1 (il faut donc avoir le mot sous les yeux pour vérifier), sinon une erreur est renvoyée.

    Pour trouver l'erreur, il faut vérifier que les bits contrôlés par les bits de parité ont bien un nombre paire de bits positifs. On trouve celui/ceux qui sont erronés, et par déduction (par rapport aux autres bits de parité), on trouve le bit qui a changé. [par contre, s'il y en a plusieurs ....]

    Maintenant, s'il y a une erreur dans un bit de parité, là, c'est autre chose..

    Voyons maintenant un exemple pour rappeler ces différentes notions.

    But: Écrire un code de Hamming de parité paire à 7 bits pour les chiffres 0 à 9.

    Les bits de données (le message, donc 1,2...) sont respectivement : 0000, 0001, 0010, 0011, 0100, 0101, 0110, 0111, 1000, 1001.
    Comment construire le mot de code incluant les bits de parité ?

    Commençons par trouver combien il y a de bits de parité. Rappel : Cela fonctionne par puissance de deux. On a des mots de 4 bits.
    On obtient donc 3 bits de parité (ce qui explique la parité à 7 bits demandé dans l'énoncé):

    2^0=1
    2^1=2
    2^2=4 (X=M), on s'arrête là, il y a trois bits de parité, qui prennent respectivement la position 1, 2 et 4 (résultat des puissances).

    On obtient donc (par exemple pour 0):

    Position :
    1. 1234567
    2. 0000000


    Nommons les bits de parité p* et deux de données d*.
    On obtient donc pour tous :

    Position :
    1. 1 2 3 4 5 6 7
    2. p1 p2 d1 p3 d2 d3 d4


    Bien, nous avons les mots de donnés initiaux, le nombre et la place des bits de parité et de données, il ne reste plus qu'à faire le mot de code ! Voila la réponse explications en verts pour chaque mot de code :

    Citation :
    p1 contrôle d1 (3), d2 (5), d4 (7), p2 contrôle d1 (3), d3 (6) et d4 (7), p3 contrôle d2, d3 , d4 (voir explication plus haut)
    Les bits de parité sont en violet, et les bits de données en rouge :)  [Rappelons que la parité est paire]

    0 : 00 0 0 000
    d1 d2 d3 d4 = 0 (paire tout le temps, puisque 0 bit positif), donc tout à 0 !
    1 : 11 0 1 001
    d1+d2+d4 = impaire : p1->1, d1+d3+d4 = impaire : p2->1, d2+d3+d4=impaire, p3->1
    2 : 01 0 1 010
    d1+d2+d4=paire : p1->0, d1+d3+d4 = impaire : p2->0, d2+d3+d4=impaire, p3->1
    3 : 10 0 0 011
    d1+d2+d4=impaire : p1->1 , d1+d3+d4 = paire : p2->0, d2+d3+d4=paire, p3->0
    4 : 10 0 1 100
    d1+d2+d4=impaire : p1->1, d1+d3+d4 = paire : p2->0, d2+d3+d4=impaire, p3->1
    5 : 01 0 0 101
    d1+d2+d4=paire : p1->0, d1+d3+d4 = impaire : p2->1, d2+d3+d4=paire, p3->0
    6 : 11 0 0 110
    d1+d2+d4=impaire : p1->1, d1+d3+d4 = impaire : p2->, d2+d3+d4=paire, p3->0
    7 : 00 0 1 111
    d1+d2+d4=paire : p1->0, d1+d3+d4 = paire : p2->0, d2+d3+d4=impaire, p3->0
    8 : 11 1 0 000
    d1+d2+d4=impaire : p1->1, d1+d3+d4 = impaire : p2->0, d2+d3+d4=paire, p3->0
    9 : 00 1 1 001
    d1+d2+d4=paire : p1->0, d1+d3+d4 = paire : p2->0, d2+d3+d4=pimaire, p3>1


    Ceci illustre une partie de l'algorithme de Hamming.

    Voici d'autres exemples d'algo :

    - Code de Reed-Solom : http://fr.wikipedia.org/wiki/Code_de_Reed-Solomon
    - Code de Reed-Müller : http://fr.wikipedia.org/wiki/Code_de_Reed-M%C3%BCller

    Les périphériques d'Entrée/Sortie (E/S)


    On a beaucoup de périphériques d'E/S aujourd'hui :

    Des périphériques d'entrée : Souris, clavier, scanner, micro, joystick ..
    Des périphériques de sortie : Imprimante, écran, haut parleur ..
    Des périphériques d'Entrée/Sortie : Clé USB, DD externe, lecteur CD, modem ..

    Ces périphériques sont reliés soit à des ports internes (directement sur la carte mère), soit sur des ports externes connectés à des bus (clef USB) ou des ports externes de cartes d'extensions reliées à un BUS (carte graphique par ex).

    Chaque périphérique possède un Contrôleur, qui contient la plupart des composants électroniques. C'est lui qui va être le relai entre le périphérique E/S et le Bus/Processeur. Selon le type de périphérique, le Bus utilisé est différent. Par exemple, pour les périphériques USB, on a le Bus USB; pour la Carte Graphique, on peut avoir le Bus AGP ou PCI EXPRESS (PCIe), pour le Disque dur, on a le BUS S-ATA etc ..

    Le contrôleur peut posséder ses propres Registres pour stocker des informations, c'est lui qui fait les requêtes, qui reçoit les ordres du Processeur.
    Ce contrôleur peut posséder un décodeur pour assurer la communication.

    Maintenant que nous avons vu les principaux composants, nous allons voir brièvement comment ils sont reliés.
    Je pense que vous avez déjà compris, les composants sont donc reliés entre eux par des Bus.

    Un Bus est un lien de communication électrique entre plusieurs composants, c'est en effet un ensemble de fils.
    Vous l'avez bien compris, le Bus n'est pas une chose simple, ce n'est pas seulement un ensemble de fils, mais un ensemble de fils qui ont une fonction bien précise (selon le type de bus).

    Au sein d'un PC actuel, nous avons plusieurs types de bus de largeur différente. Nous avons des bus très rapides (Bus Mémoire : Processeur - Ram), rapides (PCI-EXPRESS, AGP), moyen-lents (PCI, (E)S-ATA [IDE, ATA, ATAPI ..], USB). On retrouve également des bus plus petits, par exemple, il y a un bus interne au CPU. Voyons un schéma plutôt caricaturé, mais surtout très simplifié :



    Comme vous le voyez, le tout est relié à un "Circuit Pont" qui fait communiquer les BUS. On remarque qu'on a bien un contrôleur pour chaque périphérique E/S, sauf pour l'USB, nous verrons après pourquoi.

    Revenons à la fonction du BUS, faire circuler les informations. Le BUS possède ce qu'on appelle des "lignes" (fils) : Lignes d'adresses, de données, de commandes précises (écriture/lecture mémoire, écriture/lecture E/S..). Or les informations viennent du matériel, donc le CPU par exemple possède également ce type de système pour communiquer avec l'extérieur. Le CPU, pareillement, possèdes des broches d'adresses, de données, de commandes .. On a donc un mode de communication via des broches.
    Broches de commandes du bus, d'interruptions, de signaux destinés aux co-processeurs (processeurs auxiliaires de calcul de virgule flottante [carte graphique = GPU]), etc.
    Sans compter qu'il y a des facteurs externes tel que l'horloge, alimentation etc. Bien entendu, le BUS reçoit des informations du processeur mais également des requêtes ou réponses des autres composants.

    C'est un décodeur qui assure la transmission de la "commande" à la bonne ligne. Par exemple, il faut mener les bits d'adresse sur les broches d'adresses et pas sur les broches de données ;) 

    La mémoire pouvant être adressée par un processeur dépend de la largeur du BUS (du nombre de lignes d'adresse). Le processeur peut théoriquement adresser 2^n lignes d'adresse. (n étant actuellement à 32-64) Ceci car chaque broche peut accueillir 1 bit, ce qui fait au final 2^nbroches combinaisons possibles.

    Deux moyens sont possibles pour augmenter le débit de données sur un bus :

    - Réduire le temps de cycle (plus de transferts/sec);
    - Augmenter la largeur du Bus (plus de bits/transfert).

    Hélas plus on joue sur ces facteurs, plus le problème du déphasage temporel se pose (= signaux des différentes lignes se déplacent à des vitesses légèrement différentes). La vitesse n'est donc pas extensible à l'infini !
    En ce qui concerne le problème de la largeur du Bus, on peut avoir un bus multiplexé (= lignes d'adresses et de données confondues), dans ce cas, il faut veiller à maintenant un ordre (adresses d'abord, données après).

    Il y a deux types de composants :

    - Ceux qui sont susceptibles d'utiliser le bus qualifiés de Maîtres (master);
    - Les autres qualifiés d'esclaves (slave).

    La mémoire est toujours esclave, elle reçoit des requêtes et se soumet :red:
    Il y a plusieurs maîtres (CPU, mais aussi E/S pour des raisons de perte de données possibles notamment).

    Pour revenir aux bus, il y a deux types de Bus : Bus synchrone & Bus asynchrone.

    Le bus synchrone possède une ligne pilotée par une horloge, le bus asynchrone n' a pas de ligne d'horloge maître.

    N.B : La fréquence d'un BUS est peu élevée comparée à celle du CPU à cause des problèmes précédemment évoqués.

    Globalement, le bus asynchrone offre de meilleures performances, mais le bus synchrone n'en reste pas moins le plus utilisé (par sa "simplicité" de conception).

    Prenons maintenant un exemple simple du fonctionnement du Bus :

    Le processeur veut envoyer un mot en mémoire :

    ~ Il positionne l'adresse du mot sur "la" ligne d'adresse du BUS.
    ~ Il positionne le mot sur la ligne de données du BUS.

    Dans le cas d'un bus non-multiplexé, adresses et données sont envoyées en même temps !

    Dans le cas d'un fetch (aller chercher un mot en mémoire) :

    ~ Le CPU envoie l'adresse sur la ligne d'adresses;
    ~ La mémoire répond en envoyant le mot sur la ligne de données (changement de sens)
    -> La mémoire envoie un signal si elle dépasse le cycle d'horloge pour envoyer la donnée (n'oublions pas qu'on résonne en cycle d'horloge toujours [synchrone]).

    Au final, l'inconvénient principal du bus synchrone est que s'il est relié à un ensemble hétérogène de composants, il tournera au rythme du plus lent (préférable pour les petites distances).
    Pour le bus asynchrone, les signaux (le système fonctionne par signaux, du processeur, de la mémoire, il y en a beaucoup : synchronisation, requêtes, alerte etc..) ne sont pas liés tous ensemble à une horloge (il y a plus de signaux pour communiquer entre composants). Il y a donc des synchronisations maître-esclave qui permettent un maximum de performances. C'est la technique de l'accord confirmé (indépendante du temps).

    Il arrive que les contrôleurs de périphériques E/S accèdent à la mémoire sans l'intervention de l'UC, cela s'appelle un accès direct à la mémoire (DMA : Direct Memory Access)

    Le problème, c'est quand deux périphériques (ou plus) veulent au même cycle d'horloge l'accès au bus, que se passe-t-il ?
    C'est là qu'entre en jeu l'arbitrage du Bus.

    Il existe deux arbitrages, l'arbitrage centralisé et le décentralisé.

    L'arbitrage centralisé (pouvant être intégré au processeur) choisit les composants prioritaires. Le bus contient une ligne "Requête" contrôlée par l'arbitre sur laquelle les différents E/S peuvent envoyer une requête définie par une priorité.
    L'arbitre active la ligne d'allocation du BUS; le premier E/S a accepté cette allocation (s'il a émis une requête) prend le contrôle du BUS et émet un signal spécifique (bus occupé). Pendant que tel E/S se sert du bus, la ligne d'allocation est mise au repos, et les requêtes reprennent. Quand l'E/S a fini sa transmission sur le BUS, le bus est déjà alloué pour tel autre E/S (gain de performance). C'est l'unité la plus proche qui a donc la priorité sur le BUS.
    Pour éviter l'utilisation successive du bus par un même maître, il lui est interdit de le refaire, tant que la ligne de requête n'est pas inactive. Mais un accès au Bus pourrait théoriquement durer infiniment si la durée d'un transfert était très long par exemple.

    En général, les E/S sont prioritaires sur le processeur (à cause du danger des pertes de données), néanmoins ce problème ne se pose plus puisque les E/S possèdent leurs bus (cf schéma plus haut).

    Avec l'arbitrage décentralisé, chaque circuit examine toutes les requêtes et en détermine si oui ou non (grâce à un arbitre propre), il peut prendre l'accès au bus.

    À la fin d'une tâche E/S demandée par le processeur, le processeur reçoit une INTerruption, qui nécessite le BUS.
    Lors d'une procédure d'INTerruption, il y a une pause sur l'exécution de tel programme par le CPU pour par exemple vérifier la présence d'erreurs sur le périphérique et communiquer à l'OS l'état de l'E/S.
    Si plusieurs INT sont émises en même temps, alors on utilise l'arbitrage centralisé..

    Pour résumer, on a le signale de l'INT -> Accusé de réception du CPU sur le contrôleur INT -> contrôleur spécifie l'entrée à l'origine de l'INT dans la ligne de données du bus -> CPU utilise ce numéro dans une table de pointeurs appelée vecteur d'INT.

    Pour revenir d'une manière globale sur les bus, on s'aperçoit qu'il y a plusieurs BUS reliés entre eux et qui ont en général des fréquences différentes d'un bus à l'autre ? Un problème se pose ...
    Les accès aux bus doivent être synchronisés.
    Imaginez un bus1 de 200 Mhz, et un autre bus2 de 3354 Mhz sans aucun intermédiaire entre eux.
    Plusieurs cycles d'horloges du bus2 se retrouveraient en plein milieu d'un cycle d'horloge du bus1 (et inversement), comment réguler ensuite les accès aux bus ..? Impossible... Ce serait donc n'importe quoi (l'anarchie matérielle si on peut dire)

    Il faut donc synchroniser les bus, c'est le rôle des "contrôleurs" (NorthBridge, SouthBridge, Contrôleur RAM). Pour faire ceci au mieux, il faut bien choisir le moment précis de lecture/écriture de tel Bus.

    Deux contraintes sont présentes :

    - S'adapter au Bus (périphérique) le plus lent en ralentissant une des fréquences pour ne pas générer d'erreurs (mais ce qui fait perdre en performance forcément);
    - Utiliser des Buffer ( = Puce dédiée à une fille d'attente de données/instructions) pour mettre les données en file d'attente. Le Chip possède ses buffers qu'il gère comme il veut. Exemple : Les Buffers du NorthBridge sont par exemple intégré dans le Chip NorthBridge.
    Ne pas confondre Mémoire Cache et Buffer /!\

    ~> La mémoire cache est une SRAM (non dynamique) qui stocke les instructions les plus utilisées de manière plus ou moins aléatoire, le Buffer stocke de manière ordonnée (FIFO) des données temporairement.

    En utilisant bien ces deux systèmes, le contrôleur amortit le plus possible les pertes de temps (perte de performance).

    Pour faciliter le processus, la fréquence de la plupart (pas tous !) des composants (CPU, RAM) est basée (partiellement ou non) sur la fréquence du FSB par un coefficient multiplicateur (2x/4x/6x/11x/12x...) pour avoir des cycles d'horloges plus cohérents, ce qui permet des synchronisations plus simples.

    Exemple : Si on a un FSB de 200Mhz, et un proco qui tourne à 2200MhZ, alors le coeff multiplicateur est à 11.

    Rappel : Un cycle d'horloge n'a pas une durée universelle (au contraire).
    --> Fréquence = 1 / Temps d'un cycle d'horloge.
    Si on réduit la durée d'un cycle d'horloge, on augmente la fréquence et vice-versa.

    Conclusion : L'intermédiaire entre bus, bus et composants est l'une des choses les plus importantes, puisque c'est elle qui permet la synchronisation de vos composants/bus.

    N.B : C'est pas pour rien que le Chipset (NorthBridge) supporte seulement quelques vitesses FSB, et quelques types de mémoire seulement.

    Vous trouverez peut-être via Everest par exemple pour le Bus Mémoire et le FSB, une horloge dite originelle, et une autre dite effective.
    En fait, comme les mémoires, il faut regarder ici le type de Bus auquel on a à faire.

    Personnellement, mon FSB est de type QDR (quadra data rate), donc il exploite "4 phases" du cyle d'horloge (4 bits par cycle d'horloge sans prendre en compte la largeur du bus) grâce à des oscillateurs déphasés, ce qui permet un débit 4x supérieur au débit de l'horloge physique [originel] (1 bit par cycle d'horloge).
    Pour mon bus mémoire, il est de type DDR, donc exploite la phase montante et descendante.

    Voilà pourquoi on peut y trouver de grosses différences ;) 

    Des exemples de BUS :

    Le bus Mémoire est le plus rapide avec une largeur (en général) de 128 bits (sûrement un bus non-multiplexé = 64 bits pour les adresses, 64 bits pour les données), suivi du FSB.

    Le bus PCI est un bus synchrone multiplexé avec arbitrage centralisé. Sa fréquence est de 66 MHz à la base, mais selon les normes, peut supporter une fréquence bien supérieur (500..), et sa largeur : 32/64 bits. Ce qui permet un adressage de 2^31/2^64 octets (la mémoire s'exprime en octets). On a un débit théorique de 528 Mo/sec qui accroît selon les normes.

    Le bus AGP (8x) a un débit théorique de 2,1 Go/sec, conçu uniquement pour les cartes graphiques.

    N.B : Il n'y a pas que des broches d'adresses et de données, mais quand on parle de largeur, en général, on parle de ceux-là.

    Illustrons le bus USB qui a un débit théorique de 480 Mbits/sec, soit 60 Mo/sec. (bus lent)
    Le BUS USB marche par câbles (pour relier les périphériques au PC). La différence primordiale avec d'autre types de bus, est que dans ce cas, on a un seul Contrôleur général (root hub), ce qui explique le schéma plus haut. Le contrôleur possèdes des prises externes (ports USB).
    Le câble USB possède 4 fils : 2 pour les données, 1 pour l'alimentation et 1 pour la masse.

    Lorsqu'un nouvel E/S (usb) est branché, le contrôleur principal le détecte et génère une Interruption, interroge l'élément (identité, débit..), et enfin lui attribue une adresse unique (de 1 à 127 -> GUID). C'est la raison pour laquelle un GUID d'un périphérique USB est différent d'un PC à l'autre et qu'il reste le même qu'on le supprime ou pas.

    On obtient donc une liaison entre les E/S et le contrôleur (pas entre E/S). Toutes les millisecondes environ, le contrôleur envoie une trame à tous les E/S (USB) pour maintenir la synchronisation (sur l'OS, cela se synthétise sous la forme d'un son et de l'ajout/retrait d'une icône dans le Poste de Travail lors de l'ajout/retrait d'un périphérique USB). On peut donc ajouter/enlever un E/S quand on veut.
    Il y a 4 types de trame : trames de supervision (configuration, ordre, état), trames isochrones (pour les E/S en temps réels pour des intervalles de temps précis : microphone, haut parleur), trames massives (long transfert de données : imprimantes, clefs usb), trames d'INT (l'USB ne dispose pas lui-même de signal d'INT : Le clavier n'émet pas d'interruption quand un touche est enfoncée, c'est l'OS qui se charge d'interroger le clavier par intervalles de temps pour connaitre les frappes produites).

    Les trames contiennent plusieurs paquets :

    - Jeton (token) : réservés aux commandes du système, du contrôleur à l'E/S);
    - Données : Corps, CRC (code correcteur), type de paquet (PID);
    - Accusé de réception etc .

    Voilà comment fonctionnent globalement et de manière très simplifiée les BUS.

    Dans le PC, il y a aussi ce qu'on appelle les circuits d'E/S. Les périphériques se voient attribuer des ports qui servent de moyens de communication.
    En Assembleur, on peut par exemple communiquer avec des contrôleurs en entrée/sortie grâce à ces ports.

    Exemple : IN AL, 60h (assembleur) va lire un octet à l'adresse 60h qui sur le PC est la sortie du contrôleur clavier. (associée à un port)

    La Mémoire (vive) est allouée de manière fixe aux périphériques (périphériques E/S, contrôleurs etc.). Nous le verrons mieux dans un autre chapitre.
    On peut le voir via Everest dans Périphériques -> Ressource des périphériques.

    On observe :

    - Les IRQ qui sont les interruptions matérielles (voir vecteur d'interruptions);
    - L'allocation de la mémoire aux composants;
    - L'adressage des ports aux composants.

    Après cette brève entrée en matière, parlons enfin d'éléments non négligeables présents sur nos PC's :

    - Le Bios : Le Basic Input Output System, contenue dans la ROM, permet d'effectuer des opérations élémentaires lors de sa mise sous tension, par exemple la lecture d'un secteur sur un disque. Lorsque le CPU reçoit le signal "Power Good" (en d'autres termes, la mise sous tension du PC par l'user), il exécute le code contenu dans le BIOS. Viens l'étape du POST (Power On Self-Test) où le BIOS vérifie les composants (état, attribution des ressources etc..), puis il suit la séquence de démarrage (amorçage), cherche la MBR (Master Boot Record) et charge le secteur de boot (DD). La globalité de ces informations est trouvée dans le CMOS (Complementary Metal Oxide Semiconductor) alimentée par une pile ce qui lui permet de garder les informations nécessaires (matériel, date, heure), lorsque le PC est éteint.
    En résumé, on peut considérer le bios comme une interface entre la Carte mère et l'OS. (intermédiaire)

    - Le Chipset : C'est en fait lui le fameux circuit pont, en quelque sorte. C'est l'élément responsable de la coordination des Bus, pour une meilleure communication entre les différents composants. Il est globalement composé de deux ponts (bridge) :
    ~ NorthBridge : Il régule les communications entre les bus rapides ou très rapides (FSB, Bus Mémoire, BUS AGP, BUS PCI-EXPRESS). On peut trouver dedans le contrôleur mémoire qui régule les échanges entre processeur et mémoire vive. Le cas échéant, on le trouve directement dans le processeur.
    ~ SouthBridge régule les communications avec les périphériques E/S (périphériques plus ou moins lents [bus]).

    N.B : Deux bus doivent avoir même largeur pour communiquer entre eux.

    - L'Alimentation : Et bien c'est simplement l'alimentation qui fait circuler le courant électrique nécessaire jusqu'à vos composants, afin qu'ils soient fonctionnels.
    Plus vos composants nécessitent de "voltage", plus une alimentation puissante (en Watts) et stable (marque de préférence) est recommandée. (surtout si vous comptez faire de l'overclocking)

    ----------

    Merci CRicky, merci Dafen.

    ++++

    N'hésitez pas à faire vos commentaires, propositions de correction si erreurs.
    Merci
  • Autres pages sur : tutoriel architecture globale annexe dafen

    18 Mars 2009 21:54:04

    posted
    m
    0
    l
    18 Mars 2009 21:54:16

    posted²
    m
    0
    l
    Contenus similaires
    18 Mars 2009 21:54:23

    Et puis zut...
    m
    0
    l
    18 Mars 2009 21:54:34

    J'ai deja dit "posted" ?
    m
    0
    l
    18 Mars 2009 22:09:18

    Respect pour tout ce que t'as écris! :D 

    On flood pas dafen.. :o 

    Sinon je participe.. :D 
    m
    0
    l
    19 Mars 2009 06:50:20

    Non :o 
    m
    0
    l
    19 Mars 2009 23:12:09

    UP :p 
    m
    0
    l
    19 Mars 2009 23:13:36

    Je crois que je vais passer le lien à mon prof d'architecture matériel.. :) 
    m
    0
    l
    19 Mars 2009 23:16:26

    Putin baleze le post ! Respect !
    m
    0
    l
    19 Mars 2009 23:30:29

    J'ai deja passe le lien a des amis en ecole d'ingenieur et Master 1 :D 

    Ils le trouvent tres bien.
    m
    0
    l
    19 Mars 2009 23:33:02

    y'a au moins un Helpeur d'intelligent, parce que Angel... :D 
    m
    0
    l
    19 Mars 2009 23:37:35

    Ca sera repete et amplifie :o 
    m
    0
    l
    20 Mars 2009 07:16:11

    C'est vrai Dafen ? :D 

    Citation :
    Je crois que je vais passer le lien à mon prof d'architecture matériel.. :) 

    Tu me diras ce qu'il en pense hein :o 

    Merci pour vos compliments, et si vous voyez des fautes, ne soyez pas indulgent :) 
    m
    0
    l
    Tom's guide dans le monde
    • Allemagne
    • Italie
    • Irlande
    • Royaume Uni
    • Etats Unis
    Suivre Tom's Guide
    Inscrivez-vous à la Newsletter
    • ajouter à twitter
    • ajouter à facebook
    • ajouter un flux RSS